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

Artigo
08/02/2024

Neste artigo, você aprenderá 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. 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.

Observação

É recomendável usar a ID de carga de trabalho do Microsoft Entra e as identidades gerenciadas no AKS para acesso ao OpenAI do Azure, pois ela permite um processo de autenticação seguro e sem senha para acessar recursos do Azure.

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 OpenAI do Azure para usar para 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 Início Rápido para Bash no 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 ver outras opções de entrada, confira Conectar-se com 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 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.

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)

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
```

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

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

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)

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)

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

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

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

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

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

Defina o ponto de extremidade, as variáveis do nome de implantação e o nome do recurso 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)

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

Verifique se o novo pod está em execução usando o comando kubectl get pods.
```
kubectl get pods --selector app=ai-service -w
```
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)
```
Obtenha as variáveis de ambiente de 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
```
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}')"
```
Em um navegador da Web, 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 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.

Partilhar via