Sécuriser l’accès à Azure OpenAI à partir d’Azure Kubernetes Service (AKS)

Article
08/02/2024

Dans cet article, vous allez apprendre à sécuriser l’accès à Azure OpenAI à partir d’Azure Kubernetes Service (AKS) en tirant parti de l’identité de charge de travail Microsoft Entra ID. Vous allez apprendre à effectuer les actions suivantes :

Activez des identités de charge de travail sur un cluster AKS.
Créer une identité managée attribuée par l’utilisateur Azure.
Créez des informations d’identification fédérées Microsoft Entra ID.
Activer une identité de charge de travail sur un pod Kubernetes.

Remarque

Nous vous recommandons d’utiliser l’identité de charge de travail Microsoft Entra ID et des identités managées sur AKS pour l’accès Azure OpenAI, car elles vous permettent de bénéficier d’un processus d’authentification sécurisé et sans mot de passe pour accéder aux ressources Azure.

Avant de commencer

Vous devez avoir un compte Azure avec un abonnement actif. Si vous n’en avez pas un, créez un compte gratuitement.
Cet article s’appuie sur Déployer une application qui utilise OpenAI sur AKS. Vous devez compléter cet article avant de commencer celui-ci.
Vous devez avoir un nom de domaine personnalisé activé sur votre compte Azure OpenAI à utiliser pour l’autorisation Microsoft Entra. Si vous souhaitez obtenir plus d’informations, voir Noms de sous-domaine personnalisés pour Azure AI services.

Prérequis

Utilisez l’environnement Bash dans Azure Cloud Shell. Pour plus d’informations, consultez Démarrage rapide pour Bash dans Azure Cloud Shell.
Si vous préférez exécuter les commandes de référence de l’interface de ligne de commande localement, installez l’interface Azure CLI. Si vous exécutez sur Windows ou macOS, envisagez d’exécuter Azure CLI dans un conteneur Docker. Pour plus d’informations, consultez Guide pratique pour exécuter Azure CLI dans un conteneur Docker.
- Si vous utilisez une installation locale, connectez-vous à Azure CLI à l’aide de la commande az login. Pour finir le processus d’authentification, suivez les étapes affichées dans votre terminal. Pour connaître les autres options de connexion, consultez Se connecter avec Azure CLI.
- Lorsque vous y êtes invité, installez l’extension Azure CLI lors de la première utilisation. Pour plus d’informations sur les extensions, consultez Utiliser des extensions avec Azure CLI.
- Exécutez az version pour rechercher la version et les bibliothèques dépendantes installées. Pour effectuer une mise à niveau vers la dernière version, exécutez az upgrade.

Activer l’ID de charge de travail Microsoft Entra sur un cluster Azure Container Service

Les fonctionnalités de charge de travail Microsoft Entra ID et de point de terminaison d’émetteur OIDC ne sont pas activées par défaut sur AKS. Vous devez les activer sur votre cluster AKS avant de pouvoir les utiliser.

Définissez les variables nom du groupe de ressources et nom de groupe de ressources du 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)

Activez les fonctionnalités de charge de travail Microsoft Entra ID et de point de terminaison d’émetteur OIDC sur votre cluster Azure Container Service existant à l’aide de la commande az aks update.
```
az aks update \
    --resource-group $RG_NAME \
    --name $AKS_NAME \
    --enable-workload-identity \
    --enable-oidc-issuer
```

Obtenez l’URL de point de terminaison de l’émetteur OIDC AKS à l’aide de la commande az aks show.

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

Créer une identité managée attribuée par l’utilisateur Azure

Créez une identité managée affectée par l’utilisateur Azure en utilisant la commande 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

Obtenez l’ID client et l’ID d’objet de l’identité managée en tirant parti de la commande 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)

Obtenez l’ID de ressource Azure OpenAI à l’aide de la commande az resource list.

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

Accordez à l’identité managée l’accès à la ressource Azure OpenAI à l’aide de la commande 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

Créez des informations d’identification fédérées Microsoft Entra ID

Définissez les variables de compte de service, d’espace de noms et d’informations d’identification fédérées.

# 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

Créez les informations d’identification fédérées à l’aide de la commande 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}

Utiliser une charge de travail Microsoft Entra ID sur Azure Kubernetes Service

Pour utiliser la charge de travail Microsoft Entra ID sur AKS, vous devez apporter quelques modifications au manifeste de déploiement ai-service.

Créer un ServiceAccount

Obtenez le fichier kubeconfig pour votre cluster en utilisant la commande az aks get-credentials.
```
az aks get-credentials \
    --resource-group $RG_NAME \
    --name $AKS_NAME
```

Créez un ServiceAccount Kubernetes à l’aide de la commande 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

Activer l’ID de charge de travail Microsoft Entra sur le pod

Définissez les variables nom de la ressource Azure OpenAI, point de terminaison et nom de déploiement.

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

Redéployez le ai-service avec ServiceAccount et l’annotation azure.workload.identity/use définie sur true en tirant parti de la commande 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

Test de l’application

Vérifiez que le nouveau pod est en cours d’exécution à l’aide de la commande kubectl get pods.
```
kubectl get pods --selector app=ai-service -w
```
Obtenez les journaux des pods à l’aide de la commande kubectl logs. L’initialisation du pod peut prendre quelques minutes.
```
kubectl logs --selector app=ai-service -f
```
L’exemple de sortie suivant montre que l’application s’est initialisée et qu’elle est prête à accepter les requêtes. La première ligne suggère que le code contient des variables de configuration manquantes. Toutefois, le Kit de développement logiciel (SDK) Azure Identity gère ce processus et définit les variables AZURE_CLIENT_ID et 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)
```
Obtenez les variables d’environnement de pod en utilisant la commande kubectl describe pod. La sortie montre que la clé API Azure OpenAI n’existe plus dans les variables d’environnement du pod.
```
kubectl describe pod --selector app=ai-service
```
Ouvrez un nouveau terminal et obtenez l’adresse IP du service d’administration du magasin à l’aide de la commande suivante echo.
```
echo "http://$(kubectl get svc/store-admin -o jsonpath='{.status.loadBalancer.ingress[0].ip}')"
```
Ouvrez un navigateur web et accédez à l’adresse IP à partir de l’étape précédente.
Sélectionnez Produits. Vous devez être en mesure d’ajouter un nouveau produit et d’en obtenir une description en tirant parti d’Azure OpenAI.

Étapes suivantes

Dans cet article, vous avez appris à sécuriser l’accès à Azure OpenAI à partir d’Azure Kubernetes Service (AKS) en tirant parti de l’identité de charge de travail Microsoft Entra ID.

Pour plus d’informations, sur la charge de travail Microsoft Entra ID, consultez la charge de travail Microsoft Entra ID.

Partager via