Tutoriel - Préparer une application pour Azure Kubernetes Service (AKS)

Dans ce tutoriel, vous préparez une application multiconteneur à utiliser dans Kubernetes. Vous allez utiliser des outils de développement existants comme Docker Compose pour générer et tester localement l’application. Vous allez apprendre à effectuer les actions suivantes :

Clonez un exemple de source d’application à partir de GitHub.
Créez une image conteneur à partir de l’exemple de source de l’application.
Testez l’application à plusieurs conteneurs dans un environnement Docker local.

Une fois ces étapes effectuées, l’application suivante s’exécute dans votre environnement de développement local :

Dans les didacticiels ultérieurs, vous chargez l’image conteneur dans un Azure Container Registry (ACR), puis déployez-la dans un cluster AKS.

Avant de commencer

Ce didacticiel présuppose une compréhension de base des concepts Docker essentiels, tels que les conteneurs, les images de conteneur et les commandes docker. Pour apprendre les principes de base des conteneurs, consultez Bien démarrer avec Docker.

Pour suivre ce tutoriel, vous avez besoin d’un environnement de développement Docker local exécutant des conteneurs Linux. Docker fournit des packages qui configurent Docker sur un système Mac, Windows ou Linux.

Remarque

Azure Cloud Shell n'inclut pas les composants Docker requis pour effectuer chaque étape de ces didacticiels. Par conséquent, nous recommandons d’utiliser un environnement de développement Docker complet.

Obtenir le code d’application

L'application d'exemple utilisée dans ce didacticiel est une application de magasin frontal de base, comprenant les déploiements et services Kubernetes suivants :

Vitrine : application web permettant aux clients d’afficher les produits et de passer des commandes.
Service de produit : affiche les informations sur le produit.
Service de commande : passe des commandes.
Rabbit MQ : file d’attente de messages pour une file d’attente de commandes.

Git
CLI Azure pour développeurs

Créez un répertoire sur votre ordinateur et basculez vers ce répertoire dans votre session de terminal, comme Bash. Cet exemple utilise un répertoire nommé demorepo , mais vous pouvez utiliser n’importe quel nom souhaité.
```
mkdir demorepo
cd demorepo
```
Utilisez git pour cloner l’exemple d’application dans votre environnement de développement.
```
git clone https://github.com/Azure-Samples/aks-store-demo.git
```
Passez au répertoire cloné.
```
cd aks-store-demo
```

Si vous utilisez azd localement, créez un répertoire vide nommé aks-store-demo pour héberger les fichiers de modèle azd.
```
mkdir aks-store-demo
```
Accédez au nouveau répertoire pour charger tous les fichiers à partir du modèle azd.
```
cd aks-store-demo
```
Clonez l’exemple d’application dans le aks-store-demo répertoire à l’aide de la azd init commande avec l’indicateur --template défini sur aks-store-demo.
```
azd init --template aks-store-demo
```

Passez en revue le fichier Docker Compose

L’exemple d’application que vous créez dans ce didacticiel utilise le docker-compose-quickstart fichier YAML à partir de la repository que vous avez cloné.

services:
  rabbitmq:
    image: rabbitmq:3.13.2-management-alpine
    container_name: 'rabbitmq'
    restart: always
    environment:
      - "RABBITMQ_DEFAULT_USER=username"
      - "RABBITMQ_DEFAULT_PASS=password"
    ports:
      - 15672:15672
      - 5672:5672
    healthcheck:
      test: ["CMD", "rabbitmqctl", "status"]
      interval: 30s
      timeout: 10s
      retries: 5
    volumes:
      - ./rabbitmq_enabled_plugins:/etc/rabbitmq/enabled_plugins
    networks:
      - backend_services
  order-service:
    build: src/order-service
    container_name: 'order-service'
    restart: always
    ports:
      - 3000:3000
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://order-service:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    environment:
      - ORDER_QUEUE_HOSTNAME=rabbitmq
      - ORDER_QUEUE_PORT=5672
      - ORDER_QUEUE_USERNAME=username
      - ORDER_QUEUE_PASSWORD=password
      - ORDER_QUEUE_NAME=orders
      - ORDER_QUEUE_RECONNECT_LIMIT=3
    networks:
      - backend_services
    depends_on:
      rabbitmq:
        condition: service_healthy
  product-service:
    build: src/product-service
    container_name: 'product-service'
    restart: always
    ports:
      - 3002:3002
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://product-service:3002/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    environment:
      - AI_SERVICE_URL=http://ai-service:5001/
    networks:
      - backend_services
  store-front:
    build: src/store-front
    container_name: 'store-front'
    restart: always
    ports:
      - 8080:8080
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://store-front:80/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    environment:
      - VUE_APP_PRODUCT_SERVICE_URL=http://product-service:3002/
      - VUE_APP_ORDER_SERVICE_URL=http://order-service:3000/
    networks:
      - backend_services
    depends_on:
      - product-service
      - order-service
networks:
  backend_services:
    driver: bridge

Créer des images conteneur et exécuter une application

Docker
CLI Azure pour développeurs

Vous pouvez utiliser Docker Compose pour automatiser la création d’images conteneur et le déploiement d’applications multiconteneurs.

Docker

Créez l’image conteneur, téléchargez l’image RabbitMQ et démarrez l’application à l’aide de la commande docker compose :
```
docker compose -f docker-compose-quickstart.yml up -d
```

Affichez les images créées à l’aide de la commande docker images.

docker images

L’exemple de sortie condensée suivant montre les images crées :

REPOSITORY                        TAG                          IMAGE ID
aks-store-demo-product-service    latest                       72f5cd7e6b84
aks-store-demo-order-service      latest                       54ad5de546f9
aks-store-demo-store-front        latest                       1125f85632ae
...

Affichez les conteneurs en cours d’exécution à l’aide de la commande docker ps.

docker ps

L’exemple de sortie condensé suivant montre quatre conteneurs en cours d’exécution :

CONTAINER ID        IMAGE
f27fe74cfd0a        aks-store-demo-product-service
df1eaa137885        aks-store-demo-order-service
b3ce9e496e96        aks-store-demo-store-front
31df28627ffa        rabbitmq:3.13.2-management-alpine

Tester l’application localement

Pour voir votre application en cours d’exécution, naviguez vers http://localhost:8080 dans un navigateur web local. L’exemple d’application est chargée, comme indiqué dans l’exemple suivant :

Sur cette page, vous pouvez afficher les produits, les ajouter à votre panier, puis passer une commande.

Nettoyer les ressources

Étant donné que vous avez validé la fonctionnalité de l’application, vous pouvez arrêter et supprimer les conteneurs en cours d’exécution. Ne supprimez pas les images conteneur , car vous les utilisez dans le didacticiel suivant.

Pour arrêter et supprimer les instances de conteneur et les ressources, utilisez la commande docker-compose down.

docker compose down

Lorsque vous utilisez azd, il n’existe aucune dépendance manuelle d’image conteneur. azd gère l’approvisionnement, le déploiement et le nettoyage de vos applications et clusters avec les commandes azd up et azd down, similaires à Docker.

Vous pouvez personnaliser les étapes de préparation pour utiliser Terraform ou Bicep avant de déployer le cluster dans la section infra de votre azure.yaml. Par défaut, ce projet utilise Terraform :

infra:
  provider: terraform
  path: infra/terraform

Si vous souhaitez modifier le fournisseur en Bicep, mettez à jour le fichier azure.yaml comme suit :

infra:
  provider: bicep
  path: infra/bicep

Dans ce tutoriel, vous avez créé un exemple d’application et des images conteneur pour l’application, puis testé l’application. Vous avez appris à :

Clonez un exemple de source d’application à partir de GitHub.
Créez une image conteneur à partir de l’exemple de source de l’application.
Testez l’application à plusieurs conteneurs dans un environnement Docker local.

Dans le prochain tutoriel, vous allez apprendre à stocker des images conteneur dans un ACR.

Pousser les images vers Azure Container Registry

Dans ce tutoriel, vous avez cloné un exemple d’application avec azd. Vous avez appris à :

Clonez un exemple de modèle azd à partir de GitHub.
Afficher où les images conteneur sont utilisées à partir de l’exemple de source de l’application.

Dans le tutoriel suivant, vous allez apprendre à créer un cluster à l’aide du modèle azd que vous avez cloné.

Créer un cluster AKS

Commentaires

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

Last updated on 2026-04-07