Proteggere l'accesso ad Azure OpenAI dal servizio Azure Kubernetes

Questo articolo illustra come proteggere l'accesso ad Azure OpenAI dal servizio Azure Kubernetes usando l'ID del carico di lavoro Microsoft Entra. Scopri come:

• Abilitare le identità del carico di lavoro in un cluster del servizio Azure Kubernetes.
• Creare un'identità gestita assegnata dall'utente di Azure.
• Creare una credenziale federata di Microsoft Entra ID.
• Abilitare l'identità del carico di lavoro in un pod Kubernetes.

Nota

È consigliabile usare l'ID del carico di lavoro Microsoft Entra e le identità gestite nel servizio Azure Kubernetes per l'accesso ad Azure OpenAI perché consente un processo di autenticazione sicuro e senza password per l'accesso alle risorse di Azure.

Operazioni preliminari

• È necessario un account Azure con una sottoscrizione attiva. Se non si dispone di un account, crearne uno gratuitamente.
• Questo articolo si basa su Distribuire un'applicazione che usa OpenAI nel servizio Azure Kubernetes. È necessario completare quell'articolo prima di iniziare questo.
• È necessario abilitare un nome di dominio personalizzato nell'account OpenAI di Azure da usare per l'autorizzazione di Microsoft Entra. Per altre informazioni, vedere Nomi di sottodomini personalizzati per i servizi di intelligenza artificiale di Azure.

Prerequisiti

• Usare l'ambiente Bash in Azure Cloud Shell. Per altre informazioni, vedere Avvio rapido su Bash in Azure Cloud Shell.

  

• Se si preferisce eseguire i comandi di riferimento dell'interfaccia della riga di comando in locale, installare l'interfaccia della riga di comando di Azure. Per l'esecuzione in Windows o macOS, è consigliabile eseguire l'interfaccia della riga di comando di Azure in un contenitore Docker. Per altre informazioni, vedere Come eseguire l'interfaccia della riga di comando di Azure in un contenitore Docker.

  • Se si usa un'installazione locale, accedere all'interfaccia della riga di comando di Azure con il comando az login. Per completare il processo di autenticazione, seguire la procedura visualizzata nel terminale. Per altre opzioni di accesso, vedere Accedere tramite l'interfaccia della riga di comando di Azure.

  • Quando richiesto, al primo utilizzo installare l'estensione dell'interfaccia della riga di comando di Azure. Per altre informazioni sulle estensioni, vedere Usare le estensioni con l'interfaccia della riga di comando di Azure.

  • Eseguire az version per trovare la versione e le librerie dipendenti installate. Per eseguire l'aggiornamento alla versione più recente, eseguire az upgrade.

Abilitare l'ID del carico di lavoro Microsoft Entra in un cluster del servizio Azure Kubernetes

L'ID del carico di lavoro Microsoft Entra e le funzionalità dell'endpoint dell'autorità di certificazione OIDC non sono abilitate per impostazione predefinita nel servizio Azure Kubernetes. È necessario abilitarli nel cluster del servizio Azure Kubernetes prima di poterli usare.

1. Impostare il nome del gruppo di risorse e le variabili del nome del gruppo di risorse del cluster del servizio Azure Kubernetes.

   # 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. Abilitare l'ID del carico di lavoro Microsoft Entra e le funzionalità endpoint dell'autorità di certificazione OIDC nel cluster del servizio Azure Kubernetes esistente usando il comando az aks update.

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

3. Ottenere l'URL dell'endpoint dell'autorità di certificazione OIDC del servizio Azure Kubernetes usando il comando az aks show.

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

Creare un'identità gestita assegnata dall'utente di Azure

1. Creare un'identità gestita assegnata dall'utente di Azure usando il 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. Ottenere l'ID client dell'identità gestita e l'ID oggetto usando il 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. Ottenere l'ID risorsa OpenAI di Azure usando il 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. Concedere all'identità gestita l'accesso alla risorsa OpenAI di Azure usando il 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
   

Creare una credenziale federata di Microsoft Entra ID

1. Impostare le variabili federate di credenziali, spazio dei nomi e account del servizio.

   # 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. Creare le credenziali federate usando il 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}
   

Usare l'ID del carico di lavoro di Microsoft Entra nel servizio Azure Kubernetes

Per usare l'ID del carico di lavoro di Microsoft Entra nel servizio Azure Kubernetes, è necessario apportare alcune modifiche al manifesto della distribuzione ai-service.

Creare un Account di servizio

1. Ottenere il kubeconfig per il cluster usando il comando az aks get-credentials.

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

2. Creare un account del servizio Kubernetes usando il 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
   

Abilitare l'ID del carico di lavoro Microsoft Entra nel pod

1. Impostare le variabili nome della risorsa, dell'endpoint e del nome della distribuzione di 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. Ridistribuire ai-service con ServiceAccount e l'annotazione azure.workload.identity/use impostata su true usando il 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
   

Testare l'applicazione

1. Verificare che il nuovo pod sia in esecuzione usando il comando kubectl get pods.

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

2. Ottenere i log dei pod usando il comando kubectl logs. L'inizializzazione del pod può richiedere alcuni minuti.

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

   L'output di esempio seguente mostra che l'app è stata inizializzata ed è pronta per accettare le richieste. La prima riga suggerisce che il codice non contiene variabili di configurazione. Tuttavia, Azure Identity SDK gestisce questo processo e imposta le variabili 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. Ottenere le variabili di ambiente del pod usando il comando kubectl describe pod. L'output dimostra che la chiave API OpenAI di Azure non esiste più nelle variabili di ambiente del pod.

   kubectl describe pod --selector app=ai-service
   

4. Aprire un nuovo terminale e ottenere l'indirizzo IP del servizio di amministrazione dello Store usando il comando echo seguente.

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

5. Aprire un Web browser e passare all'indirizzo IP del passaggio precedente.

6. Seleziona i prodotti. Dovrebbe essere possibile aggiungere un nuovo prodotto e ottenere una descrizione usando Azure OpenAI.

Passaggi successivi

In questo articolo si è appreso come proteggere l'accesso ad Azure OpenAI dal servizio Azure Kubernetes usando l'ID del carico di lavoro Microsoft Entra.

Per altre informazioni sull'ID del carico di lavoro Microsoft Entra, vedere ID del carico di lavoro di Microsoft Entra.