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

Artigo
11/22/2024

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.

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)

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

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

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

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)

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)

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

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

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

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

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

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

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)

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

Verifique se o novo pod está em execução usando o kubectl get pods comando.
```
kubectl get pods --selector app=ai-service -w
```
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 and 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)
```
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
```
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}')"
```
Abra um navegador da Web e navegue até o endereço IP da etapa anterior.
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 o ID de carga de trabalho do Microsoft Entra, consulte ID de carga de trabalho do Microsoft Entra.

Partilhar via