Configurar a identidade da carga de trabalho entre locatários no Serviço de Kubernetes do Azure (AKS)

Artigo
08/02/2024

Neste artigo, você aprenderá a configurar a identidade de carga de trabalho entre locatários no Serviço de Kubernetes do Azure (AKS). A identidade da carga de trabalho entre locatários permite que você acesse recursos em outro locatário a partir do cluster do AKS. Neste exemplo, crie um Barramento de Serviço do Azure em um locatário e envie mensagens para ele a partir de uma carga de trabalho em execução em um cluster do AKS em outro locatário.

Para obter mais informações sobre a identidade da carga de trabalho, confira a Visão geral da identidade da carga de trabalho.

Pré-requisitos

Duas assinaturas do Azure, cada uma em um locatário separado. Neste artigo, nos referimos a eles como Locatário A e Locatário B.
CLI do Azure instalada em seu computador local. Se você não tiver a CLI do Azure instalada, confira Instalar a CLI do Azure.
Ambiente do shell do Bash. Este artigo usa a sintaxe do shell do Bash.
Você precisa ter os seguintes detalhes da assinatura:
- ID do locatário do Locatário A
- ID da assinatura do Locatário A
- ID do locatário do Locatário B
- ID da assinatura do Locatário B

Importante

Certifique-se de permanecer na mesma janela de terminal durante este artigo para manter as variáveis de ambiente que você definiu. Se você fechar a janela do terminal, precisará definir as variáveis de ambiente novamente.

Configurar recursos no Locatário A

No Locatário A, crie um cluster do AKS com a identidade da carga de trabalho e o emissor do OIDC habilitados. Use esse cluster para implantar um aplicativo que tente acessar recursos no Locatário B.

Fazer logon no Locatário A

Faça logon em sua assinatura do Locatário A usando o comando az login.

# Set environment variable
TENANT_A_ID=<tenant-id>

az login --tenant $TENANT_A_ID

Certifique-se de que está trabalhando com a assinatura correta no Locatário A usando o comando az account set.

# Set environment variable
TENANT_A_SUBSCRIPTION_ID=<subscription-id>

# Log in to your Tenant A subscription
az account set --subscription $TENANT_A_SUBSCRIPTION_ID

Criar recursos no Locatário A

Crie um grupo de recursos no Locatário A para hospedar o cluster do AKS usando o comando az group create.

# Set environment variables
RESOURCE_GROUP=<resource-group-name>
LOCATION=<location>

# Create a resource group
az group create --name $RESOURCE_GROUP --location $LOCATION

Crie um cluster do AKS no Locatário A com a identidade da carga de trabalho e o emissor do OIDC habilitados usando o comando az aks create.

# Set environment variable
CLUSTER_NAME=<cluster-name>

# Create an AKS cluster
az aks create \
  --resource-group $RESOURCE_GROUP \
  --name $CLUSTER_NAME \
  --enable-oidc-issuer \
  --enable-workload-identity \
  --generate-ssh-keys

Obter a URL do emissor do OIDC do cluster do AKS

Obtenha a URL do emissor do OIDC do cluster no Locatário A usando o comando az aks show.

OIDC_ISSUER_URL=$(az aks show --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME --query "oidcIssuerProfile.issuerUrl" --output tsv)

Configurar recursos no Locatário B

No Locatário B, crie um Barramento de Serviço do Azure, uma identidade gerenciada e atribua permissões para ler e gravar mensagens no barramento de serviço e estabelecer a confiança entre a identidade gerenciada e o cluster do AKS no Locatário A.

Fazer logon no Locatário B

Faça logoff da assinatura do Locatário A usando o comando az logout.
```
az logout
```

Faça logon na assinatura do Locatário B usando o comando az login.

# Set environment variable
TENANT_B_ID=<tenant-id>

az login --tenant $TENANT_B_ID

Verifique se você está trabalhando com a assinatura correta no Locatário B usando o az account set comando.

# Set environment variable
TENANT_B_SUBSCRIPTION_ID=<subscription-id>

# Log in to your Tenant B subscription
az account set --subscription $TENANT_B_SUBSCRIPTION_ID

Criar recursos no Locatário B

Crie um grupo de recursos no Locatário B para hospedar a identidade gerenciada usando o comando az group create.

# Set environment variables
RESOURCE_GROUP=<resource-group-name>
LOCATION=<location>

# Create a resource group
az group create --name $RESOURCE_GROUP --location $LOCATION

Crie um barramento de serviço e uma fila no Locatário B usando os comandos az servicebus namespace create e az servicebus queue create.

# Set environment variable
SERVICEBUS_NAME=sb-crosstenantdemo-$RANDOM

# Create a new service bus namespace and and return the service bus hostname
SERVICEBUS_HOSTNAME=$(az servicebus namespace create \
  --name $SERVICEBUS_NAME \
  --resource-group $RESOURCE_GROUP \
  --disable-local-auth \
  --query serviceBusEndpoint \
  --output tsv | sed -e 's/https:\/\///' -e 's/:443\///')

# Create a new queue in the service bus namespace
az servicebus queue create \
  --name myqueue \
  --namespace $SERVICEBUS_NAME \
  --resource-group $RESOURCE_GROUP

Crie uma identidade gerenciada atribuída pelo usuário no Locatário B usando o comando az identity create.

# Set environment variable
IDENTITY_NAME=${SERVICEBUS_NAME}-identity

# Create a user-assigned managed identity
az identity create --resource-group $RESOURCE_GROUP --name $IDENTITY_NAME

Obter IDs de recurso e atribuir permissões no Locatário B

Obtenha a ID da identidade de segurança da identidade gerenciada no Locatário B usando o comando az identity show.

# Get the user-assigned managed identity principalId
PRINCIPAL_ID=$(az identity show \
  --resource-group $RESOURCE_GROUP \
  --name $IDENTITY_NAME \
  --query principalId \
  --output tsv)

Obtenha a ID do cliente da identidade gerenciada no Locatário B usando o comando az identity show.

CLIENT_ID=$(az identity show \
  --resource-group $RESOURCE_GROUP \
  --name $IDENTITY_NAME \
  --query clientId \
  --output tsv)

Obtenha a ID do recurso do namespace do barramento de serviço no Locatário B usando o comando az servicebus namespace show.

SERVICEBUS_ID=$(az servicebus namespace show \
  --name $SERVICEBUS_NAME \
  --resource-group $RESOURCE_GROUP \
  --query id \
  --output tsv)

Atribua a identidade gerenciada em permissões do Locatário B para ler e gravar mensagens do barramento de serviço usando o comando az role assignment create.

az role assignment create \
  --role "Azure Service Bus Data Owner" \
  --assignee-object-id $PRINCIPAL_ID \
  --assignee-principal-type ServicePrincipal \
  --scope $SERVICEBUS_ID

Estabelecer a confiança entre o cluster do AKS e a identidade gerenciada

Nesta seção, crie a credencial de identidade federada necessária para estabelecer a confiança entre o cluster do AKS no Locatário A e a identidade gerenciada no Locatário B. Use a URL do emissor do OIDC do cluster do AKS no Locatário A e o nome da identidade gerenciada no Locatário B.

Crie uma credencial de identidade federada usando o comando az identity federated-credential create.

az identity federated-credential create \
  --name $IDENTITY_NAME-$RANDOM \
  --identity-name $IDENTITY_NAME \
  --resource-group $RESOURCE_GROUP \
  --issuer $OIDC_ISSUER_URL \
  --subject system:serviceaccount:default:myserviceaccount

--subject system:serviceaccount:default:myserviceaccount é o nome da conta de serviço do Kubernetes que você criará no Locatário A posteriormente no artigo. Quando o pod do aplicativo fizer solicitações de autenticação, esse valor será enviado para o Microsoft Entra ID como o subject naa solicitação de autorização. O Microsoft Entra ID determinará a qualificação com base em se esse valor corresponde ao que você definiu ao criar a credencial de identidade federada, portanto, é importante garantir que o valor corresponda.

Implantar aplicativo para enviar mensagens para a fila do Barramento de Serviço do Azure

Nesta seção, implante um aplicativo no cluster do AKS no Locatário A que envie mensagens para a fila do Barramento de Serviço do Azure no Locatário B.

Fazer logon no Locatário A e obter credenciais do AKS

Faça logoff da sua assinatura do Locatário B usando o comando az logout.
```
az logout
```
Faça logon em sua assinatura do Locatário A usando o comando az login.
```
az login --tenant $TENANT_A_ID
```
Certifique-se de que está trabalhando com a assinatura correta no Locatário A usando o comando az account set.
```
az account set --subscription $TENANT_A_SUBSCRIPTION_ID
```
Obtenha as credenciais para o cluster do AKS no Locatário A usando o comando az aks get-credentials.
```
az aks get-credentials --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME
```

Criar recursos do Kubernetes para enviar mensagens para a fila do Barramento de Serviço do Azure

Crie uma nova ServiceAccount do Kubernetes no namespace default e passe a ID do cliente de sua identidade gerenciada no Locatário B para o comando kubectl apply. A ID do cliente é usada para autenticar o aplicativo no Locatário A para o Barramento de Serviço do Azure no Locatário B.
```
kubectl apply -f - <<EOF
apiVersion: v1
kind: ServiceAccount
metadata:
  annotations:
    azure.workload.identity/client-id: $CLIENT_ID
  name: myserviceaccount
EOF
```

Crie um novo trabalho do Kubernetes no namespace default para enviar 100 mensagens para a fila do Barramento de Serviço do Azure. O modelo de pod está configurado para usar a identidade da carga de trabalho e a conta de serviço que você criou na etapa anterior. Observe também que a variável de ambiente AZURE_TENANT_ID está definida como a ID do locatário do Locatário B. Isso é necessário porque a identidade da carga de trabalho tem como padrão o locatário do cluster do AKS, portanto, você precisa definir explicitamente a ID do locatário do Locatário B.

kubectl apply -f - <<EOF
apiVersion: batch/v1
kind: Job
metadata:
  name: myproducer
spec:
  template:
    metadata:
      labels:
        azure.workload.identity/use: "true"
    spec:
      serviceAccountName: myserviceaccount
      containers:
      - image: ghcr.io/azure-samples/aks-app-samples/servicebusdemo:latest
        name: myproducer
        resources: {}
        env:
        - name: OPERATION_MODE
          value: "producer"
        - name: MESSAGE_COUNT
          value: "100"
        - name: AZURE_SERVICEBUS_QUEUE_NAME
          value: myqueue
        - name: AZURE_SERVICEBUS_HOSTNAME
          value: $SERVICEBUS_HOSTNAME
        - name: AZURE_TENANT_ID
          value: $TENANT_B_ID
      restartPolicy: Never
EOF

Verificar a implantação

Verifique se o pod está configurado corretamente para interagir com a fila do Barramento de Serviço do Azure no Locatário B, verificando o status do pod usando o comando kubectl describe pod.

# Get the dynamically generated pod name
POD_NAME=$(kubectl get po --selector job-name=myproducer -o jsonpath='{.items[0].metadata.name}')

# Verify the tenant ID environment variable is set for Tenant B
kubectl describe pod $POD_NAME | grep AZURE_TENANT_ID

Verifique os logs do pod para ver se o aplicativo conseguiu enviar mensagens entre os locatários usando o comando kubectl logs.
```
kubectl logs $POD_NAME
```
Seu resultado deve ser semelhante ao seguinte exemplo de saída:
```
...
Adding message to batch: Hello World!
Adding message to batch: Hello World!
Adding message to batch: Hello World!
Sent 100 messages
```

Observação

Como uma etapa extra de verificação, você pode acessar o portal do Azure e navegar até a fila do Barramento de Serviço do Azure no Locatário B para exibir as mensagens que foram enviadas no Service Bus Explorer.

Limpar os recursos

Depois de verificar se a implantação foi bem-sucedida, você pode limpar os recursos para evitar incorrer em custos do Azure.

Excluir recursos no Locatário A

Faça logon em sua assinatura do Locatário A usando o comando az login.
```
az login --tenant $TENANT_A_ID
```
Certifique-se de que está trabalhando com a assinatura correta no Locatário A usando o comando az account set.
```
az account set --subscription $TENANT_A_SUBSCRIPTION_ID
```
Exclua o grupo de recursos do Azure e todos os recursos nele contidos usando o comando az group delete.
```
az group delete --name $RESOURCE_GROUP --yes --no-wait
```

Excluir recursos no Locatário B

Faça logon na assinatura do Locatário B usando o comando az login.
```
az login --tenant $TENANT_B_ID
```
Verifique se você está trabalhando com a assinatura correta no Locatário B usando o az account set comando.
```
az account set --subscription $TENANT_B_SUBSCRIPTION_ID
```
Exclua o grupo de recursos do Azure e todos os recursos nele contidos usando o comando az group delete.
```
az group delete --name $RESOURCE_GROUP --yes --no-wait
```

Próximas etapas

Neste artigo, você aprendeu a configurar a identidade de carga de trabalho entre locatários no Serviço de Kubernetes do Azure (AKS). Para saber mais sobre a identidade da carga de trabalho, confira os seguintes artigos:

Compartilhar via