Proteger o acesso ao OpenAI do Azure a partir do AKS (Serviço de Kubernetes do Azure)

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

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

Antes de começar

• Você precisa de uma conta do Azure com uma assinatura ativa. Se você não tiver, crie uma conta gratuita.
• Esse artigo se baseia em Implantar um aplicativo que usa o OpenAI no AKS. Você deve concluir 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 com a autorização do Microsoft Entra. Para mais informações, confira 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, confira Introdução ao Azure Cloud Shell.

  

• Se preferir executar os comandos de referência da CLI localmente, instale a CLI do Azure. Para execuções no Windows ou no macOS, considere executar a CLI do Azure em um contêiner do Docker. Para obter mais informações, confira Como executar a CLI do Azure em um contêiner do Docker.

  • Se estiver usando uma instalação local, entre com a CLI do Azure usando o comando az login. Para concluir o processo de autenticação, siga as etapas exibidas no terminal. Para obter outras opções de entrada, consulte Autenticar no Azure usando a CLI do Azure.

  • Quando solicitado, instale a extensão da CLI do Azure no primeiro uso. Para obter mais informações sobre extensões, confira Usar e gerenciar extensões com a CLI do Azure.

  • Execute az version para localizar a versão e as bibliotecas dependentes que estão instaladas. Para fazer a atualização para a versão mais recente, execute az upgrade.

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

Por padrão, os recursos da ID de carga de trabalho do Microsoft Entra e do ponto de extremidade do emissor do OIDC não estão habilitados no AKS. Você deve habilita-los no cluster do AKS antes de usa-los.

1. Defina o nome do grupo de recursos e as variáveis de nome do grupo de recursos do cluster do 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 da ID de carga de trabalho do Microsoft Entra e do Ponto de Extremidade do Emissor do OIDC no cluster existente do AKS usando o comando az aks update.

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

3. Obtenha a URL do ponto de extremidade do emissor OIDC do AKS usando o comando az aks show.

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

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

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

   # 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 da identidade gerenciada e a ID do objeto usando o comando az identity show.

   # 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 do recurso do OpenAI do Azure usando o comando az resource list.

   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 do OpenAI do Azure usando o comando az role assignment create.

   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 comando az identity federated-credential create.

   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 a ID de carga de trabalho do Microsoft Entra no AKS

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

Criar um ServiceAccount

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

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

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

   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 a ID de carga de trabalho do Microsoft Entra no Pod

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

   # 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 ai-service com ServiceAccount e a anotação azure.workload.identity/use definida como true usando o comando kubectl apply.

   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 o aplicativo

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

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

2. Obtenha os logs de pod usando o comando kubectl logs. Pode levar alguns minutos para o pod ser inicializado.

   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 de Identidade do Azure lida com esse processo e define as variáveis AZURE_CLIENT_ID 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 do pod usando o comando kubectl describe pod. A saída demonstra que a chave de API do OpenAI do Azure 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 administrador do repositório usando o comando echo a seguir.

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

5. Em um navegador da Web, 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 OpenAI do Azure.

Próximas etapas

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

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