Configurar associações de identidade no AKS (Serviço de Kubernetes do Azure) (versão prévia)

Configure associações de identidade em seus clusters do Serviço de Kubernetes do Azure (AKS) para mapear uma identidade gerenciada atribuída pelo usuário (UAMI) em vários clusters, usando uma única credencial de identidade federada (FIC). Essa configuração ajuda você a dimensionar a autenticação do Microsoft Entra para cargas de trabalho sem atingir os limites de FIC.

Pré-requisitos

Examine os conceitos de associações de identidade para entender como as associações de identidade funcionam.
CLI do Azure versão 2.73.0 ou posterior. Para verificar sua versão, use o az version comando. Para instalar ou atualizar a CLI do Azure, consulte Instalar a CLI do Azure.
The versão da extensão da CLI do Azureaks-preview18.0.0b26 ou mais recente instalada.
O IdentityBindingPreview sinalizador de recurso habilitado para sua assinatura.
Você precisa das seguintes permissões do Azure no escopo de identidade e cluster: Microsoft.ManagedIdentity/userAssignedIdentities/federatedIdentityCredentials/write e Microsoft.ContainerService/managedClusters/write.
Você precisa de permissões de administrador de cluster do Kubernetes (ou equivalente) para criar ClusterRole e ClusterRoleBinding recursos.

Instalar ou atualizar a `aks-preview` extensão

Instale ou atualize a extensão da CLI aks-preview do Azure para a versão mais recente usando os comandos az extension add 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

Habilite o sinalizador de recurso `IdentityBindingPreview`:

Registre o IdentityBindingPreview sinalizador de recurso em sua assinatura do Azure usando o comando az feature register.
```
az feature register --namespace Microsoft.ContainerService --name IdentityBindingPreview
```
O registro de recursos pode levar até 15 minutos para ser concluído.

Aguarde até que o recurso termine de se registrar usando o az feature show comando.

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

Depois que o recurso for mostrado como Registered, atualize o registro do provedor usando o az provider register comando.
```
az provider register --namespace Microsoft.ContainerService
```

Limitações

Ainda não há suporte para vínculos de identidade em clusters configurados com a integração do servidor de API com a VNet.

Criar recursos de teste

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

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

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

Crie um cluster AKS com identidade de carga de trabalho e emissor OIDC habilitados usando o comando az aks create com os sinalizadores --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 UAMI (identidade gerenciada) atribuída pelo usuário 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 identidades de carga de trabalho

A associação de identidade requer a versão prévia do webhook de identidades de carga de trabalho. Verifique a versão do webhook instalada 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
```
A saída deve ser mostrada como v1.6.0-alpha.1 na tag de imagem, o que confirma que a versão correta está instalada.

Obter os IDs UAMI

Obtenha as IDs de recurso, principal, cliente e tenant da UAMI e defina-as 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 do AKS com uma associaçã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 uma associação de identidade é criada, o AKS cria automaticamente uma credencial de identidade federada (FIC) denominada aks-identity-binding sob a UAMI. Essa credencial é gerenciada pelo AKS. Não modifique ou exclua-o enquanto as associações de identidade estiverem em uso. O FIC criado para associações de identidade é compartilhado em todas as associações de identidade que fazem referência à mesma UAMI.

Obter a URL do emissor do OIDC para o UAMI

Tenha a URL do emissor OIDC associada à 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"

Saída de exemplo condensada:

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

Conecte-se ao cluster do AKS

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

Autorizar namespaces e contas de serviço

Configure o controle de acesso baseado em função (RBAC) para conceder aos sujeitos específicos a permissão para usar a identidade gerenciada através da associação de identidade aplicando o manifesto a seguir usando o seguinte comando kubectl apply.

Observação

O exemplo a seguir refere-se explicitamente à conta de serviço demo no espaço de nomes demo. Embora a referência explícita a uma conta de serviço específica seja uma opção, também é possível fazer referência a uma coleção de contas de serviço sob subjects. Para obter mais informações, consulte Referência a Tópicos 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 limpeza e autorização RBAC do Azure.

Crie um cofre de chaves com proteção contra exclusão e autorização RBAC do Azure habilitada usando o comando az keyvault create com os sinalizadores --enable-purge-protection e --enable-rbac-authorization. Você também poderá usar um cofre de chaves existente se ele estiver configurado para proteção de purga e autorização do 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 identificador e a URL do recurso do cofre de chaves

Obtenha a ID do recurso do cofre de chaves usando o comando e defina-a az keyvault show como uma 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 comando e defina-a az keyvault show como uma 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

As etapas a seguir mostram como acessar segredos, chaves ou certificados no 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 RBAC do Azure para conceder acesso do pod ao Key Vault. Para obter mais informações sobre o modelo de permissão do RBAC do Azure para o Azure Key Vault, consulte Conceder permissão aos aplicativos para acessar o Azure Key Vault usando o RBAC do Azure.

Obtenha a ID do objeto do usuário conectado usando o comando e defina-a az ad signed-in-user show como uma variável de ambiente:
```
export CALLER_OBJECT_ID=$(az ad signed-in-user show --query id --output tsv)
```

Atribua a si mesmo a função de 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 comando az keyvault secret set.

export KEY_VAULT_SECRET_NAME="my-secret"

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

Atribua a função Key Vault Secrets User ao 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

Anotar conta de serviço

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

Implantar um aplicativo de exemplo

Implante o pod de exemplo que usa a associação de identidade para obter um token de acesso para a identidade gerenciada para acessar o Azure Key Vault usando o seguinte kubectl apply comando:

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 do aplicativo de exemplo

Descreva o pod e confirme se as variáveis de ambiente e as montagens de volume de token projetadas estão presentes usando o kubectl describe pod comando.
```
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 e AZURE_KUBERNETES_CA_FILE.
Verifique se o pod pode obter um token e acessar o recurso usando o kubectl logs comando.
```
kubectl logs demo -n demo
```
Se bem-sucedida, a saída deverá ser semelhante ao seguinte exemplo:
```
I1107 20:03:42.865180       1 main.go:77] "successfully got secret" secret="Hello!"
```

Dimensionar associações de identidade em vários clusters

As associações de identidade permitem mapear vários clusters do AKS para a mesma UAMI enquanto ainda usam apenas um FIC. Para dimensionar as vinculações de identidade em múltiplos clusters, você pode repetir as etapas de Criar uma associação de identidade até verificar o acesso ao cofre de chaves a partir de um aplicativo de exemplo para cada cluster extra que você deseja mapear para o mesmo UAMI (criando uma nova vinculação de identidade por cluster).

Limpar os recursos

Se você não precisar mais dos recursos criados neste artigo, poderá limpá-los para evitar incorrer em custos futuros.

Exclua o pod usando o comando kubectl delete pod.
```
kubectl delete pod demo -n demo
```
Exclua o namespace usando o kubectl delete ns comando.
```
kubectl delete ns demo
```
Exclua 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