[Docker Compose] Installation, utilisation et déploiement de Docker Compose de clusters de microservices

---

Préface : Problèmes de déploiement de Docker

Dans les applications pratiques, lorsque nous devons déployer un grand nombre de conteneurs Docker, il devient très fastidieux de gérer manuellement la configuration et le déploiement de ces conteneurs. Chaque conteneur peut nécessiter différents paramètres, mappages de ports, paramètres réseau, etc., ce qui entraîne une complexité de gestion et de maintenance. Pour résoudre ce problème, nous pouvons utiliser l'outil Docker Compose, qui fournit un moyen simple et unifié de définir et de gérer des applications Docker multi-conteneurs.

1. Première introduction à Docker Compose

1.1 Qu'est-ce que Docker Compose

Docker Compose est un outil fourni par Docker Company pour définir et exécuter des applications Docker multi-conteneurs. Avec Docker Compose, vous pouvez utiliser de simples fichiers YAML pour configurer divers paramètres tels que les services, les réseaux, les volumes, etc. pour l'ensemble de l'application. De cette manière, nous pouvons facilement déployer et gérer plusieurs conteneurs Docker en un seul clic, simplifiant ainsi la configuration et la gestion des applications multi-conteneurs.

1.2 Installer Docker Compose sur CentOS

L'installation de Docker Compose est très simple et peut être installée sur CentOS en suivant ces étapes :

1. Ouvrez un terminal et connectez-vous en tant qu'utilisateur root.

2. Téléchargez les binaires Docker Compose à l'aide de la commande suivante :

   sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
   

3. Accordez des autorisations d'exécution :

   sudo chmod +x /usr/local/bin/docker-compose
   

4. Vérifiez l'installation :

   docker-compose --version
   

   Si l'installation réussit, les informations de version de Docker Compose seront affichées.

Grâce aux étapes ci-dessus, Docker Compose a été installé avec succès sur CentOS. Nous explorerons ensuite en profondeur comment utiliser Docker Compose pour écrire et gérer des applications multi-conteneurs.

2. Compréhension approfondie des fichiers Docker Compose

2.1 Présentation du fichier Docker Compose

Un fichier Docker Compose est un fichier YAML utilisé pour définir et configurer des services, des réseaux, des volumes, etc. pour une application Docker multi-conteneurs. Grâce aux fichiers Docker Compose, nous pouvons décrire la structure et les paramètres de l'application de manière déclarative, simplifiant ainsi le déploiement et la gestion des applications conteneurisées.

Un fichier Docker Compose de base comprend généralement les éléments suivants :

• version: Spécifiez la version du fichier Compose
• services: Définissez chaque service, chaque service correspond à un conteneur.
• networks: Définir les paramètres réseau.
• volumes: Définissez des volumes pour les données persistantes.

Voici un exemple de fichier Docker Compose simple :

version: '3'

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
  db:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: example

networks:
  app_net:

volumes:
  data_vol:

Dans cet exemple, deux services webet sont définis db, ainsi qu'un réseau app_netet un volume data_vol.

2.2 Explication détaillée des fichiers Docker Compose

1. versioninstruction

versionLa directive est utilisée pour spécifier la version du fichier Compose. Différentes versions peuvent prendre en charge différentes fonctionnalités et syntaxes. Les versions courantes incluent 2, 2.1, 3, etc. Choisissez la version appropriée en fonction de vos besoins.

2. servicesinstruction

servicesLa directive définit chaque service, et chaque service correspond à un conteneur. Chaque service peut inclure les éléments de configuration courants suivants :

• image: Spécifiez l'image à utiliser.
• build: Spécifiez le chemin du Dockerfile pour créer l'image.
• ports: Spécifiez le mappage de port.
• environment: Spécifiez les variables d'environnement.
• volumes: Montez le volume spécifié.

Voici un exemple de service :

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html

Dans cet exemple, weble service utilise nginx:latestune image, ./htmlmonte le répertoire de l'hôte dans le /usr/share/nginx/htmlrépertoire du conteneur et mappe le 8080port de l'hôte sur le 80port du conteneur.

3. networksinstruction

networksLes directives sont utilisées pour définir les paramètres réseau. Un réseau spécifique peut être spécifié pour le service. Voici un exemple de réseau :

networks:
  app_net:

Dans cet exemple, un app_netréseau nommé est défini.

4. volumesinstruction

volumesLes directives sont utilisées pour définir des volumes pour les données persistantes. Voici un exemple de volume :

volumes:
  data_vol:

Dans cet exemple, un data_volvolume nommé est défini.

2.3 Exemple : écriture d'un fichier Docker Compose

version: '3'

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html
  db:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: example

networks:
  app_net:

volumes:
  data_vol:

Dans cet exemple, deux services webet sont définis db, ainsi qu'un réseau app_netet un volume data_vol:

• webLe service utilise nginx:latestla mise en miroir pour ./htmlmonter le répertoire de l'hôte sur le /usr/share/nginx/htmlrépertoire du conteneur et mapper le 8080port de l'hôte sur le port du conteneur 80.
• dbLe service utilise mysql:5.7la mise en miroir et définit le mot de passe root MySQL. Réseau app_netet Volume data_voldéfinissent respectivement un réseau et un volume.

Grâce à cet exemple, vous pouvez mieux comprendre la structure et la syntaxe de base des fichiers Docker Compose. Dans la prochaine leçon, nous en apprendrons davantage sur la façon d'utiliser Docker Compose pour déployer et gérer des applications multi-conteneurs.

3. Commandes liées à Docker Compose

Docker Compose fournit une série de commandes pour gérer les applications multi-conteneurs. Ci-dessous, nous présenterons quelques commandes Docker Compose couramment utilisées pour vous aider à mieux utiliser et gérer les applications conteneurisées.

3.1 Commandes Docker Compose couramment utilisées

1. docker-compose up

Démarrez le conteneur. Exécutez cette commande dans le répertoire du projet et Compose démarrera docker-compose.ymlle service correspondant basé sur le fichier. S'il n'y a pas docker-compose.ymlde fichier, vous pouvez utiliser -fle paramètre pour spécifier d'autres fichiers Compose.

docker-compose up

2. docker-compose down

Arrêtez et supprimez les conteneurs, les réseaux et les volumes. L'exécution de cette commande dans le répertoire du projet entraînera l'arrêt et la suppression de Compose de tous les services associés au projet. Vous pouvez également utiliser -fle paramètre pour spécifier d'autres fichiers Compose.

docker-compose down

3. docker-compose ps

Répertorie l'état de tous les services du projet. Exécutez cette commande dans le répertoire du projet et Compose répertoriera l'état de tous les services du projet, y compris l'état d'exécution, le mappage des ports et d'autres informations.

docker-compose ps

4. docker-compose logs

Affichez la sortie du journal du service. Exécutez cette commande dans le répertoire du projet et Compose affichera la sortie du journal en temps réel de tous les services du projet.

docker-compose logs

5. docker-compose exec

Exécutez la commande dans le service. Vous pouvez utiliser cette commande pour exécuter des commandes spécifiques dans le service spécifié, par exemple :

docker-compose exec web ls -l

Ci-dessus sont quelques commandes Docker Compose couramment utilisées. Grâce à ces commandes, nous pouvons facilement démarrer, arrêter et gérer des applications multi-conteneurs.

3.2 Exemple : Déployer une application Web simple à l'aide de Docker Compose

Voici un exemple simple pour montrer comment utiliser Docker Compose pour déployer une application qui inclut des services Web et des services de base de données.

1. Écrire des fichiers Docker Compose

Créez un docker-compose.ymlfichier appelé et ajoutez le contenu suivant :

version: '3'

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
  db:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: example

Dans cet exemple, deux services webet sont définis db. webLe service utilise nginx:latestla mise en miroir pour 8080mapper le port de l'hôte au 80port du conteneur. dbLe service utilise mysql:5.7la mise en miroir et définit le mot de passe root MySQL.

2. Démarrer l'application

Dans le répertoire contenant docker-compose.ymlle fichier, exécutez la commande suivante pour démarrer l'application :

docker-compose up

Compose démarrera deux services, exécutés respectivement dans deux conteneurs. webLe service utilise Nginx pour fournir des services Web et dble service utilise MySQL pour fournir des services de base de données.

3. Accéder aux applications Web

Une fois accessible dans le navigateur http://宿主机IP:8080, vous verrez la page d'accueil fournie par Nginx. À ce stade, une simple application multi-conteneurs est déployée et exécutée avec succès.

4. arrêter et nettoyer

Lorsque l'application n'est plus nécessaire, vous pouvez arrêter et nettoyer les conteneurs, les réseaux et les volumes en exécutant les commandes suivantes :

docker-compose down

Grâce à cet exemple simple, cela peut nous aider à écrire des fichiers Docker Compose et à utiliser Docker Compose pour démarrer, arrêter et gérer des applications multi-conteneurs. Cela sera très utile pour la gestion d’applications conteneurisées complexes.

4. Utilisez Docker Compose pour déployer des clusters de microservices

Objectif : utiliser Docker Compose pour cloud-demodéployer un cluster de projet de microservice dans un conteneur Docker.

1. Créez d'abord un répertoire cloud-demo, puis créez quatre dossiers dans ce répertoire : , , gateway, mysqlet créez-en un autre pour écrire les informations de configuration de Docker Compose.order-serviceuser-servicedocker-compose.yml

2. Écrire des fichiers Docker Compose

version: "3.2"

services:
  nacos:
    image: nacos/nacos-server
    environment:
      MODE: standalone
    ports:
      - "8848:8848"
  mysql:
    image: mysql:5.7.25
    environment:
      MYSQL_ROOT_PASSWORD: 123
    volumes:
      - "$PWD/mysql/data:/var/lib/mysql"
      - "$PWD/mysql/conf:/etc/mysql/conf.d/"
  userservice:
    build: ./user-service
  orderservice:
    build: ./order-service
  gateway:
    build: ./gateway
    ports:
      - "10010:10010"

Description :
Il s'agit d'un docker-compose.ymlfichier utilisé pour définir les informations de configuration de Docker Compose. Il contient la définition de plusieurs services, chaque service a une configuration spécifique.

• nacosLe service utilise nacos/nacos-serverl'image, définit la variable d'environnement MODEsur standaloneet mappe le port 8848 du conteneur au port 8848 de l'hôte.

• mysqlLe service utilise mysql:5.7.25la mise en miroir, définit le mot de passe de l'utilisateur root MySQL 123et monte deux répertoires locaux dans le conteneur pour stocker respectivement les données MySQL et les fichiers de configuration.

• userservice, orderservice, et les trois services sont tous construits gatewayà l'aide de dans leurs répertoires de microservices respectifs . DockerfileCela signifie que le processus de construction de ces trois services doit afficher séparément les fichiers dans leurs répertoires respectifs Dockerfile.

• Pour gatewayles services, mappez également le port 10010 du conteneur au port 10010 de l’hôte.

Le but de ce fichier est de décrire la configuration et les dépendances de chaque service dans l'ensemble de l'architecture du microservice. En exécutant la docker-compose up -dcommande, Docker Compose créera et démarrera l'ensemble du cluster de microservices en fonction de ces informations de configuration.

3. Modifiez cloud-demola configuration dans le projet : nommez la base de données MySQL, nacosl'adresse et l'adresse IP du microservice comme docker-composenom de service dans

Par exemple:

4. Utilisez mavendes outils de packaging pour empaqueter chaque microservice du projet commeapp.jar

Autrement dit, modifiez le dans tous les microservices sous buildla forme suivante :

<build>
    <finalName>app</finalName>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

5. Copiez chaque package de microservices app.jardans son répertoire correspondant et créez un fichier Dockerfile dans son propre répertoire :

Contenu du fichier Dockerfile :

FROM java:8-alpine
COPY ./app.jar /tmp/app.jar
ENTRYPOINT java -jar /tmp/app.jar

Structure du répertoire cloud-demo :

Parmi eux, mysqlles fichiers de configuration de base de données et les fichiers de table de base de données sont stockés dans le répertoire.

6. Déployer cloud-demoun cluster de microservices

Commande de déploiement :

docker-compose up -d

Après avoir exécuté cette commande, puisqu'il n'y a actuellement aucune image Nacos et MySQL dans Docker, ces deux images seront extraites en premier. Ensuite, les images du microservice seront créées et enfin toutes les images seront exécutées.

7. Afficher les conteneurs en cours d'exécution
   

Notez que d'autres services peuvent ne pas démarrer car Nacos n'est pas démarré en premier. Dans ce cas, vous pouvez redémarrer d'autres microservices pour résoudre le problème :

docker-compose restart gateway userservice orderservice

8. gatewayAccéder au cluster de microservices via une passerelle

Utilisateur visiteur :

Pour accéder aux commandes :

À ce stade, notre cluster de microservices a été construit avec succès via Docker Compose.