Beveiligde toegang tot Azure OpenAI vanuit Azure Kubernetes Service (AKS)

In dit artikel leert u hoe u de toegang tot Azure OpenAI kunt beveiligen vanuit Azure Kubernetes Service (AKS) met behulp van Microsoft Entra Workload-ID. U leert het volgende:

Schakel workloadidentiteiten in op een AKS-cluster.
Maak een door de gebruiker toegewezen beheerde identiteit van Azure.
Maak een gefedereerde referentie voor Microsoft Entra ID.
Schakel de workload-identiteit in op een Kubernetes-pod.

Notitie

U wordt aangeraden Microsoft Entra Workload-ID en beheerde identiteiten te gebruiken in AKS voor Toegang tot Azure OpenAI, omdat hiermee een beveiligd, wachtwoordloos verificatieproces wordt ingeschakeld voor toegang tot Azure-resources.

Voordat u begint

U hebt een Azure-account met een actief abonnement nodig. Als u nog geen account hebt, maakt u gratis een account.
Dit artikel is gebaseerd op Een toepassing implementeren die Gebruikmaakt van OpenAI op AKS. U moet dat artikel voltooien voordat u met dit artikel begint.
U hebt een aangepaste domeinnaam nodig die is ingeschakeld voor uw Azure OpenAI-account voor Microsoft Entra-autorisatie. Zie Aangepaste subdomeinnamen voor Azure AI-services voor meer informatie.

Vereisten

Gebruik de Bash-omgeving in Azure Cloud Shell. Zie Aan de slag met Azure Cloud Shell voor meer informatie.
Installeer de Azure CLI, indien gewenst, om CLI-referentieopdrachten uit te voeren. Als u in Windows of macOS werkt, kunt u Azure CLI uitvoeren in een Docker-container. Zie De Azure CLI uitvoeren in een Docker-container voor meer informatie.
- Als u een lokale installatie gebruikt, meldt u zich aan bij Azure CLI met behulp van de opdracht az login. Volg de stappen die worden weergegeven in de terminal, om het verificatieproces te voltooien. Zie Verifiëren bij Azure met behulp van Azure CLI voor andere aanmeldingsopties.
- Installeer de Azure CLI-extensie bij het eerste gebruik, wanneer u hierom wordt gevraagd. Zie Extensies gebruiken en beheren met de Azure CLIvoor meer informatie over extensies.
- Voer az version uit om de geïnstalleerde versie en afhankelijke bibliotheken te vinden. Voer az upgrade uit om te upgraden naar de nieuwste versie.

Microsoft Entra Workload-ID inschakelen op een AKS-cluster

De Microsoft Entra Workload-ID- en OIDC Issuer Endpoint-functies zijn niet standaard ingeschakeld op AKS. U moet ze inschakelen in uw AKS-cluster voordat u ze kunt gebruiken.

Stel de naam van de resourcegroep en de naamvariabelen van de AKS-clustergroep in.

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

Schakel de Microsoft Entra Workload-ID- en OIDC Issuer Endpoint-functies in op uw bestaande AKS-cluster met behulp van de az aks update opdracht.
```
az aks update \
    --resource-group $RG_NAME \
    --name $AKS_NAME \
    --enable-workload-identity \
    --enable-oidc-issuer
```

Haal de eindpunt-URL van de AKS OIDC Issuer op met behulp van de az aks show opdracht.

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

Een door de gebruiker toegewezen beheerde identiteit van Azure maken

Maak een door de gebruiker toegewezen beheerde identiteit van Azure met behulp van de az identity create opdracht.

# 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

Haal de client-id en object-id van de beheerde identiteit op met behulp van de az identity show opdracht.

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

Haal de Azure OpenAI-resource-id op met behulp van de az resource list opdracht.

AOAI_RESOURCE_ID=$(az resource list --resource-group $RG_NAME --resource-type Microsoft.CognitiveServices/accounts --query "[0].id" -o tsv)

Geef de beheerde identiteit toegang tot de Azure OpenAI-resource met behulp van de az role assignment create opdracht.

az role assignment create \
    --role "Cognitive Services OpenAI User" \
    --assignee-object-id $MANAGED_IDENTITY_OBJECT_ID \
    --assignee-principal-type ServicePrincipal \
    --scope $AOAI_RESOURCE_ID

Federatieve referenties voor Microsoft Entra-id maken

Stel de variabelen voor federatieve referentie, naamruimte en serviceaccount in.

# 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

Maak de federatieve inloggegevens met behulp van de az identity federated-credential create opdracht.

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}

Microsoft Entra Workload-ID gebruiken in AKS

Als u Microsoft Entra Workload-ID op AKS wilt gebruiken, moet u enkele wijzigingen aanbrengen in het ai-service implementatiemanifest.

Een ServiceAccount maken

Haal de kubeconfig voor uw cluster op met behulp van de az aks get-credentials opdracht.
```
az aks get-credentials \
    --resource-group $RG_NAME \
    --name $AKS_NAME
```

Maak een Kubernetes ServiceAccount met behulp van de kubectl apply opdracht.

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

Microsoft Entra Workload-ID inschakelen op de pod

Stel de azure OpenAI-resourcenaam, het eindpunt en de implementatienaamvariabelen in.

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

Herimplementeer de ai-service met het ServiceAccount en de azure.workload.identity/use aantekening dat is ingesteld op true door de kubectl apply opdracht te gebruiken.

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

De toepassing testen

Controleer of de nieuwe pod actief is met behulp van het kubectl get pods commando.
```
kubectl get pods --selector app=ai-service
```
Haal de omgevingsvariabelen voor pods op met behulp van de kubectl describe pod opdracht. De uitvoer laat zien dat de Azure OpenAI API-sleutel niet meer bestaat in de omgevingsvariabelen van de Pod.
```
kubectl describe pod --selector app=ai-service
```
Open een nieuwe terminal en haal het IP-adres van de winkelbeheerdersservice op met behulp van de volgende echo opdracht.
```
echo "http://$(kubectl get svc/store-admin -o jsonpath='{.status.loadBalancer.ingress[0].ip}')"
```
Open een webbrowser en navigeer naar het IP-adres uit de vorige stap.
Selecteer Producten. U moet een nieuw product kunnen toevoegen en er een beschrijving voor krijgen met behulp van Azure OpenAI.

Volgende stappen

In dit artikel hebt u geleerd hoe u de toegang tot Azure OpenAI kunt beveiligen vanuit Azure Kubernetes Service (AKS) met behulp van Microsoft Entra Workload-ID.

Zie Microsoft Entra Workload-ID voor meer informatie over Microsoft Entra Workload-ID.

Feedback

Is deze pagina nuttig?

Last updated on 2025-07-14