Proteggere l'accesso a Azure OpenAI dal servizio Azure Kubernetes Service

Questo articolo illustra come proteggere l'accesso ad Azure OpenAI dall'Azure Kubernetes Service utilizzando Accesso privato Microsoft Entra. Scopri come:

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

Nota

Si consiglia di utilizzare Accesso privato Microsoft Entra e identità gestite su AKS per l'accesso ad Azure OpenAI poiché consente un processo di autenticazione sicuro e privo di 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 espande su Distribuire un'applicazione che utilizza OpenAI su AKS. È necessario completare quell'articolo prima di iniziare questo.
È necessario abilitare un nome di dominio personalizzato nell'account OpenAI Azure da usare per l'autorizzazione Microsoft Entra. Per altre informazioni, vedere Nomi di sottodomini personalizzati per gli strumenti Foundry.

Prerequisiti

Usare l'ambiente Bash in Azure Cloud Shell. Per altre informazioni, vedere Introduzione a Azure Cloud Shell.
Se si preferisce, per eseguire localmente i comandi di riferimento CLI, installare l'interfaccia della riga di comando di Azure per eseguire i relativi comandi di riferimento. Se si esegue in Windows o macOS, è consigliabile eseguire interfaccia della riga di comando di Azure in un contenitore Docker. Per altre informazioni, vedere Come eseguire il interfaccia della riga di comando di Azure in un contenitore Docker.
- Se si usa un'installazione locale, accedere al interfaccia della riga di comando di Azure usando il comando az login. Per completare il processo di autenticazione, seguire la procedura visualizzata nel terminale. Per altre opzioni di accesso, vedere Authenticate to Azure using interfaccia della riga di comando di Azure .For other sign-in options, see Authenticate to Azure using interfaccia della riga di comando di Azure.
- Quando richiesto, installare l'estensione interfaccia della riga di comando di Azure al primo uso. Per altre informazioni sulle estensioni, vedere Usare e gestire le estensioni con 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 Accesso privato Microsoft Entra in un cluster AKS

Per impostazione predefinita, le funzionalità ID dei carichi di lavoro di Microsoft Entra ed Endpoint dell'autorità emittente OIDC non sono abilitate nel servizio Azure Kubernetes. È necessario abilitarli nel cluster del servizio Azure Kubernetes prima di poterli usare.

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

# Set the resource group variable
RG_NAME=myResourceGroup

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

Abilitare le funzionalità Accesso privato Microsoft Entra ed OIDC Issuer Endpoint nel cluster AKS esistente usando il comando az aks update.
```
az aks update \
    --resource-group $RG_NAME \
    --name $AKS_NAME \
    --enable-workload-identity \
    --enable-oidc-issuer
```

Acquisire l'URL dell'endpoint dell'autorità emittente OIDC del servizio Azure Kubernetes mediante il comando.

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

Creare un'identità gestita assegnata dall'utente 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

Ottieni l'ID cliente dell'identità gestita e l'ID oggetto utilizzando il 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)

Ottenere l'ID della risorsa Azure OpenAI 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)

Concedere all'identità gestita l'accesso alla risorsa OpenAI 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 Microsoft Entra ID

Impostare la variabile della credenziale federata, il namespace e le variabili dell'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

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

Utilizzare un ID dei carichi di lavoro di Microsoft Entra nel servizio Azure Kubernetes

Per usare Accesso privato Microsoft Entra su AKS, è necessario apportare alcune modifiche al manifesto di distribuzione ai-service.

Creare un Account di servizio

Ottieni il kubeconfig per il tuo cluster usando il comando specifico.

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

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

Abilitare Accesso privato Microsoft Entra nel pod

Imposta le variabili nome della risorsa Azure OpenAI, endpoint e nome della distribuzione.

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

Ridistribuire con ServiceAccount e l'annotazione impostata su mediante il 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

Testare l'applicazione

Verificare che il nuovo pod sia in esecuzione usando il comando specifico.
```
kubectl get pods --selector app=ai-service
```
Ottenere le variabili di ambiente del pod usando il comando . L'output dimostra che la chiave API OpenAI Azure non esiste più nelle variabili di ambiente del pod.
```
kubectl describe pod --selector app=ai-service
```
Aprire un nuovo terminale e ottenere l'indirizzo IP del servizio di amministrazione dello Store usando il comando seguente.
```
echo "http://$(kubectl get svc/store-admin -o jsonpath='{.status.loadBalancer.ingress[0].ip}')"
```
Aprire un Web browser e passare all'indirizzo IP del passaggio precedente.
Seleziona i prodotti. Dovrebbe essere possibile aggiungere un nuovo prodotto e ottenere una descrizione per tale prodotto usando Azure OpenAI.

Passaggi successivi

In questo articolo, hai imparato come proteggere l'accesso ad Azure OpenAI da Servizio Azure Kubernetes (AKS) usando Accesso privato Microsoft Entra.

Per altre informazioni sulle Accesso privato Microsoft Entra, vedere Accesso privato Microsoft Entra.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-03-06