Déployer une application qui utilise OpenAI sur Azure Kubernetes Service (AKS)

Dans cet article, vous déployez l’application de démonstration AKS Store sur Azure Kubernetes Service (AKS) et configurez Azure OpenAI ou l’API OpenAI pour générer des descriptions de produits.

L’exemple d’application native cloud comprend des services écrits dans plusieurs langages et frameworks, notamment :

Golang avec Gin
Rust avec Actix-Web
JavaScript avec Vue.js et Fastify
Python avec FastAPI

Ces applications fournissent des serveurs frontaux pour les acheteurs et les administrateurs de magasin, les API REST qui envoient des données à une file d’attente de messages RabbitMQ et une base de données DocumentDB et des applications console qui simulent le trafic.

Note

N’exécutez pas de conteneurs avec état, tels que DocumentDB et RabbitMQ, sans stockage persistant en production. Cet article les utilise sans stockage persistant par souci de simplicité. Pour les charges de travail de production, utilisez des services managés tels que Azure Cosmos DB ou Azure Service Bus.

Pour accéder à la base de code GitHub pour l’exemple d’application, consultez AKS Store Demo.

Avant de commencer

Vous avez besoin d’un compte Azure avec un abonnement actif. Si vous n’en avez pas un, créez un compte gratuitement.
Pour cette démonstration, utilisez Azure OpenAI ou l’API OpenAI.
- Pour utiliser Azure OpenAI, vous avez besoin d’autorisations pour créer une ressource OpenAI Azure et déployer un modèle. L’inscription n’est requise que pour les modèles à accès limité ou les protections modifiées.
- Pour utiliser l’API OpenAI, inscrivez-vous sur le site web OpenAI.

Prérequis

Utilisez l’environnement Bash dans Azure Cloud Shell. Pour plus d’informations, consultez Démarrez avec Azure Cloud Shell.
Si vous préférez exécuter des commandes de référence CLI localement, installation la 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 How to run the Azure CLI in a Docker container.
- Si vous utilisez une installation locale, connectez-vous au Azure CLI à l'aide de la commande az login. Pour finir le processus d’authentification, suivez les étapes affichées dans votre terminal. Pour obtenir d’autres options de connexion, consultez Authenticate pour Azure à l’aide de 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 Utilisez et gérez les extensions avec le 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.

Créer un groupe de ressources

Un groupe de ressources Azure est un groupe logique dans lequel vous déployez et gérez des ressources Azure. Lorsque vous créez un groupe de ressources, vous êtes invité à spécifier un emplacement. Cet emplacement est l'emplacement de stockage de vos métadonnées de groupe de ressources et où vos ressources s'exécutent dans Azure si vous ne spécifiez pas une autre région lors de la création de ressources.

L’exemple suivant crée un groupe de ressources nommé myResourceGroup à l’emplacement eastus.

Créez un groupe de ressources à l’aide de la commande az group create.

az group create --name myResourceGroup --location eastus

L’exemple de sortie suivant montre la création réussie du groupe de ressources :

{
  "id": "/subscriptions/<guid>/resourceGroups/myResourceGroup",
  "location": "eastus",
  "managedBy": null,
  "name": "myResourceGroup",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null,
  "type": "Microsoft.Resources/resourceGroups"
}

Créer un cluster AKS

L’exemple suivant crée un cluster nommé myAKSCluster dans myResourceGroup.

Créez un cluster AKS avec la commande az aks create.

az aks create --resource-group myResourceGroup --name myAKSCluster --generate-ssh-keys

Au bout de quelques minutes, la commande se termine et retourne des informations au format JSON sur le cluster.

Se connecter au cluster

Pour gérer un cluster Kubernetes, utilisez le client de ligne de commande de Kubernetes, kubectl. Si vous utilisez Azure Cloud Shell, kubectl est déjà installé.

Installez kubectl localement avec la commande az aks install-cli.
```
az aks install-cli
```
Note

Si votre système Linux nécessite des autorisations élevées, utilisez la sudo az aks install-cli commande.
Configurez kubectl afin de vous connecter à votre cluster Kubernetes avec la commande az aks get-credentials.

Cette commande exécute les opérations suivantes :
- Cette étape télécharge les informations d’identification et configure l’interface de ligne de commande Kubernetes pour leur utilisation.
- ~/.kube/config, l’emplacement par défaut du fichier de configuration Kubernetes. Spécifiez un autre emplacement pour votre fichier de configuration Kubernetes à l’aide de l’argument --file .
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```

Pour vérifier la connexion à votre cluster, exécutez la commande kubectl get. Cette commande renvoie la liste des nœuds de cluster.

kubectl get nodes

L’exemple de sortie suivant montre les nœuds créés dans les étapes précédentes. Vérifiez que chaque nœud a l’état Prêt.

NAME                                STATUS   ROLES   AGE     VERSION
aks-nodepool1-31469198-vmss000000   Ready    agent   3h29m   v1.25.6
aks-nodepool1-31469198-vmss000001   Ready    agent   3h29m   v1.25.6
aks-nodepool1-31469198-vmss000002   Ready    agent   3h29m   v1.25.6

Note

Pour un cluster AKS privé, connectez-vous à partir d’un point de terminaison dans le même réseau virtuel que le cluster. Pour obtenir des instructions de configuration, consultez Créer un cluster AKS privé.

Déployer l’application

Le manifeste AKS Store inclut les déploiements et services Kubernetes suivants :

Service de produit : affiche les informations sur le produit.
Service de commande : passer des commandes.
Service Makeline : traite les commandes de la file d’attente et termine les commandes.
Vitrine : application web permettant aux clients d’afficher les produits et de passer des commandes.
Administrateur de magasin : application web permettant aux employés du magasin d’afficher les commandes dans la file d’attente et de gérer les informations sur le produit.
Client virtuel : simule la création de commandes sur une base planifiée.
Virtual Worker : simule l’achèvement des commandes sur une base planifiée.
DocumentDB : instance NoSQL pour les données persistantes.
RabbitMQ: Système de messagerie pour une file de commandes.

Note

Passez en revue le manifeste YAML pour l’application.

Déployez l’application à l’aide de la commande kubectl apply et spécifiez le nom de votre manifeste YAML.

kubectl apply -f https://raw.githubusercontent.com/Azure-Samples/aks-store-demo/main/aks-store-all-in-one.yaml

Déployer un service OpenAI

Choisissez Azure OpenAI ou l’API OpenAI pour l’application s’exécutant sur AKS.

Azure OpenAI
OpenAI

Dans le portail Azure, créez une instance OpenAI Azure.
Connectez-vous à Microsoft Foundry.
Désactivez le bouton bascule New Foundry , puis sélectionnez Afficher toutes les ressources sous Conserver la génération avec Foundry.
Sélectionnez la Azure ressource OpenAI que vous avez créée, puis sélectionnez Déploiements sous Ressources partagées.
Sélectionnez Déployer le modèle>Déployer le modèle de base.
Sélectionnez le modèle de base gpt-4o-mini , entrez un nom de déploiement, puis déployez le modèle. Enregistrez le nom du déploiement pour la section suivante.

Pour plus d’informations sur la création d’un déploiement Azure OpenAI, consultez Prise en main de la génération de texte à l’aide de Azure OpenAI.

Déployer le microservice IA

Déployez le microservice IA basé sur Python qui utilise OpenAI pour générer automatiquement des descriptions de produits. Ce microservice se connecte à l’application du Store AKS que vous avez déployée dans la section précédente.

Azure OpenAI
OpenAI

Utilisez la Azure ressource OpenAI et le déploiement de modèle que vous avez créés dans la section Déployer un service OpenAI. Configurez les variables d’environnement suivantes dans le manifeste de microservice IA :

Variable d'environnement	Valeur
`USE_AZURE_OPENAI`	Définissez la valeur à `"True"` utiliser Azure OpenAI.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Nom de votre `gpt-4o-mini` déploiement de modèle dans Microsoft Foundry.
`AZURE_OPENAI_ENDPOINT`	Point de terminaison à partir de la page Clés et point de terminaison de votre ressource OpenAI Azure.
`OPENAI_API_KEY`	Clé API à partir de la page Clés et point de terminaison de votre ressource OpenAI Azure.

Créez un fichier nommé ai-service.yaml et copiez-y le manifeste suivant :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ai-service
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ai-service
  template:
    metadata:
      labels:
        app: ai-service
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
        - name: ai-service
          image: ghcr.io/azure-samples/aks-store-demo/ai-service:2.2.0
          ports:
            - containerPort: 5001
          env:
            - name: USE_AZURE_OPENAI
              value: "True"
            - name: AZURE_OPENAI_DEPLOYMENT_NAME
              value: ""
            - name: AZURE_OPENAI_ENDPOINT
              value: ""
            - name: OPENAI_API_KEY
              value: ""
          resources:
            requests:
              cpu: 20m
              memory: 50Mi
            limits:
              cpu: 50m
              memory: 128Mi
---
apiVersion: v1
kind: Service
metadata:
  name: ai-service
spec:
  type: ClusterIP
  ports:
    - name: http
      port: 5001
      targetPort: 5001
  selector:
    app: ai-service

Définissez la variable d’environnement USE_AZURE_OPENAI sur "True".
Dans Microsoft Foundry, copiez le nom du déploiement OpenAI Azure et définissez la AZURE_OPENAI_DEPLOYMENT_NAME valeur.
Dans le portail Azure, sélectionnez Clés et point de terminaison dans votre ressource OpenAI Azure. Copiez le point de terminaison et la clé API, puis définissez les valeurs et OPENAI_API_KEY les AZURE_OPENAI_ENDPOINT valeurs.
Déployez l’application à l’aide de la commande kubectl apply et spécifiez le nom de votre manifeste YAML.
```
kubectl apply -f ai-service.yaml
```
L’exemple de sortie suivant montre les déploiements et services créés :
```
  deployment.apps/ai-service created
  service/ai-service created
```

Utilisez la clé secrète OpenAI et l’ID d’organisation à partir de la section Déployer un service OpenAI . Configurez les variables d’environnement suivantes dans le manifeste de microservice IA :

Variable d'environnement	Valeur
`USE_AZURE_OPENAI`	Définissez cette option pour `"False"` utiliser OpenAI.
`OPENAI_API_KEY`	Clé secrète OpenAI générée dans la page clés d’API OpenAI.
`OPENAI_ORG_ID`	ID de votre organisation à partir de la page des paramètres de l’organisation OpenAI.

Créez un fichier nommé ai-service.yaml et copiez-y le manifeste suivant :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ai-service
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ai-service
  template:
    metadata:
      labels:
        app: ai-service
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
        - name: ai-service
          image: ghcr.io/azure-samples/aks-store-demo/ai-service:2.2.0
          ports:
            - containerPort: 5001
          env:
            - name: USE_AZURE_OPENAI
              value: "False"
            - name: OPENAI_API_KEY
              value: ""
            - name: OPENAI_ORG_ID
              value: ""
          resources:
            requests:
              cpu: 20m
              memory: 50Mi
            limits:
              cpu: 50m
              memory: 128Mi
---
apiVersion: v1
kind: Service
metadata:
  name: ai-service
spec:
  type: ClusterIP
  ports:
    - name: http
      port: 5001
      targetPort: 5001
  selector:
    app: ai-service

Définissez la variable d’environnement USE_AZURE_OPENAI sur "False".
Définissez OPENAI_API_KEY la clé secrète OpenAI que vous avez générée sur la page clés API OpenAI dans la section Déployer un service OpenAI .
Définissez OPENAI_ORG_ID l’ID d’organisation à partir de la page des paramètres de votre organisation OpenAI.
Déployez l’application à l’aide de la commande kubectl apply et spécifiez le nom de votre manifeste YAML.
```
kubectl apply -f ai-service.yaml
```
L’exemple de sortie suivant montre les déploiements et services créés :
```
  deployment.apps/ai-service created
  service/ai-service created
```

Note

Le stockage des clés API directement dans les manifestes Kubernetes est non sécurisé et peut exposer des secrets dans le contrôle de code source. Cet exemple utilise des valeurs de manifeste par souci de simplicité. Pour les charges de travail de production, authentifiez-vous à Azure OpenAI à l’aide d’une identité managée ou stockez des secrets dans Azure Key Vault.

Test de l’application

Vérifiez l'état des pods déployés à l'aide de la commande kubectl get pods.
```
kubectl get pods
```
Vérifiez que tous les pods ont un état d’exécution avant de continuer.
Obtenez l’adresse IP externe de l’administrateur du Windows Store à l’aide de la kubectl get service commande.
```
kubectl get service store-admin
```
Un service Kubernetes expose l’administrateur du Windows Store via un équilibreur de charge public. L’équilibreur de charge peut prendre quelques minutes pour affecter une adresse. La valeur EXTERNAL-IP s’affiche en attente jusqu’à ce que l’adresse soit disponible.
```
NAME          TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
store-admin   LoadBalancer   10.0.142.228   40.64.86.161    80:32494/TCP   50m
```
Répétez l’étape précédente pour le store-front service.
Dans un navigateur web, accédez à l’adresse IP externe de l’administrateur du Windows Store. Dans cet exemple, l’adresse est 40.64.86.161.
Dans l’administrateur du Windows Store, sélectionnez Produits>Ajouter un produit.
Une fois ai-service démarré, le bouton Demander à l’Assistant IA apparaît en regard du champ de description. Entrez le nom, le prix et les mots clés, sélectionnez Demander à l’Assistant IA pour générer une description de produit, puis sélectionnez Enregistrer le produit.
Vérifiez que Dog Smart Collar s’affiche dans l’administrateur du Windows Store.
Accédez à l’adresse IP externe pour Store Front et vérifiez que Dog Smart Collar s’affiche.

Étapes suivantes

Maintenant que vous avez ajouté des fonctionnalités OpenAI à une application AKS, vous pouvez sécuriser l'accès à Azure OpenAI depuis Azure Kubernetes Service (AKS).

Pour en savoir plus sur les cas d’usage de l’IA générative, consultez les ressources suivantes :

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-08-13

Déployer une application qui utilise OpenAI sur Azure Kubernetes Service (AKS)

Avant de commencer

Prérequis

Créer un groupe de ressources

Créer un cluster AKS

Se connecter au cluster

Déployer l’application

Déployer un service OpenAI

Déployer le microservice IA

Test de l’application

Étapes suivantes

Commentaires

Ressources supplémentaires