Acesso seguro ao Azure OpenAI a partir do Serviço Kubernetes do Azure (AKS)

Neste artigo, você aprenderá a proteger o acesso ao Azure OpenAI a partir do Serviço Kubernetes do Azure (AKS) usando a ID de Carga de Trabalho do Microsoft Entra. Sabe como:

• Habilite identidades de carga de trabalho em um cluster AKS.
• Crie uma identidade gerenciada atribuída pelo usuário do Azure.
• Crie uma credencial federada do Microsoft Entra ID.
• Habilite a identidade da carga de trabalho em um Pod do Kubernetes.

Nota

Recomendamos o uso do ID de Carga de Trabalho do Microsoft Entra e identidades gerenciadas no AKS para acesso ao Azure OpenAI porque ele permite um processo de autenticação seguro e sem senha para acessar os recursos do Azure.

Antes de começar

• Você precisa de uma conta do Azure com uma assinatura ativa. Se você não tiver uma, crie uma conta gratuitamente.
• Este artigo baseia-se em Implantar um aplicativo que usa OpenAI no AKS. Você deve completar esse artigo antes de começar este.
• Você precisa de um nome de domínio personalizado habilitado em sua conta do Azure OpenAI para usar para autorização do Microsoft Entra. Para obter mais informações, consulte Nomes de subdomínio personalizados para serviços de IA do Azure.

Pré-requisitos

• Use o ambiente Bash no Azure Cloud Shell. Para obter mais informações, consulte Guia de início rápido para Bash no Azure Cloud Shell.

  

• Se preferir executar comandos de referência da CLI localmente, instale a CLI do Azure. Se estiver a utilizar o Windows ou macOS, considere executar a CLI do Azure num contentor Docker. Para obter mais informações, consulte Como executar a CLI do Azure em um contêiner do Docker.

  • Se estiver a utilizar uma instalação local, inicie sessão no CLI do Azure ao utilizar o comando az login. Para concluir o processo de autenticação, siga os passos apresentados no seu terminal. Para outras opções de entrada, consulte Entrar com a CLI do Azure.

  • Quando solicitado, instale a extensão da CLI do Azure na primeira utilização. Para obter mais informações sobre as extensões, veja Utilizar extensões com o CLI do Azure.

  • Execute o comando az version para localizar a versão e as bibliotecas dependentes instaladas. Para atualizar para a versão mais recente, execute o comando az upgrade.

Habilitar o ID de carga de trabalho do Microsoft Entra em um cluster AKS

Os recursos Microsoft Entra Workload ID e OIDC Issuer Endpoint não estão habilitados no AKS por padrão. Você deve habilitá-los em seu cluster AKS antes de poder usá-los.

1. Defina o nome do grupo de recursos e as variáveis de nome do grupo de recursos do cluster AKS.

   # Set the resource group variable
   RG_NAME=myResourceGroup
   
   # Set the AKS cluster resource group variable
   AKS_NAME=$(az resource list --resource-group $RG_NAME --resource-type Microsoft.ContainerService/managedClusters --query "[0].name" -o tsv)
   

2. Habilite os recursos Microsoft Entra Workload ID e OIDC Issuer Endpoint em seu cluster AKS existente usando o az aks update comando.

   az aks update \
       --resource-group $RG_NAME \
       --name $AKS_NAME \
       --enable-workload-identity \
       --enable-oidc-issuer
   

3. Obtenha o URL do ponto final do emissor AKS OIDC usando o az aks show comando.

   AKS_OIDC_ISSUER=$(az aks show --resource-group $RG_NAME --name $AKS_NAME --query "oidcIssuerProfile.issuerUrl" -o tsv)
   

Criar uma identidade gerenciada atribuída pelo usuário do Azure

1. Crie uma identidade gerenciada atribuída pelo usuário do Azure usando o az identity create comando.

   # Set the managed identity name variable
   MANAGED_IDENTITY_NAME=myIdentity
   
   # Create the managed identity
   az identity create \
       --resource-group $RG_NAME \
       --name $MANAGED_IDENTITY_NAME
   

2. Obtenha a ID do cliente de identidade gerenciada e a ID do objeto usando o az identity show comando.

   # Get the managed identity client ID
   MANAGED_IDENTITY_CLIENT_ID=$(az identity show --resource-group $RG_NAME --name $MANAGED_IDENTITY_NAME --query clientId -o tsv)
   
   # Get the managed identity object ID
   MANAGED_IDENTITY_OBJECT_ID=$(az identity show --resource-group $RG_NAME --name $MANAGED_IDENTITY_NAME --query principalId -o tsv)
   

3. Obtenha a ID de recurso do Azure OpenAI usando o az resource list comando.

   AOAI_RESOURCE_ID=$(az resource list --resource-group $RG_NAME --resource-type Microsoft.CognitiveServices/accounts --query "[0].id" -o tsv)
   

4. Conceda à identidade gerenciada acesso ao recurso OpenAI do Azure usando o az role assignment create comando.

   az role assignment create \
       --role "Cognitive Services OpenAI User" \
       --assignee-object-id $MANAGED_IDENTITY_OBJECT_ID \
       --assignee-principal-type ServicePrincipal \
       --scope $AOAI_RESOURCE_ID
   

Criar uma credencial federada do Microsoft Entra ID

1. Defina as variáveis de credencial federada, namespace e conta de serviço.

   # Set the federated credential name variable
   FEDERATED_CREDENTIAL_NAME=myFederatedCredential
   
   # Set the namespace variable
   SERVICE_ACCOUNT_NAMESPACE=default
   
   # Set the service account variable
   SERVICE_ACCOUNT_NAME=ai-service-account
   

2. Crie a credencial federada usando o az identity federated-credential create comando.

   az identity federated-credential create \
       --name ${FEDERATED_CREDENTIAL_NAME} \
       --resource-group ${RG_NAME} \
       --identity-name ${MANAGED_IDENTITY_NAME} \
       --issuer ${AKS_OIDC_ISSUER} \
       --subject system:serviceaccount:${SERVICE_ACCOUNT_NAMESPACE}:${SERVICE_ACCOUNT_NAME}
   

Usar o ID de carga de trabalho do Microsoft Entra no AKS

Para usar o ID de carga de trabalho do Microsoft Entra no AKS, você precisa fazer algumas alterações no manifesto de ai-service implantação.

Criar uma ServiceAccount

1. Obtenha o kubeconfig para seu cluster usando o az aks get-credentials comando.

   az aks get-credentials \
       --resource-group $RG_NAME \
       --name $AKS_NAME
   

2. Crie uma ServiceAccount do Kubernetes usando o kubectl apply comando.

   kubectl apply -f - <<EOF
   apiVersion: v1
   kind: ServiceAccount
   metadata:
     annotations:
       azure.workload.identity/client-id: ${MANAGED_IDENTITY_CLIENT_ID}
     name: ${SERVICE_ACCOUNT_NAME}
     namespace: ${SERVICE_ACCOUNT_NAMESPACE}
   EOF
   

Habilitar o ID de carga de trabalho do Microsoft Entra no pod

1. Defina as variáveis de nome de recurso, ponto de extremidade e nome de implantação do Azure OpenAI.

   # Get the Azure OpenAI resource name
   AOAI_NAME=$(az resource list \
     --resource-group $RG_NAME \
     --resource-type Microsoft.CognitiveServices/accounts \
     --query "[0].name" -o tsv)
   
   # Get the Azure OpenAI endpoint
   AOAI_ENDPOINT=$(az cognitiveservices account show \
     --resource-group $RG_NAME \
     --name $AOAI_NAME \
     --query properties.endpoint -o tsv)
   
   # Get the Azure OpenAI deployment name
   AOAI_DEPLOYMENT_NAME=$(az cognitiveservices account deployment list  \
     --resource-group $RG_NAME \
     --name $AOAI_NAME \
     --query "[0].name" -o tsv)
   

2. Reimplante o com ServiceAccount e a azure.workload.identity/use anotação definida para true usar o kubectl applyai-service comando.

   kubectl apply -f - <<EOF
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: ai-service
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: ai-service
     template:
       metadata:
         labels:
           app: ai-service
           azure.workload.identity/use: "true"
       spec:
         serviceAccountName: $SERVICE_ACCOUNT_NAME
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: ai-service
           image: ghcr.io/azure-samples/aks-store-demo/ai-service:latest
           ports:
           - containerPort: 5001
           env:
           - name: USE_AZURE_OPENAI
             value: "True"
           - name: USE_AZURE_AD
             value: "True"
           - name: AZURE_OPENAI_DEPLOYMENT_NAME
             value: "${AOAI_DEPLOYMENT_NAME}"
           - name: AZURE_OPENAI_ENDPOINT
             value: "${AOAI_ENDPOINT}"
           resources:
             requests:
               cpu: 20m
               memory: 50Mi
             limits:
               cpu: 50m
               memory: 128Mi
   EOF
   

Testar a aplicação

1. Verifique se o novo pod está em execução usando o kubectl get pods comando.

   kubectl get pods --selector app=ai-service -w
   

2. Obtenha os logs do pod usando o kubectl logs comando. Pode levar alguns minutos para o pod inicializar.

   kubectl logs --selector app=ai-service -f
   

   A saída de exemplo a seguir mostra que o aplicativo foi inicializado e está pronto para aceitar solicitações. A primeira linha sugere que o código está faltando variáveis de configuração. No entanto, o SDK do Azure Identity lida com esse processo e define as AZURE_CLIENT_ID variáveis e AZURE_TENANT_ID .

   Incomplete environment configuration. These variables are set: AZURE_CLIENT_ID, AZURE_TENANT_ID
   INFO:     Started server process [1]
   INFO:     Waiting for application startup.
   INFO:     Application startup complete.
   INFO:     Uvicorn running on http://0.0.0.0:5001 (Press CTRL+C to quit)
   

3. Obtenha as variáveis de ambiente pod usando o kubectl describe pod comando. A saída demonstra que a chave da API do Azure OpenAI não existe mais nas variáveis de ambiente do Pod.

   kubectl describe pod --selector app=ai-service
   

4. Abra um novo terminal e obtenha o IP do serviço de administração da loja usando o seguinte echo comando.

   echo "http://$(kubectl get svc/store-admin -o jsonpath='{.status.loadBalancer.ingress[0].ip}')"
   

5. Abra um navegador da Web e navegue até o endereço IP da etapa anterior.

6. Selecione Produtos. Você deve ser capaz de adicionar um novo produto e obter uma descrição para ele usando o Azure OpenAI.

Próximos passos

Neste artigo, você aprendeu como proteger o acesso ao Azure OpenAI do Serviço Kubernetes do Azure (AKS) usando a ID de Carga de Trabalho do Microsoft Entra.

Para obter mais informações sobre a ID da carga de trabalho do Microsoft Entra, consulte ID da carga de trabalho do Microsoft Entra.