Configurar a identidade da carga de trabalho em um cluster do AKS Edge Essentials (visualização)

Artigo
11/16/2024

O Serviço Kubernetes do Azure (AKS) Edge Essentials é uma implementação Kubernetes local do Serviço Kubernetes do Azure (AKS) 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 identidade de carga de trabalho no Kubernetes habilitado para Arco do Azure (visualização).

Importante

Esses recursos de visualização estão disponíveis em uma base de autoatendimento e aceitação. As visualizações prévias são fornecidas "como estão" e "conforme disponíveis" e são excluídas dos contratos de nível de serviço e da garantia limitada. As visualizações do Azure Kubernetes Service Edge Essentials são parcialmente cobertas pelo suporte ao cliente com base no melhor esforço.

Nota

Nesta visualização pública, o AKS Edge Essentials permite habilitar a identidade da carga de trabalho durante a implantação inicial do script de início rápido das Operações do Azure IoT. Este 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 do Azure IoT conforme descrito em Criar e configurar um cluster do AKS Edge Essentials que possa executar as Operações do Azure IoT. O script habilita automaticamente o recurso de federação de identidade de carga de trabalho no cluster AKS Edge Essentials.

Depois de implantar o cluster 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 pelos 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 a URL do emissor OIDC em uma variável de ambiente

Para obter a URL do emissor OIDC e salvá-la 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 vinculá-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 o 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 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 federada no Microsoft Entra, consulte Visão geral das credenciais de identidade federada 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

Nota

Depois de adicionar uma credencial de identidade federada, 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 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 as metadata\namespace propriedades e spec\serviceAccountName . Certifique-se de especificar 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 de aplicativo que usam a identidade de carga de trabalho incluam o rótulo azure.workload.identity/use: "true" na especificação do pod. Caso contrário, os pods falham depois de serem reiniciados.

Exemplo: Conceder permissões para acessar o Cofre da Chave do Azure

As instruções nesta etapa descrevem como acessar segredos, chaves ou certificados em um cofre de chaves do Azure 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 a seguir mostra como usar o modelo de permissão de controle de acesso baseado em função do Azure (Azure RBAC) para conceder acesso ao pod ao cofre de chaves. Para obter mais informações sobre o modelo de permissão do Azure RBAC para o Azure Key Vault, consulte Conceder permissão a aplicativos para acessar um cofre de chaves do Azure usando o Azure RBAC.

Crie um cofre de chaves com proteção contra limpeza e autorização RBAC habilitada. Você também pode usar um cofre de chaves existente se ele estiver configurado para proteção contra limpeza e autorização 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 de Oficial de Segredos do Cofre de Chaves RBAC 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 ServicePrincipal
```

Crie 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 Cofre de Chaves à identidade gerenciada atribuída pelo usuário que você criou anteriormente. Esta etapa dá à identidade gerenciada permissão 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 ServicePrincipal
```

Crie uma variável de ambiente para o 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 ao 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óximos passos

Neste artigo, você 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.

Partilhar via