Didacticiel : préparer une application pour Azure Kubernetes Service (AKS)

Article
03/21/2024

Dans ce tutoriel, premier d’une série de sept, vous allez préparer une application à plusieurs conteneurs à 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 :

Cloner un exemple de source de l’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 tutoriels ultérieurs, vous allez charger l’image conteneur dans un Azure Container Registry (ACR), puis la déployer 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 le configurent 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’exemple d’application utilisé dans ce didacticiel est une application frontale de magasin de base, notamment 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
Azure Developer CLI

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 répertoire aks-store-demo à l’aide de la commande [azd init][azd-init] 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 tutoriel utilise le fichier YAML docker-compose-quickstart à partir du référentiel que vous avez cloné.

version: "3.7"
services:
  rabbitmq:
    image: rabbitmq:3.11.17-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
  orderservice:
    build: src/order-service
    container_name: 'orderservice'
    restart: always
    ports:
      - 3000:3000
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://orderservice: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
  productservice:
    build: src/product-service
    container_name: 'productservice'
    restart: always
    ports:
      - 3002:3002
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://productservice:3002/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    networks:
      - backend_services
  storefront:
    build: src/store-front
    container_name: 'storefront'
    restart: always
    ports:
      - 8080:8080
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://storefront:80/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    environment:
      - VUE_APP_PRODUCT_SERVICE_URL=http://productservice:3002/
      - VUE_APP_ORDER_SERVICE_URL=http://orderservice:3000/
    networks:
      - backend_services
    depends_on:
      - productservice
      - orderservice
networks:
  backend_services:
    driver: bridge

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

Docker
Azure Developer CLI

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 Redis 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-productservice    latest                       2b66a7e91eca
aks-store-demo-orderservice      latest                       54ad5de546f9
aks-store-demo-storefront        latest                       d9e3ac46a225
rabbitmq                         3.11.17-management-alpine    79a570297657
...

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
21574cb38c1f        aks-store-demo-productservice
c30a5ed8d86a        aks-store-demo-orderservice
d10e5244f237        aks-store-demo-storefront
94e00b50b86a        rabbitmq:3.11.17-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 : vous les utilisez dans le tutoriel 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 remplacer le fournisseur par 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 à :

Cloner un exemple de source de l’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.

Envoyer des images à 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