Implantar e configurar o Workload Identity em um cluster do AKS Hybrid and Edge (prévia)

Aplica-se a: AKS no Azure Local

A federação de identidade de workload permite configurar uma identidade gerenciada atribuída pelo usuário ou o registro de aplicativo no Microsoft Entra ID para confiar em tokens de um provedor de identidade externo (IdP), como o Kubernetes, habilitando o acesso a recursos protegidos pelo Microsoft Entra, como o Azure Key Vault ou o armazenamento de Blob do Azure.

AKS (Serviço de Kubernetes do Azure) Hybrid and Edge é um serviço gerenciado de Kubernetes que permite implantar facilmente clusters do Kubernetes com identidade de carga de trabalho habilitada. Este artigo descreve como executar as seguintes tarefas:

  • Crie um cluster do AKS com a identidade da carga de trabalho habilitada (versão prévia).
  • Crie uma conta de serviço do Kubernetes e associe-a à identidade gerenciada do Azure.
  • Crie uma credencial federada na identidade gerenciada para estabelecer confiança com o emissor do OIDC.
  • Implante seu aplicativo.
  • Exemplo: conceda a um pod no cluster acesso a segredos em um cofre de chaves do Azure.

Para obter uma visão geral conceitual da federação de identidade de carga de trabalho, consulte Workload identity federation in Azure Arc-enabled Kubernetes (versão prévia).

Importante

Esses recursos de visualização estão disponíveis em uma base de autoatendimento e de adesão voluntária. As versões prévias são fornecidas “no estado em que se encontram” e “conforme disponíveis” e são excluídas dos contratos de nível de serviço e da garantia limitada. As versões prévias do Serviço de Kubernetes do Azure, Hybrid e Edge contam com suporte parcial ao cliente, prestado em regime de "melhor esforço".

Note

Em versão prévia, o AKS no Azure Local permite habilitar a identidade de carga de trabalho durante a criação do cluster AKS. No entanto, não há suporte para habilitar a identidade da carga de trabalho após a criação do cluster ou desabilitá-la posteriormente.

Pré-requisitos

Antes de implantar um cluster Kubernetes com o Azure Arc habilitado, você deve ter os seguintes pré-requisitos:

  • Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.
  • Versão 1.4.23 ou posterior da CLI do Azure. Se você está usando o Azure Cloud Shell, a última versão já está instalada.

Exportar variáveis de ambiente

Para simplificar as etapas para configurar as identidades necessárias, execute os comandos a seguir para definir variáveis de ambiente. Os exemplos neste artigo fazem referência a essas variáveis. Substitua os seguintes valores por seus próprios valores:

$AZSubscriptionID = "00000000-0000-0000-0000-000000000000" 
$Location = "westeurope" 
$resource_group_name = "myResourceGroup" 

$aks_cluster_name = "myAKSCluster" 

$SERVICE_ACCOUNT_NAMESPACE = "default" 
$SERVICE_ACCOUNT_NAME = "workload-identity-sa" 

$FedIdCredentialName = "myFedIdentity" 
$MSIName = "myIdentity" 

# To access key vault secrets from a pod in the cluster, include these variables:
$KVName = "KV-workload-id" 
$KVSecretName= "KV-secret"

Definir a assinatura ativa

Primeiro, defina sua assinatura como a assinatura ativa atual. Execute o comando az account set com seu ID de assinatura:

az login  
az account set -s $AZSubscriptionID

Criar um grupo de recursos

Um grupo de recursos Azure é um grupo lógico no qual Azure recursos são implantados e gerenciados. Ao criar um grupo de recursos, você é solicitado a especificar um local. Esse local é o local de armazenamento dos metadados do grupo de recursos e onde seus recursos são executados em Azure se você não especificar outra região durante a criação de recursos.

Para criar um grupo de recursos, execute o comando az group create:

az group create --name $resource_group_name --location $Location

O exemplo de saída a seguir mostra a criação bem-sucedida de um grupo de recursos:

{ 
  "id": "/subscriptions/<guid>/resourceGroups/myResourceGroup", 
  "location": "westeurope", 
  "managedBy": null, 
  "name": "$resource_group_name", 
  "properties": { 
    "provisioningState": "Succeeded" 
  }, 
  "tags": null 
}

Etapa 1: criar um cluster do AKS com a identidade da carga de trabalho habilitada

Para criar um cluster do AKS, você precisa dos valores $customlocation_ID e $logicnet_Id.

  • $customlocation_ID: o ID do Azure Resource Manager do local personalizado. O local personalizado é configurado durante a implantação do cluster local do Azure. O administrador de infraestrutura deve fornecer a ID do Gerenciador de Recursos do local personalizado. Você também pode obter o ID do Gerenciador de Recursos executando $customlocation_ID = $(az customlocation show --name "<your-custom-location-name>" --resource-group $resource_group_name --query "id" -o tsv), se o administrador da infraestrutura fornecer um nome de local personalizado e um nome de grupo de recursos.
  • $logicnet_Id: o ID do Azure Resource Manager da rede lógica Local do Azure criado seguindo essas etapas. Seu administrador de infraestrutura deve lhe fornecer o ID do Resource Manager da rede lógica. Você também pode obter o ID do Gerenciador de Recursos executando $logicnet_Id = $(az stack-hci-vm network lnet show --name "<your-lnet-name>" --resource-group $resource_group_name --query "id" -o tsv), caso o administrador da infraestrutura forneça um nome de rede lógica e um nome de grupo de recursos.

Execute o comando az aksarc create com o parâmetro --enable-oidc-issuer --enable-workload-identity. Forneça seu entra-admin-group-object-ids e verifique se você é membro do grupo de administradores do Microsoft Entra ID para acesso ao modo proxy:

az aksarc create  
-n $aks_cluster_name -g $resource_group_name  
--custom-location $customlocation_ID --vnet-ids $logicnet_Id  
--aad-admin-group-object-ids <entra-admin-group-object-ids> 
--generate-ssh-keys  
--enable-oidc-issuer --enable-workload-identity

Após alguns minutos, o comando será concluído e retornará informações no formato JSON sobre o cluster.

Pode levar algum tempo para que a extensão de identidade de workload seja implantada após a criação bem-sucedida de um cluster provisionado. Use o seguinte comando para verificar o status da extensão da identidade do workload:

az connectedk8s show -n $aks_cluster_name -g $resource_group_name
# agentState = "Succeeded" 
"agentPublicKeyCertificate": "", 
  "agentVersion": "1.21.10", 
  "arcAgentProfile": { 
    "agentAutoUpgrade": "Enabled", 
    "agentErrors": [], 
    "agentState": "Succeeded", 
    "desiredAgentVersion": "", 
    "systemComponents": null 

# oidcIssuerProfile "enabled": true and "issuerUrl" present 

"oidcIssuerProfile": { 
    "enabled": true, 
    "issuerUrl": "https://oidcdiscovery-{location}-endpoint-1111111111111111.000.azurefd.net/00000000-0000-0000-0000-000000000000/11111111-1111-1111-1111-111111111111/"}

No portal do Azure, você pode exibir a extensão wiextension na seção Propriedades de seu cluster Kubernetes.

Importante

Como parte do aprimoramento de segurança para clusters AKS, a habilitação da identidade de carga de trabalho aciona duas alterações. Primeiro, a chave de assinatura da conta de serviço do Kubernetes gira automaticamente a cada 45 dias. Em segundo lugar, o sinalizador --service-account-extend-token-expiration é desabilitado, reduzindo a validade do token de um ano para um máximo de 24 horas.

Salvar o URL do emissor do OIDC em uma variável de ambiente

Depois que o cluster do AKS for criado com êxito, você poderá obter a URL do emissor do OIDC e salvá-la em uma variável de ambiente. Execute o comando a seguir:

$SERVICE_ACCOUNT_ISSUER =$(az connectedk8s show --n $aks_cluster_name --resource-group $resource_group_name --query "oidcIssuerProfile.issuerUrl" --output tsv)

Etapa 2: crie uma conta de serviço do Kubernetes e vincule-a à identidade gerenciada do Azure

Primeiro, crie uma identidade gerenciada. Execute o comando az identity create:

az identity create --name $MSIName --resource-group $resource_group_name --location $Location --subscription $AZSubscriptionID

Em seguida, crie variáveis para a ID do cliente da identidade gerenciada:

$MSIId=$(az identity show --resource-group $resource_group_name --name $MSIName --query 'clientId' --output tsv)
$MSIPrincipalId=$(az identity show --resource-group $resource_group_name --name $MSIName --query 'principalId' --output tsv)

Criar uma conta de serviço do Kubernetes

Nesta etapa, você cria uma conta de serviço do Kubernetes e a anota com a ID do cliente da identidade gerenciada que você criou na etapa anterior.

Use a conexão de cluster para acessar seu cluster a partir de um dispositivo cliente. Para obter mais informações, consulte Acessar seu cluster de um dispositivo cliente:

az connectedk8s proxy -n $aks_cluster_name -g $resource_group_name

Abra uma nova janela de comando da CLI. Copie e cole os seguintes comandos:

$yaml = @"
apiVersion: v1
kind: ServiceAccount
metadata:
  annotations:
    azure.workload.identity/client-id: $MSIId
  name: $SERVICE_ACCOUNT_NAME
  namespace: $SERVICE_ACCOUNT_NAMESPACE
"@

$yaml = $yaml -replace '\$MSIId', $MSIId `
               -replace '\$SERVICE_ACCOUNT_NAME', $SERVICE_ACCOUNT_NAME `
               -replace '\$SERVICE_ACCOUNT_NAMESPACE', $SERVICE_ACCOUNT_NAMESPACE

$yaml | kubectl apply -f -

A saída a seguir mostra a criação bem-sucedida da conta de serviço:

serviceaccount/workload-identity-sa created

Etapa 3: crie uma credencial federada na identidade gerenciada para confiar no emissor do OIDC

Primeiro, crie uma credencial de identidade federada. Use o comando az identity federated-credential create para criar a credencial de identidade federada entre a identidade gerenciada, o emissor da conta de serviço e o assunto. Para obter mais informações sobre credenciais de identidade federadas em Microsoft Entra, consulte Overview das credenciais de identidade federadas em Microsoft Entra ID.

# Create a federated credential 

az identity federated-credential create --name $FedIdCredentialName --identity-name $MSIName --resource-group $resource_group_name --issuer $SERVICE_ACCOUNT_ISSUER --subject "system:serviceaccount:${SERVICE_ACCOUNT_NAMESPACE}:${SERVICE_ACCOUNT_NAME}" 

# Show the federated credential 

az identity federated-credential show --name $FedIdCredentialName --resource-group $resource_group_name --identity-name $MSIName

Note

Depois de adicionar uma credencial de identidade federada, ela leva alguns segundos para se propagar. As solicitações de token feitas imediatamente depois podem falhar até que o cache seja atualizado. Para evitar esse problema, considere adicionar um breve atraso após a criação da credencial de identidade federada.

Etapa 4: Implantar o aplicativo

Quando você implanta seus pods de aplicativos, o manifesto deve fazer referência à conta de serviço criada na etapa Criar conta de serviço do Kubernetes. O seguinte manifesto mostra como referenciar a conta, especificamente as propriedades metadata\namespace e spec\serviceAccountName. Especifique uma imagem para image e um nome de contêiner para containerName:

$image = "<image>"  # Replace <image> with the actual image name 
$containerName = "<containerName>"  # Replace <containerName> with the actual container name 

$yaml = @" 
apiVersion: v1 
kind: Pod 
metadata: 
  name: sample-quick-start 
  namespace: $SERVICE_ACCOUNT_NAMESPACE 
  labels: 
    azure.workload.identity/use: "true" # Required. Only pods with this label can use workload identity. 
spec: 
  serviceAccountName: $SERVICE_ACCOUNT_NAME 
  containers: 
    - image: $image 
      name: $containerName 
"@ 

# Replace variables within the YAML content 
$yaml = $yaml -replace '\$SERVICE_ACCOUNT_NAMESPACE', $SERVICE_ACCOUNT_NAMESPACE ` 
                -replace '\$SERVICE_ACCOUNT_NAME', $SERVICE_ACCOUNT_NAME 

# Apply the YAML configuration 
$yaml | kubectl apply -f - 

Importante

Certifique-se de que os pods do aplicativo que usam a identidade da carga de trabalho incluam o rótulo azure.workload.identity/use: "true" na especificação do pod. Caso contrário, os pods falharão após a reinicialização.

Exemplo: conceder permissões para acessar Azure Key Vault

As instruções nesta etapa descrevem como acessar segredos, chaves ou certificados em um Azure Key Vault do pod. Os exemplos nesta seção configuram o acesso a segredos no cofre de chaves para a identidade da carga de trabalho, mas você pode executar etapas semelhantes para configurar o acesso a chaves ou certificados.

O exemplo a seguir mostra como usar o modelo de permissão do RBAC (controle de acesso baseado em função) do Azure para conceder ao pod acesso ao cofre de chaves. Para obter mais informações sobre o modelo de permissão Azure RBAC para o Azure Key Vault, consulte Conceder permissão para aplicativos acessarem um cofre de chaves do Azure usando Azure RBAC.

  1. Crie um cofre de chaves com proteção contra limpeza e autorização RBAC habilitada. Você também pode usar um cofre de chaves existente se ele estiver configurado tanto para proteção contra exclusão definitiva quanto para autorização RBAC:

    az keyvault create --name $KVName --resource-group $resource_group_name --location $Location --enable-purge-protection --enable-rbac-authorization
    
    # retrieve the key vault ID for role assignment
    $KVId=$(az keyvault show --resource-group $resource_group_name --name $KVName --query id --output tsv)
    
  2. Atribua a função RBAC Responsável pelos segredos do Key Vault a si mesmo para que você possa criar um segredo no novo cofre de chaves. Novas atribuições de função podem levar até cinco minutos para serem propagadas e atualizadas pelo servidor de autorização.

    $CALLER_OBJECT_ID=$(az ad signed-in-user show --query id -o tsv)
    
    az role assignment create --assignee-object-id $CALLER_OBJECT_ID --role "Key Vault Secrets Officer" --scope $KVId --assignee-principal-type ServicePrincipal
    
  3. Crie um segredo no cofre de chaves:

    az keyvault secret set --vault-name $KVName --name $KVSecretName --value "Hello!"
    
  4. Atribua a função Key Vault Secrets User à identidade gerenciada atribuída pelo usuário que você criou anteriormente. Esta etapa permite à identidade gerenciada ler segredos do Key Vault.

    $IDENTITY_PRINCIPAL_ID=$(az identity show --name "$USER_ASSIGNED_IDENTITY_NAME" --resource-group "$resource_group_name" --query principalId --output tsv)
    
    az role assignment create --assignee-object-id $IDENTITY_PRINCIPAL_ID --role "Key Vault Secrets User" --scope $KVId --assignee-principal-type ServicePrincipal
    
  5. Crie uma variável de ambiente para a URL do cofre de chaves:

    $KVUrl=$(az keyvault show --resource-group $resource_group_name --name $KVName --query properties.vaultUri --output tsv)
    
  6. Implante um pod que faça referência à conta de serviço e à URL do cofre de chaves:

    $yaml = @" 
    apiVersion: v1 
    kind: Pod 
    metadata: 
      name: sample-quick-start 
      namespace: $SERVICE_ACCOUNT_NAMESPACE 
      labels: 
        azure.workload.identity/use: "true" 
    spec: 
      serviceAccountName: $SERVICE_ACCOUNT_NAME 
      containers: 
        - image: ghcr.io/azure/azure-workload-identity/msal-go 
          name: oidc 
          env: 
          - name: KEYVAULT_URL 
            value: $KVUrl 
          - name: SECRET_NAME 
            value: $KVSecretName 
      nodeSelector: 
        kubernetes.io/os: linux 
    "@ 
    
    # Replace variables within the YAML content 
    $yaml = $yaml -replace '\$SERVICE_ACCOUNT_NAMESPACE', $SERVICE_ACCOUNT_NAMESPACE ` 
                    -replace '\$SERVICE_ACCOUNT_NAME', $SERVICE_ACCOUNT_NAME ` 
                    -replace '\$KVUrl', $KVUrl ` 
                    -replace '\$KVSecretName', $KVSecretName 
    
    # Apply the YAML configuration 
    $yaml | kubectl --kubeconfig <path-to-aks-cluster-kubeconfig> apply -f -
    

Excluir cluster do AKS

Para excluir o cluster do AKS, use o comando az aksarc delete :

az aksarc delete -n $aks_cluster_name -g $resource_group_name

Próximas Etapas 

Neste artigo, você implantou um cluster do Kubernetes e configurou-o para usar uma identidade de carga de trabalho em preparação para cargas de trabalho de aplicativo a serem autenticadas com essa credencial. Agora você está pronto para implantar seu aplicativo e configurá-lo para usar a identidade da carga de trabalho com a versão mais recente da biblioteca de clientes Azure Identity.

Você também pode ajudar a proteger seu cluster de outras maneiras seguindo as diretrizes no livro de segurança para AKS Híbrido e Edge.