Share via

Tutorial: Usar uma identidade de carga de trabalho com um aplicativo no Serviço Kubernetes do Azure (AKS)

  • Artigo

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

  • Implante um cluster AKS usando a CLI do Azure com o Emissor OpenID Connect (OIDC) e a identidade gerenciada.
  • Crie um Cofre da Chave do Azure e um segredo.
  • Crie 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.
  • Implante a carga de trabalho e verifique a autenticação com a identidade da carga de trabalho.

Antes de começar

Pré-requisitos

Criar um grupo de recursos

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

O exemplo seguinte cria um grupo de recursos com o nome myResourceGroup na localização eastus.

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

    az group create --name myResourceGroup --location eastus

    O exemplo de saída a seguir é semelhante à criação bem-sucedida do grupo de recursos:

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

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.

  • Crie essas variáveis usando os seguintes comandos. Substitua os valores padrão para RESOURCE_GROUP, , , , SUBSCRIPTIONUSER_ASSIGNED_IDENTITY_NAMELOCATIONSERVICE_ACCOUNT_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"
export KEYVAULT_NAME="azwi-kv-tutorial"
export KEYVAULT_SECRET_NAME="my-secret"

Criar um cluster do AKS

  1. Crie um cluster AKS usando o comando az aks create com o parâmetro para usar o --enable-oidc-issuer Emissor OIDC.

    az aks create --resource-group "${RESOURCE_GROUP}" --name myAKSCluster --node-count 1 --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.

  2. Obtenha a URL do Emissor OIDC e salve-a em uma variável ambiental usando o seguinte comando. Substitua o valor padrão para os argumentos -n, que é o nome do cluster.

    export AKS_OIDC_ISSUER="$(az aks show --name myAKSCluster --resource-group "${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/00000000-0000-0000-0000-000000000000/

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

Criar um Cofre de Chaves do Azure e um segredo

  1. Crie um Cofre da Chave do Azure no grupo de recursos criado neste tutorial usando o comando az keyvault create .

    az keyvault create --resource-group "${RESOURCE_GROUP}" --location "${LOCATION}" --name "${KEYVAULT_NAME}" --enable-rbac-authorization false

    A saída deste comando mostra as propriedades do cofre de chaves recém-criado. Tome nota das duas propriedades listadas abaixo:

    • Name: O nome do cofre que você forneceu para o --name parâmetro.
    • vaultUri: No exemplo, isto é https://<your-unique-keyvault-name>.vault.azure.net/. As aplicações que utilizam o cofre através da respetiva API têm de utilizar este URI.

    Nesta altura, a sua conta do Azure é a única autorizada a realizar quaisquer operações neste novo cofre.

  2. Adicione um segredo ao cofre usando o comando az keyvault secret set . A senha é o valor que você especificou para a variável KEYVAULT_SECRET_NAME de ambiente e armazena o valor de Hello! nela.

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

  3. Adicione o URL do Cofre da Chave à variável KEYVAULT_URL de ambiente usando o comando az keyvault show .

    export KEYVAULT_URL="$(az keyvault show --resource-group "${RESOURCE_GROUP}" --name ${KEYVAULT_NAME} --query properties.vaultUri -o tsv)"

Criar uma identidade gerenciada e conceder permissões para acessar o segredo

  1. Defina uma assinatura específica como a assinatura ativa atual usando o comando az account set .

    az account set --subscription "${SUBSCRIPTION}"

  2. Crie uma identidade gerenciada usando o comando az identity create .

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

  3. Defina uma política de acesso para a identidade gerenciada acessar o segredo do Cofre da Chave usando os comandos a seguir.

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

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

Criar conta de serviço do Kubernetes

  1. Crie uma conta de serviço Kubernetes e anote-a com o ID do cliente da identidade gerenciada criada na etapa anterior usando o comando az aks get-credentials . Substitua o valor padrão para o nome do cluster e o nome do grupo de recursos.

    az aks get-credentials --name myAKSCluster --resource-group "${RESOURCE_GROUP}"

  2. Copie a seguinte entrada de várias linhas para o seu terminal e execute o comando para criar a conta de serviço.

    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

  • Crie a credencial de identidade federada entre a identidade gerenciada, o emissor da conta de serviço e o assunto usando o comando az identity federated-credential create .

    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}

    Nota

    Leva alguns segundos para que a credencial de identidade federada se propague depois de ser adicionada inicialmente. Se uma solicitação de token estiver imediatamente disponível após a adição da credencial de identidade federada, você poderá enfrentar 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.

Implantar a carga de trabalho

  1. Implante um pod que faça referência à conta de serviço criada na etapa anterior usando o comando a seguir.

    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

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

    pod/quick-start created

  2. Verifique se todas as propriedades são injetadas corretamente com o webhook usando o comando kubectl describe .

    kubectl describe pod quick-start

  3. Verifique se o pod pode obter um token e acessar o segredo do Cofre da Chave usando o comando kubectl logs .

    kubectl logs quick-start

    A saída a seguir se assemelha ao acesso bem-sucedido do token:

    I1013 22:49:29.872708       1 main.go:30] "successfully got secret" secret="Hello!"

Clean up resources (Limpar recursos)

Você pode querer deixar esses recursos no lugar. Se você não precisar mais desses recursos, use os seguintes comandos para excluí-los.

  1. Exclua o pod usando o kubectl delete pod comando.

    kubectl delete pod quick-start

  2. Exclua a conta de serviço usando o kubectl delete sa comando.

    kubectl delete sa "${SERVICE_ACCOUNT_NAME}" --namespace "${SERVICE_ACCOUNT_NAMESPACE}"

  3. Exclua o grupo de recursos do Azure e todos os seus recursos usando o comando az group delete .

    az group delete --name "${RESOURCE_GROUP}"

Próximos passos

Neste tutorial, você implantou um cluster Kubernetes e, em seguida, implantou um aplicativo de contêiner simples para testar o trabalho com uma ID de carga de trabalho do Microsoft Entra.

Este tutorial é para fins introdutórios. Para obter orientação sobre como criar soluções completas com o AKS para produção, consulte Orientação de solução AKS.