Configurar ligações de identidade no Azure Kubernetes Service (AKS) (pré-visualização)

Configure ligações de identidade nos seus clusters do Azure Kubernetes Service (AKS) para mapear uma identidade gerida atribuída pelo utilizador (UAMI) em vários clusters, utilizando uma única credencial de identidade federada (FIC). Esta configuração ajuda-te a escalar a autenticação Microsoft Entra para cargas de trabalho sem atingir os limites do FIC.

Pré-requisitos

Reveja os conceitos de ligações de identidade para compreender como funcionam as ligações de identidade.
Azure CLI versão 2.73.0 ou posterior. Para verificar a sua versão, use o az version comando. Para instalar ou atualizar a CLI do Azure, consulte Instalar a CLI do Azure.
A versão aks-preview da extensão Azure CLI 18.0.0b26 ou posterior instalada.
O sinalizador de funcionalidade ativado para a tua subscrição.
Precisa das seguintes permissões Azure para a identidade e o âmbito do cluster: Microsoft.ManagedIdentity/userAssignedIdentities/federatedIdentityCredentials/write e Microsoft.ContainerService/managedClusters/write.
Precisas de permissões de administrador do cluster Kubernetes (ou equivalentes) para criar os recursos ClusterRole e ClusterRoleBinding.

Instale ou atualize a `aks-preview` extensão

Instale ou atualize a extensão do Azure CLI aks-preview para a versão mais recente usando o az extension add comando ou az extension update :

# Install the aks-preview extension
az extension add --name aks-preview

# Update to the latest version if already installed
az extension update --name aks-preview

Ativar o `IdentityBindingPreview` sinalizador de funcionalidades

Regista a flag de funcionalidade IdentityBindingPreview na tua subscrição do Azure utilizando o comando az feature register.
```
az feature register --namespace Microsoft.ContainerService --name IdentityBindingPreview
```
O registo de funcionalidades pode demorar até 15 minutos a concluir.

Espere que a funcionalidade termine de ser registada usando o az feature show comando.

az feature show --namespace Microsoft.ContainerService --name IdentityBindingPreview

Assim que a funcionalidade aparecer como Registered, atualize o registo do fornecedor usando o az provider register comando.
```
az provider register --namespace Microsoft.ContainerService
```

Limitações

As ligações de identidade ainda não são suportadas em clusters configurados com a integração da VNet do servidor API.

Criar recursos de teste

Crie um grupo de recursos do Azure usando o az group create comando.

export RESOURCE_GROUP="ib-test"
export LOCATION="westus2"

az group create --name $RESOURCE_GROUP --location $LOCATION

Crie um cluster AKS com identidade de trabalho e emissor OIDC ativados, usando o comando az aks create com as flags --enable-workload-identity e --enable-oidc-issuer.

export CLUSTER_NAME="ib-test-cluster"

az aks create --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME --location $LOCATION --no-ssh-key --enable-workload-identity --enable-oidc-issuer

Crie uma identidade gerida atribuída pelo utilizador (UAMI) usando o az identity create comando.

export MI_NAME="ib-test-mi"
az identity create --resource-group $RESOURCE_GROUP --name $MI_NAME

Verificar a versão do webhook de identidade de carga de trabalho

A vinculação de identidade requer a versão de pré-visualização do webhook de identidade do workload. Verifique a versão instalada do webhook usando o seguinte kubectl get pods comando:
```
kubectl -n kube-system get pods -l azure-workload-identity.io/system=true -o yaml | grep v1.6.0
```
O resultado deve aparecer v1.6.0-alpha.1 na etiqueta da imagem, que confirma que a versão correta está instalada.

Obtenha os IDs UAMI

Obtenha os IDs de recursos, principal, cliente e tenant do UAMI e defina-os como variáveis de ambiente usando os seguintes az identity show comandos:

export MI_RESOURCE_ID=$(az identity show --resource-group $RESOURCE_GROUP --name $MI_NAME --query id --output tsv)
export MI_PRINCIPAL_ID=$(az identity show --resource-group $RESOURCE_GROUP --name $MI_NAME --query principalId --output tsv)
export MI_CLIENT_ID=$(az identity show --resource-group $RESOURCE_GROUP --name $MI_NAME --query clientId --output tsv)
export MI_TENANT_ID=$(az identity show --resource-group $RESOURCE_GROUP --name $MI_NAME --query tenantId --output tsv)

Criar uma associação de identidade

Mapeie o UAMI para o cluster AKS com uma vinculação de identidade usando o comando az aks identity-binding create.
```
az aks identity-binding create --resource-group $RESOURCE_GROUP --cluster-name $CLUSTER_NAME --name "${MI_NAME}-ib" --managed-identity-resource-id $MI_RESOURCE_ID
```
Observação

Quando crias uma ligação de identidade, o AKS cria automaticamente uma credencial de identidade federada (FIC) nomeada aks-identity-binding dentro do UAMI. Esta credencial é gerida pela AKS. Não modifique nem apague enquanto as ligações de identidade estiverem em uso. O FIC criado para associações de identidade é partilhado entre todas as associações de identidade que referenciam o mesmo UAMI.

Obtenha o URL do emissor OIDC para o UAMI

Obtenha o URL do emissor OIDC associado ao UAMI inspecionando a ligação de identidade usando o comando az aks identity-binding show.

az aks identity-binding show --resource-group $RESOURCE_GROUP --cluster-name $CLUSTER_NAME --name "${MI_NAME}-ib"

Exemplo condensado:

{
  "oidcIssuer": {
    "oidcIssuerUrl": "https://ib.oic.prod-aks.azure.com/<MI-tenant-id>/<MI-client-id>"
  }
}

Conectar-se ao cluster AKS

Obtenha as credenciais do cluster AKS usando o az aks get-credentials comando e guarde-as num ficheiro kubeconfig separado:
```
az aks get-credentials --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME -a -f "${CLUSTER_NAME}.kubeconfig"
```
Defina a KUBECONFIG variável ambiente para apontar para o novo ficheiro kubeconfig:
```
export KUBECONFIG="$(pwd)/${CLUSTER_NAME}.kubeconfig"
```

Autorizar namespaces e contas de serviço

Configure o controlo de acesso baseado em funções (RBAC) para conceder permissão aos sujeitos específicos para utilizarem a identidade gerida através de ligação de identidade, aplicando o manifesto seguinte utilizando o comando kubectl apply a seguir.

Observação

O exemplo seguinte refere-se explicitamente à demo conta de serviço no demo namespace. Embora referir-se explicitamente a uma conta de serviço específica seja uma opção, também é possível referir-se a uma coleção de contas de serviço sob subjects. Para mais informações, veja Referência a assuntos na documentação do Kubernetes.

kubectl apply -f - <<EOF
apiVersion: v1
kind: Namespace
metadata:
  name: demo
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: demo
  namespace: demo
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: use-mi-${MI_CLIENT_ID}
rules:
  - verbs: ["use-managed-identity"]
    apiGroups: ["cid.wi.aks.azure.com"]
    resources: ["${MI_CLIENT_ID}"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: use-mi-${MI_CLIENT_ID}
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: use-mi-${MI_CLIENT_ID}
subjects:
  - kind: ServiceAccount
    name: demo
    namespace: demo
EOF

Crie um cofre de chaves com proteção contra purgas e autorização Azure RBAC

Crie um cofre de chaves com proteção contra purga e autorização Azure RBAC ativadas, usando o comando com as flags e . Também podes usar um cofre de chaves existente se estiver configurado tanto para proteção contra purgas como para autorização Azure RBAC.
```
export KEY_VAULT_NAME="ib-test"

az keyvault create \
    --name $KEY_VAULT_NAME \
    --resource-group $RESOURCE_GROUP \
    --location $LOCATION \
    --enable-purge-protection \
    --enable-rbac-authorization
```

Obtenha o ID e a URL do recurso do cofre de chaves

Obtenha o ID do recurso do cofre de chaves usando o az keyvault show comando e defina-o como variável de ambiente:

export KEY_VAULT_RESOURCE_ID=$(az keyvault show --resource-group $RESOURCE_GROUP \
    --name $KEY_VAULT_NAME \
    --query id \
    --output tsv)

Obtenha a URL do cofre de chaves usando o az keyvault show comando e defina-a como variável de ambiente:

export KEYVAULT_URL="$(az keyvault show \
    --resource-group $RESOURCE_GROUP \
    --name $KEY_VAULT_NAME \
    --query properties.vaultUri \
    --output tsv)"

Configurar o acesso ao cofre de chaves e criar segredo

Os passos seguintes mostram como aceder a segredos, chaves ou certificados no Azure Key Vault a partir 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 seguinte mostra como usar o modelo de permissões da Azure RBAC para conceder ao pod acesso ao Key Vault. Para mais informações sobre o modelo de permissões Azure RBAC para Azure Key Vault, consulte Conceder permissão a aplicações para aceder ao Azure Key Vault usando Azure RBAC.

Obtenha o ID do objeto do utilizador com sessão iniciada usando o comando az ad signed-in-user show e defina-o como variável de ambiente:
```
export CALLER_OBJECT_ID=$(az ad signed-in-user show --query id --output tsv)
```

Atribui-te a função Key Vault Secrets Officer do Azure RBAC no cofre de chaves usando o comando az role assignment create.

az role assignment create --assignee $CALLER_OBJECT_ID \
    --role "Key Vault Secrets Officer" \
    --scope $KEY_VAULT_RESOURCE_ID

Crie um segredo no cofre de chaves usando o az keyvault secret set comando.

export KEY_VAULT_SECRET_NAME="my-secret"

az keyvault secret set \
    --vault-name $KEY_VAULT_NAME \
    --name $KEY_VAULT_SECRET_NAME \
    --value "Hello\!"

Atribuir o papel de Utilizador de Segredos do Cofre de Chaves à UAMI, usando o comando az role assignment create.

az role assignment create \
    --assignee-object-id $MI_PRINCIPAL_ID \
    --role "Key Vault Secrets User" \
    --scope $KEY_VAULT_RESOURCE_ID \
    --assignee-principal-type ServicePrincipal

Conta de serviço para anotação

Anote a conta de serviço com o ID do tenant de identidade gerida usando o kubectl annotate comando.
```
kubectl annotate sa demo -n demo azure.workload.identity/tenant-id=$MI_TENANT_ID
```
Anote a conta de serviço com o ID do cliente de identidade gerida usando o kubectl annotate comando.
```
kubectl annotate sa demo -n demo azure.workload.identity/client-id=$MI_CLIENT_ID
```

Implementar aplicação de exemplo

Implemente o pod de exemplo que usa ligação de identidade para obter um token de acesso para que a identidade gerida aceda ao Azure Key Vault utilizando o seguinte comando kubectl apply:

kubectl apply -f - <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: demo
  namespace: demo
  labels:
    azure.workload.identity/use: "true"
  annotations:
    azure.workload.identity/use-identity-binding: "true"
spec:
  serviceAccount: demo
  containers:
    - name: azure-sdk
      # source code: https://github.com/Azure/azure-workload-identity/blob/feature/custom-token-endpoint/examples/identitybinding-msal-go/main.go
      image: ghcr.io/bahe-msft/azure-workload-identity/identitybinding-msal-go:latest-linux-amd64
      env:
        - name: KEYVAULT_URL
          value: ${KEYVAULT_URL}
        - name: SECRET_NAME
          value: ${KEY_VAULT_SECRET_NAME}
  restartPolicy: Never
EOF

Verificar o acesso ao cofre de chaves a partir da aplicação de exemplo

Descreva o pod e confirme que as variáveis de ambiente e as montagens de volumes de token projetados estão presentes usando o comando kubectl describe pod.
```
kubectl describe pod demo -n demo
```
A saída esperada deve conter valores para AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_FEDERATED_TOKEN_FILE, AZURE_AUTHORITY_HOST, AZURE_KUBERNETES_TOKEN_PROXY. AZURE_KUBERNETES_SNI_NAME, AZURE_KUBERNETES_CA_FILE.
Verifica se o pod pode obter um token e aceder ao recurso usando o kubectl logs comando.
```
kubectl logs demo -n demo
```
Se for bem-sucedida, a saída deve ser semelhante ao exemplo a seguir:
```
I1107 20:03:42.865180       1 main.go:77] "successfully got secret" secret="Hello!"
```

Escalonar as associações de identidade em múltiplos clusters

As ligações de identidade permitem mapear múltiplos clusters AKS para o mesmo UAMI enquanto ainda usam um único FIC. Para escalar ligações de identidade em vários clusters, pode repetir os passos desde Criar uma ligação de identidade até verificar o acesso ao cofre de chaves a partir da aplicação de exemplo para cada cluster adicional que desejar mapear para a mesma UAMI, criando uma nova ligação de identidade por cluster.

Limpeza de recursos

Se já não precisa dos recursos que criou neste artigo, pode limpá-los para evitar custos futuros.

Apaga o pod usando o kubectl delete pod comando.
```
kubectl delete pod demo -n demo
```
Apaga o namespace usando o kubectl delete ns comando.
```
kubectl delete ns demo
```
Apague o grupo de recursos e todos os recursos relacionados usando o az group delete comando.
```
az group delete --name $RESOURCE_GROUP --yes --no-wait
```

Conceitos de associações de identidade

Comentários

Esta página foi útil?

Last updated on 2026-01-28