Implantar e configurar a identidade da carga de trabalho em um cluster do Serviço Kubernetes do Azure (AKS)

Artigo
04/16/2024

O Serviço Kubernetes do Azure (AKS) é um serviço Kubernetes gerenciado que permite implantar e gerenciar clusters Kubernetes rapidamente. Neste artigo, vai:

Implantar um cluster AKS usando a CLI do Azure que inclui o Emissor do OpenID Connect e uma ID de Carga de Trabalho do Microsoft Entra
Conceder acesso ao seu Cofre de Chaves do Azure
Criar um ID de carga de trabalho do Microsoft Entra e uma conta de serviço do Kubernetes
Configure a identidade gerenciada para federação de tokens.

Este artigo pressupõe que você tenha uma compreensão básica dos conceitos do Kubernetes. Para obter mais informações, consulte Conceitos principais do Kubernetes para o Serviço Kubernetes do Azure (AKS). Se você não estiver familiarizado com o ID de carga de trabalho do Microsoft Entra, consulte o seguinte artigo Visão geral .

Este artigo requer a versão 2.47.0 ou posterior da CLI do Azure. Se estiver usando o Azure Cloud Shell, a versão mais recente já está instalada.
A identidade que você está usando para criar seu cluster tem as permissões mínimas apropriadas. Para obter mais informações sobre acesso e identidade para AKS, consulte Opções de acesso e identidade para o Serviço Kubernetes do Azure (AKS).
Se você tiver várias assinaturas do Azure, selecione a ID de assinatura apropriada na qual os recursos devem ser cobrados usando o comando az account .

Nota

Em vez de configurar todas as etapas manualmente, há outra implementação chamada Service Connector que irá ajudá-lo a configurar algumas etapas automaticamente e alcançar o mesmo resultado. Consulte também: Tutorial: Conectar-se à conta de armazenamento do Azure no Serviço Kubernetes do Azure (AKS) com o Service Connector usando a identidade da carga de trabalho.

Exportar variáveis de ambiente

Para ajudar a simplificar as etapas de configuração das identidades necessárias, as etapas abaixo definem variáveis de ambiente para referência no cluster.

Execute os seguintes comandos para criar essas variáveis. Substitua os valores padrão para RESOURCE_GROUP, LOCATION, SERVICE_ACCOUNT_NAME, SUBSCRIPTION, USER_ASSIGNED_IDENTITY_NAMEe FEDERATED_IDENTITY_CREDENTIAL_NAME.

export RESOURCE_GROUP="myResourceGroup"
export LOCATION="westcentralus"
export SERVICE_ACCOUNT_NAMESPACE="default"
export SERVICE_ACCOUNT_NAME="workload-identity-sa"
export SUBSCRIPTION="$(az account show --query id --output tsv)"
export USER_ASSIGNED_IDENTITY_NAME="myIdentity"
export FEDERATED_IDENTITY_CREDENTIAL_NAME="myFedIdentity"

Criar um cluster do AKS

Crie um cluster AKS usando o comando az aks create com o --enable-oidc-issuer parâmetro para usar o Emissor OIDC. O exemplo a seguir cria um cluster chamado myAKSCluster com um nó no myResourceGroup:

az aks create -g "${RESOURCE_GROUP}" -n myAKSCluster --enable-oidc-issuer --enable-workload-identity --generate-ssh-keys

Após alguns minutos, o comando conclui e retorna informações formatadas em JSON sobre o cluster.

Nota

Quando você cria um cluster AKS, um segundo grupo de recursos é criado automaticamente para armazenar os recursos do AKS. Para obter mais informações, consulte Por que dois grupos de recursos são criados com o AKS?.

Atualizar um cluster AKS existente

Você pode atualizar um cluster AKS usando o comando az aks update com o --enable-oidc-issuer parâmetro e --enable-workload-identity para usar o Emissor OIDC e habilitar a identidade da carga de trabalho. O exemplo a seguir atualiza um cluster chamado myAKSCluster:

az aks update -g "${RESOURCE_GROUP}" -n myAKSCluster --enable-oidc-issuer --enable-workload-identity

Recuperar o URL do emissor OIDC

Para obter a URL do emissor OIDC e salvá-la em uma variável ambiental, execute o seguinte comando. Substitua o valor padrão para os argumentos -n, que é o nome do cluster:

export AKS_OIDC_ISSUER="$(az aks show -n myAKSCluster -g "${RESOURCE_GROUP}" --query "oidcIssuerProfile.issuerUrl" -o tsv)"

A variável deve conter o URL do Emissor semelhante ao exemplo a seguir:

https://eastus.oic.prod-aks.azure.com/00000000-0000-0000-0000-000000000000/11111111-1111-1111-1111-111111111111/

Por padrão, o Emissor é definido para usar a URL https://{region}.oic.prod-aks.azure.com/{tenant_id}/{uuid}base, onde o valor para {region} corresponde ao local em que o cluster AKS está implantado. O valor {uuid} representa a chave OIDC.

Criar uma identidade gerenciada

Use o comando Azure CLI az account set para definir uma assinatura específica como sendo a assinatura ativa atual. Em seguida, use o comando az identity create para criar uma identidade gerenciada.

az identity create --name "${USER_ASSIGNED_IDENTITY_NAME}" --resource-group "${RESOURCE_GROUP}" --location "${LOCATION}" --subscription "${SUBSCRIPTION}"

Em seguida, vamos criar uma variável para o ID de identidade gerenciado.

export USER_ASSIGNED_CLIENT_ID="$(az identity show --resource-group "${RESOURCE_GROUP}" --name "${USER_ASSIGNED_IDENTITY_NAME}" --query 'clientId' -o tsv)"

Criar conta de serviço do Kubernetes

Crie uma conta de serviço Kubernetes e anote-a com o ID do cliente da identidade gerenciada criada na etapa anterior. Use o comando az aks get-credentials e substitua os valores do nome do cluster e do nome do grupo de recursos.

az aks get-credentials -n myAKSCluster -g "${RESOURCE_GROUP}"

Copie e cole a seguinte entrada de várias linhas na CLI do Azure.

cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: ServiceAccount
metadata:
  annotations:
    azure.workload.identity/client-id: "${USER_ASSIGNED_CLIENT_ID}"
  name: "${SERVICE_ACCOUNT_NAME}"
  namespace: "${SERVICE_ACCOUNT_NAMESPACE}"
EOF

A saída a seguir se assemelha à criação bem-sucedida da identidade:

serviceaccount/workload-identity-sa created

Estabelecer 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.

az identity federated-credential create --name ${FEDERATED_IDENTITY_CREDENTIAL_NAME} --identity-name "${USER_ASSIGNED_IDENTITY_NAME}" --resource-group "${RESOURCE_GROUP}" --issuer "${AKS_OIDC_ISSUER}" --subject system:serviceaccount:"${SERVICE_ACCOUNT_NAMESPACE}":"${SERVICE_ACCOUNT_NAME}" --audience api://AzureADTokenExchange

Nota

A propagação da credencial de identidade federada demora alguns segundos depois de ter sido inicialmente adicionada. Se uma solicitação de token for feita imediatamente após a adição da credencial de identidade federada, isso poderá levar a uma falha por alguns minutos, pois o cache é preenchido no diretório com dados antigos. Para evitar esse problema, você pode adicionar um pequeno atraso após adicionar a credencial de identidade federada.

Implementar a sua aplicação

Quando você implanta seus pods de aplicativo, o manifesto deve fazer referência à conta de serviço criada na etapa Criar conta de serviço do Kubernetes. O manifesto a seguir mostra como fazer referência à conta, especificamente metadata\namespace e spec\serviceAccountName propriedades:

cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: your-pod
  namespace: "${SERVICE_ACCOUNT_NAMESPACE}"
  labels:
    azure.workload.identity/use: "true"  # Required, only the pods with this label can use workload identity
spec:
  serviceAccountName: "${SERVICE_ACCOUNT_NAME}"
  containers:
    - image: <your image>
      name: <containerName>
EOF

Importante

Certifique-se de que seus pods de aplicativo usando a identidade de carga de trabalho tenham adicionado o seguinte rótulo azure.workload.identity/use: "true" à sua especificação de pod, caso contrário, os pods falharão após serem reiniciados.

Opcional - Conceder permissões para acessar o Azure Key Vault

Esta etapa é necessária se você precisar acessar segredos, chaves e certificados montados no Cofre de Chaves do Azure a partir de um pod. Execute as etapas a seguir para configurar o acesso com uma identidade gerenciada. Estas etapas pressupõem que você tenha um Cofre da Chave do Azure já criado e configurado em sua assinatura. Se você não tiver um, consulte Criar um Cofre de Chaves do Azure usando a CLI do Azure.

Antes de prosseguir, você precisa das seguintes informações:

Nome do Cofre da Chave
Grupo de recursos que detém o Cofre da Chave

Você pode recuperar essas informações usando o comando da CLI do Azure: az keyvault list.

Defina uma política de acesso para a identidade gerenciada para acessar segredos no Cofre da Chave executando os seguintes comandos:

export KEYVAULT_RESOURCE_GROUP="myResourceGroup"
export KEYVAULT_NAME="myKeyVault"
export USER_ASSIGNED_CLIENT_ID="$(az identity show --resource-group "${RESOURCE_GROUP}" --name "${USER_ASSIGNED_IDENTITY_NAME}" --query 'clientId' -o tsv)"

az keyvault set-policy --name "${KEYVAULT_NAME}" --secret-permissions get --spn "${USER_ASSIGNED_CLIENT_ID}"

Crie um segredo no Cofre da Chave:

export KEYVAULT_SECRET_NAME="my-secret"

az keyvault secret set --vault-name "${KEYVAULT_NAME}" \
   --name "${KEYVAULT_SECRET_NAME}" \
   --value "Hello\!"

URL do Cofre da Chave de Exportação:

export KEYVAULT_URL="$(az keyvault show -g ${KEYVAULT_RESOURCE_GROUP} -n ${KEYVAULT_NAME} --query properties.vaultUri -o tsv)"

Implante um pod que faça referência à conta de serviço e ao URL do Cofre de Chaves acima:

cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: 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: ${KEYVAULT_URL}
      - name: SECRET_NAME
        value: ${KEYVAULT_SECRET_NAME}
  nodeSelector:
    kubernetes.io/os: linux
EOF

Para verificar se todas as propriedades são injetadas corretamente pelo webhook, use o comando kubectl describe :

kubectl describe pod quick-start | grep "SECRET_NAME:"

Se for bem-sucedida, a saída deve ser semelhante à seguinte:

      SECRET_NAME:                 ${KEYVAULT_SECRET_NAME}

Para verificar se o pod é capaz de obter um token e acessar o recurso, use o comando kubectl logs:

kubectl logs quick-start

Se for bem-sucedida, a saída deve ser semelhante à seguinte:

I0114 10:35:09.795900       1 main.go:63] "successfully got secret" secret="Hello\\!"

Desabilitar a identidade da carga de trabalho

Para desativar o ID de carga de trabalho do Microsoft Entra no cluster AKS onde ele foi habilitado e configurado, você pode executar o seguinte comando:

az aks update --resource-group "${RESOURCE_GROUP}" --name myAKSCluster --disable-workload-identity

Próximos passos

Neste artigo, você implantou um cluster Kubernetes e o configurou para usar uma identidade de carga de trabalho em preparação para cargas de trabalho de aplicativo para autenticação 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 cliente do Azure Identity . Se não for possível reescrever seu aplicativo para usar a versão mais recente da biblioteca do cliente, você poderá configurar seu pod de aplicativo para autenticar usando identidade gerenciada com identidade de carga de trabalho como uma solução de migração de curto prazo.

Implantar e configurar a identidade da carga de trabalho em um cluster do Serviço Kubernetes do Azure (AKS)

Exportar variáveis de ambiente

Criar um cluster do AKS

Atualizar um cluster AKS existente

Recuperar o URL do emissor OIDC

Criar uma identidade gerenciada

Criar conta de serviço do Kubernetes

Estabelecer credencial de identidade federada

Implementar a sua aplicação

Opcional - Conceder permissões para acessar o Azure Key Vault

Desabilitar a identidade da carga de trabalho

Próximos passos

Recursos adicionais