Configurar a identidade da carga de trabalho em um cluster do AKS Edge Essentials (versão prévia)
O Azure Kubernetes Service (AKS) Edge Essentials é uma implementação local do Kubernetes do AKS (Serviço de Kubernetes do Azure) que automatiza a execução de aplicativos em contêineres em escala. Este artigo descreve como executar as seguintes tarefas:
- Crie uma conta de serviço do Kubernetes e associe-a à Identidade Gerenciada do Azure.
- Crie uma credencial federada na identidade gerenciada para confiar no 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 identidades de carga de trabalho, consulte Federação de identidades de carga de trabalho no Kubernetes habilitado para Azure Arc (versão prévia).
Importante
Esses recursos de visualização estão disponíveis em uma base de autoatendimento e aceitação. As visualizações são fornecidas "como estão" e "conforme disponíveis" e estão excluídas dos acordos de nível de serviço e da garantia limitada. As versões prévias do Serviço de Kubernetes do Azure Edge Essentials são parcialmente cobertas pelo suporte ao cliente com base no melhor esforço.
Observação
Nesta versão prévia pública, o AKS Edge Essentials permite que você habilite a identidade da carga de trabalho durante a implantação inicial do script de início rápido do Azure IoT Operations. Esse recurso não está disponível para outros cenários do AKS Edge Essentials.
Pré-requisitos
Antes de usar a federação de identidade de carga de trabalho para um cluster do AKS Edge Essentials, você deve implantar o script de início rápido da Operação de IoT do Azure, conforme descrito em Criar e configurar um cluster do AKS Edge Essentials que pode executar as Operações do Azure IoT. O script habilita automaticamente o recurso de federação de identidade de carga de trabalho no cluster do AKS Edge Essentials.
Depois de implantar o cluster do AKS Edge Essentials, você pode usar o seguinte comando para verificar o status da extensão de identidade da carga de trabalho:
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/",
# workloadIdentity "enabled": true
"securityProfile": {
"workloadIdentity": {
"enabled": true
No portal do Azure, você pode exibir a wiextension extensão na seção Propriedades do cluster do Kubernetes.
Exportar variáveis de ambiente
Para ajudar a simplificar as etapas para configurar as identidades necessárias, as etapas a seguir definem variáveis de ambiente que são referenciadas nos exemplos deste artigo. Lembre-se de substituir os valores mostrados 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"
# Include these variables to access key vault secrets from a pod in the cluster.
$KVName = "KV-workload-id"
$KVSecretName= "KV-secret"
Salvar o URL do emissor do OIDC em uma variável de ambiente
Para obter o URL do emissor do OIDC e salvá-lo em uma variável de ambiente, execute o seguinte comando:
$SERVICE_ACCOUNT_ISSUER =$(az connectedk8s show --n $aks_cluster_name --resource-group $resource_group_name --query "oidcIssuerProfile.issuerUrl" --output tsv)
Etapa 1: Criar uma conta de serviço do Kubernetes e associá-la à Identidade Gerenciada do Azure
Primeiro, chame o comando az identity create para criar uma identidade gerenciada:
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
Crie uma conta de serviço do Kubernetes e anote-a com o ID do cliente da identidade gerenciada que você criou na etapa anterior. Copie e cole os seguintes comandos da CLI do Azure:
$yaml = @"
apiVersion: v1
kind: ServiceAccount
metadata:
annotations:
azure.workload.identity/client-id: $MSIId
name: $SERVICE_ACCOUNT_NAME
namespace: $SERVICE_ACCOUNT_NAMESPACE
"@
# Replace variables within the YAML content
$yaml = $yaml -replace '\$MSIId', $MSIId `
-replace '\$SERVICE_ACCOUNT_NAME', $SERVICE_ACCOUNT_NAME `
-replace '\$SERVICE_ACCOUNT_NAMESPACE', $SERVICE_ACCOUNT_NAMESPACE
# Apply the YAML content to Kubernetes
$yaml | kubectl apply -f -
A saída a seguir mostra a identidade da carga de trabalho criada com êxito:
serviceaccount/workload-identity-sa created
Etapa 2: Criar uma credencial federada na identidade gerenciada para confiar no emissor do OIDC
Para criar a credencial de identidade federada entre a identidade gerenciada, o emissor da conta de serviço e o assunto, chame o comando az identity federated-credential create . Para obter mais informações sobre credenciais de identidade federadas no Microsoft Entra, consulte Visão geral das credenciais de identidade federadas no 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
Observação
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 3: Implantar seu 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 manifesto a seguir mostra como fazer referência à conta, especificamente as metadata\namespace propriedades 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 o Azure Key Vault
As instruções nesta etapa descrevem como acessar segredos, chaves ou certificados em um cofre de chaves do Azure 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 rbac do Azure para o Azure Key Vault, consulte Conceder permissão a aplicativos para acessar um cofre de chaves do Azure usando o RBAC do Azure.
Crie um cofre de chaves com proteção contra limpeza e autorização RBAC habilitada. Você também poderá usar um cofre de chaves existente se ele estiver configurado para a proteção contra limpeza e a autorização do 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)Atribua a função Oficial de Segredos do RBAC 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.
az role assignment create --assignee-object-id $MSIPrincipalId --role "Key Vault Secrets Officer" --scope $KVId --assignee-principal-type ServicePrincipalCrie um segredo no cofre de chaves:
az keyvault secret set --vault-name $KVName --name $KVSecretName --value "Hello!"Atribua a função usuário de segredos do Key Vault à identidade gerenciada atribuída pelo usuário que você criou anteriormente. Esta etapa fornece a permissão de identidade gerenciada para ler segredos do cofre de chaves:
az role assignment create --assignee-object-id $MSIPrincipalId --role "Key Vault Secrets User" --scope $KVId --assignee-principal-type ServicePrincipalCrie 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)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 $aks_cluster_name apply -f -
Próximas etapas
Neste artigo, você o configurou para usar uma identidade de carga de trabalho em preparação para que as cargas de trabalho do aplicativo sejam 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 do Azure Identity.