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

Dans ce tutoriel, vous préparez une application multiconteneur à utiliser dans Kubernetes. Vous pouvez utiliser ce didacticiel si vous commencez par un nouvel exemple d'application ou si vous adaptez les concepts Docker Compose pour une application que vous envisagez de migrer vers Azure Kubernetes Service (AKS). 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 :

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.

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.
• RabbitMQ: Système de messagerie pour une file de commandes.

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é.

Le tableau suivant récapitule les valeurs par défaut clés de l’exemple de fichier Compose afin de voir rapidement quels services, ports et dépendances le didacticiel utilise :

services:
  rabbitmq:
    image: rabbitmq:4.3.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
    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
    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

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

Assurez-vous que Docker s’exécute en mode conteneur Linux avant d’exécuter les commandes suivantes.

1. À partir de la racine du référentiel cloné aks-store-demo , créez l’image conteneur, téléchargez l’image RabbitMQ et démarrez l’application à l’aide de la docker compose commande :

   docker compose -f docker-compose-quickstart.yml up -d
   

2. 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
   ...
   

3. 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:4.3.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.

Migrer vos propres fichiers Compose

Si vous disposez déjà d’une application définie dans un fichier Docker Compose, vous pouvez utiliser ce didacticiel comme référence pour la validation locale, puis convertir votre configuration Compose existante en manifestes Kubernetes. Utilisez des outils tels que Kompose, Move2Kube, Docker Compose Bridge ou Podman pour convertir des définitions Docker Compose en ressources Kubernetes. Pour obtenir le chemin de conversion complet de bout en bout, consultez la documentation Kubernetes pour la migration de Docker Compose vers Kubernetes et la vue d’ensemble de la migration AKS si vous passez également d’un autre orchestrateur ou d’un autre workflow de modernisation.

Choisir un outil de conversion

Utilisez ce tableau lorsque vous avez besoin d’une comparaison rapide des options Compose-to-Kubernetes les plus courantes.

Quel outil dois-je choisir ?

• Si vous souhaitez une preuve rapide de concept ou de manifestes de démarrage, utilisez Kompose.
• Si vous utilisez Docker Desktop et souhaitez un chemin d’accès Docker natif, utilisez Docker Compose Bridge.
• Si vous avez un plus grand effort de migration ou de modernisation multiservices, utilisez Move2Kube.
• Si vous souhaitez exporter à partir de conteneurs ou de pods en cours d’exécution, utilisez Podman.
• Si vous avez déjà des manifestes et avez besoin d’empaquetages ou de superpositions, utilisez Helm ou Kustomize.
• Si vous avez besoin d’une boucle de développement Kubernetes locale après la conversion, utilisez Skaffold ou Tilt.
• Si vous souhaitez des manifestes brouillons ou des explications de migration, utilisez l’assistance IA et validez le résultat par rapport aux recommandations officielles de Kubernetes et AKS.

Autres outils à prendre en compte :

• 8gwifi.org Convertisseur YAML Kubernetes : utile pour les expériences en ligne rapides avec de petits fichiers Compose.
• Okteto : Utile lorsque vous souhaitez une boucle de développement Kubernetes cloud ou distante pour les équipes d’applications.
• Devtron : utile lorsque vous souhaitez disposer d’un flux de travail de plateforme pour le déploiement sur Kubernetes une fois la conversion effectuée.
• Portainer : utile lorsque vous souhaitez une expérience de gestion des conteneurs et de Kubernetes pilotée par une interface utilisateur.

Convertir vos fichiers Compose

Utilisez les commandes copieables suivantes comme point de départ :

kompose convert
move2kube plan -s ./path && move2kube transform
docker compose bridge convert -o ./k8s/
podman kube generate mypod > k8s.yaml
skaffold init

Exemple de conversion Kompose

L’outil Kompose open source convertit les paramètres Docker Compose courants en objets Kubernetes tels que Deployments and Services.

1. Sur Windows, installez Kompose avec la commande suivante :

   curl -L https://github.com/kubernetes/kompose/releases/latest/download/kompose-windows-amd64.exe -o kompose.exe
   

   Pour obtenir d’autres options d’installation, consultez les instructions d’installation de Kompose.

2. Exécutez Kompose à partir du répertoire qui contient votre docker-compose.yml fichier.

   kompose convert
   

3. Passez en revue les fichiers YAML Kubernetes générés avant de les déployer sur AKS.

Conversion assistée par l’IA

Vous pouvez utiliser un assistant IA pour rédiger des manifestes Kubernetes, comparer les paramètres Compose à des équivalents Kubernetes ou expliquer pourquoi une conversion a besoin de modifications manuelles.

Exemple générique d’invite :

Convert this docker-compose.yml into production-ready Kubernetes manifests. Use Apps/v1, move secrets to Kubernetes Secret objects, map local volumes to PersistentVolumeClaims, and add readiness and liveness probes for the web service.

Exemple d’invite ciblant AKS :

Convert this docker-compose.yml into AKS-ready Kubernetes manifests. Target an AKS cluster, push images to Azure Container Registry, use Apps/v1 objects, move secrets to Kubernetes Secret objects, map local volumes to Azure Files or Azure Disks-backed PersistentVolumeClaims, and add readiness and liveness probes for the web service.

Examinez toujours le résultat produit par l’IA avant de l’utiliser. Validez les valeurs apiVersion, les demandes et limites de ressources, les classes de stockage, l’exposition des services et les sondes d’intégrité.

Gérer les problèmes de traduction courants

Comment les volumes sont-ils gérés ?

Compose volumes a souvent besoin de volumes persistants Kubernetes et d’une classe de stockage. Dans AKS, remplacez les montages locaux uniquement par des services tels que Azure Disques ou Azure Files.

Qu’est-ce qui remplace depends_on?

Compose depends_on n’applique pas la préparation du runtime dans Kubernetes. Remplacez-le par des sondes de préparation, des sondes de démarrage ou une logique de conteneur init si nécessaire.

Comment gérer les secrets et les valeurs d’environnement ?

Les valeurs d’environnement de Compose deviennent souvent des ressources Kubernetes ConfigMap ou Secret, ou des intégrations à Azure Key Vault.

Que se passe-t-il pour les ports et l’entrée ?

Les ressources Compose ports correspondent à des objets Kubernetes Service et parfois à des ressources ingress ou Gateway API, selon la façon dont vous publiez l’application.

Comment les vérifications de l’état de santé sont-elles traduites ?

Les paramètres Compose healthcheck deviennent généralement des sondes Kubernetes de vivacité et de disponibilité.

Que deviennent les réseaux Compose ?

Les réseaux Compose se traduisent généralement par la découverte de services de Kubernetes via les Services et le DNS du cluster, plutôt que par des réseaux de pont personnalisés.

Comment tester localement avec Kubernetes ?

Après la conversion, déployez les manifestes générés dans un environnement Kubernetes local tel que type ou minikube, puis utilisez Skaffold ou Tilt si vous souhaitez une boucle edit-build-deploy plus rapide.

Appliquer des ajustements spécifiques à AKS après la conversion

Kompose vous donne un point de départ, mais vous devez généralement apporter des modifications manuelles pour AKS :

• Mettez à jour les références d’image pour pointer vers votre Azure Container Registry (ACR).
• Remplacez le stockage local uniquement et liez des montages avec un stockage persistant tel que Azure Disques ou Azure Files, en fonction des besoins de votre charge de travail.
• Remplacez les secrets Compose ou les valeurs spécifiques à l’environnement par des Secrets Kubernetes, des ConfigMaps ou des intégrations à Azure Key Vault.
• Passez en revue les paramètres de mise en réseau et d’exposition, tels que LoadBalancer, l’entrée ou la configuration de la passerelle, en fonction de la façon dont vous souhaitez publier l’application dans AKS.
• Vérifiez si les composants avec état doivent rester en tant que déploiements ou passer à des modèles tels que StatefulSets lorsque vous avez besoin d’une identité stable ou d’un comportement de stockage.
• Validez les demandes de ressources, les sondes et toutes les hypothèses concernant l’ordre de démarrage, car des comportements de Compose tels que depends_on ne se traduisent pas directement dans le comportement d’exécution de Kubernetes.

Flux de travail post-conversion

1. Convertissez le fichier Compose avec un outil tel que Kompose, Move2Kube, Docker Compose Bridge, Podman ou un brouillon examiné par l’IA.
2. Examinez et renforcez les manifestes en corrigeant le stockage, les secrets, l’exposition au service, les sondes et les références d’image.
3. Regroupez les manifestes avec Helm ou superposez des modifications spécifiques à l’environnement avec Kustomize.
4. Envoyez vos images à un registre tel qu’ACR, puis déployez avec GitOps, CI/CD ou des flux de travail directs kubectl .

Exemple de séquence : kompose convert -> passer en revue les manifestes -> envoyer des images à ACR - mettre à jour les> références d’images ->kubectl apply ou helm install.

Nettoyer les ressources

Si vous avez suivi le flux de travail Docker Compose, 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. Si vous avez suivi le flux de travail d’Azure Developer CLI, utilisez azd down au lieu de docker compose down.

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

docker compose down

Commandes de l’interface CLI Azure Developer

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

Étapes suivantes

Azure CLI

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

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

Azure CLI pour développeurs

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

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