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

Artigo
11/01/2024

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

Para obter mais informações sobre a identidade da carga de trabalho, consulte 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, referimo-nos a estes como Inquilino A e Inquilino B.
CLI do Azure instalada em sua máquina local. Se você não tiver a CLI do Azure instalada, consulte Instalar a CLI do Azure.
Ambiente de shell bash. Este artigo usa a sintaxe do shell Bash.
Você precisa ter os seguintes detalhes de assinatura:
- Inquilino Um ID de inquilino
- ID de subscrição do inquilino A
- ID do locatário B
- ID de subscrição do inquilino B

Importante

Certifique-se de permanecer dentro da mesma janela de terminal durante a duração deste 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, você cria um cluster AKS com a identidade da carga de trabalho e o emissor OIDC habilitados. Use esse cluster para implantar um aplicativo que tenta acessar recursos no locatário B.

Iniciar sessão no Inquilino A

Inicie sessão na sua subscrição do Inquilino A utilizando o az login comando.

# Set environment variable
TENANT_A_ID=<tenant-id>

az login --tenant $TENANT_A_ID

Certifique-se de que está a trabalhar com a subscrição correta no Inquilino A utilizando o az account set comando.

# 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 AKS usando o az group create comando.

# 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 AKS no Locatário A com a identidade da carga de trabalho e o emissor OIDC habilitados usando o az aks create comando.

# 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 URL do emissor OIDC do cluster AKS

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

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, você cria um Barramento de Serviço do Azure, uma identidade gerenciada e atribui-lhe permissões para ler e gravar mensagens no barramento de serviço e estabelece a confiança entre a identidade gerenciada e o cluster AKS no Locatário A.

Iniciar sessão no Inquilino B

Termine sessão na subscrição do Inquilino A utilizando o az logout comando.
```
az logout
```

Inicie sessão na sua subscrição de Inquilino B utilizando o az login comando.

# Set environment variable
TENANT_B_ID=<tenant-id>

az login --tenant $TENANT_B_ID

Certifique-se de que está a trabalhar com a subscrição correta no Inquilino B utilizando 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 az group create comando.

# 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 az servicebus namespace create comandos and 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 az identity create comando.

# 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 recursos e atribuir permissões no Locatário B

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

# 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 az identity show comando.

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 az servicebus namespace show comando.

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

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

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

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

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

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

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ê cria no locatário A mais adiante no artigo. Quando o pod do aplicativo faz solicitações de autenticação, esse valor é enviado para o ID do Microsoft Entra como o subject na solicitação de autorização. O Microsoft Entra ID determina a elegibilidade com base em se esse valor corresponde ao que você definiu quando criou a credencial de identidade federada, por isso é importante garantir que o valor corresponda.

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

Nesta seção, você implanta um aplicativo em seu cluster AKS no Locatário A que envia mensagens para a fila do Barramento de Serviço do Azure no Locatário B.

Inicie sessão no Inquilino A e obtenha credenciais AKS

Termine sessão na sua subscrição de Inquilino B utilizando o az logout comando.
```
az logout
```
Inicie sessão na sua subscrição do Inquilino A utilizando o az login comando.
```
az login --tenant $TENANT_A_ID
```
Certifique-se de que está a trabalhar com a subscrição correta no Inquilino A utilizando o az account set comando.
```
az account set --subscription $TENANT_A_SUBSCRIPTION_ID
```
Obtenha as credenciais para o cluster AKS no Locatário A usando o az aks get-credentials comando.
```
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 default namespace e passe a ID do cliente da sua identidade gerenciada no Locatário B para o kubectl apply comando. A ID do cliente é usada para autenticar o aplicativo no Locatário A no 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 para enviar 100 mensagens para sua fila default do Barramento de Serviço do Azure. O modelo 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 AZURE_TENANT_ID variável de ambiente é definida como a ID do locatário do locatário B. Isso é necessário, pois a identidade da carga de trabalho é padronizada para o locatário do cluster 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 implementaçã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 kubectl describe pod comando.

# 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 foi capaz de enviar mensagens entre locatários usando o kubectl logs comando.
```
kubectl logs $POD_NAME
```
Sua saída deve ser semelhante à saída de exemplo a seguir:
```
...
Adding message to batch: Hello World!
Adding message to batch: Hello World!
Adding message to batch: Hello World!
Sent 100 messages
```

Nota

Como uma etapa de verificação extra, você pode ir para 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 Gerenciador do Barramento de Serviço.

Clean up resources (Limpar 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

Inicie sessão na sua subscrição do Inquilino A utilizando o az login comando.
```
az login --tenant $TENANT_A_ID
```
Certifique-se de que está a trabalhar com a subscrição correta no Inquilino A utilizando o az account set comando.
```
az account set --subscription $TENANT_A_SUBSCRIPTION_ID
```
Exclua o grupo de recursos do Azure e todos os recursos nele usando o az group delete comando.
```
az group delete --name $RESOURCE_GROUP --yes --no-wait
```

Excluir recursos no Locatário B

Inicie sessão na sua subscrição de Inquilino B utilizando o az login comando.
```
az login --tenant $TENANT_B_ID
```
Certifique-se de que está a trabalhar com a subscrição correta no Inquilino B utilizando 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 usando o az group delete comando.
```
az group delete --name $RESOURCE_GROUP --yes --no-wait
```

Próximos passos

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

Partilhar via