Docker 1.13 introduit une fonctionnalité tant attendue appelée support de fichier de composition, qui nous permet de définir nos conteneurs avec un joli fichier de configuration simple au lieu d'une seule longue commande. Si vous jetez un coup d'œil à nos précédents articles de blog "MySQL sur Docker", nous avons utilisé plusieurs longues lignes de commande pour exécuter des conteneurs et des services. En utilisant compose-file, les conteneurs sont facilement spécifiés pour le déploiement. Cela réduit le risque d'erreur humaine car vous n'avez pas à vous souvenir de longues commandes avec plusieurs paramètres.
Dans cet article de blog, nous allons vous montrer comment utiliser compose-file en utilisant des exemples simples autour des déploiements MySQL. Nous supposons que Docker Engine 1.13 est installé sur 3 hôtes physiques et que le mode Swarm est configuré sur tous les hôtes.
Introduction à Compose-File
Dans le fichier Compose, vous spécifiez tout au format YAML au lieu d'essayer de mémoriser tous les arguments que nous devons transmettre aux commandes Docker. Vous pouvez définir ici les services, les réseaux et les volumes. La définition sera récupérée par Docker et cela revient à passer des paramètres de ligne de commande à la commande "docker run|network|volume".
En guise d'introduction, nous allons déployer un simple conteneur MySQL autonome. Avant de commencer à écrire un fichier Compose, vous devez d'abord connaître la commande run. Extrait de notre première série de blogs MySQL sur Docker, composons la commande "docker run" suivante :
$ docker run --detach \
--name=test-mysql \
--publish 6603:3306 \
--env="MYSQL_ROOT_PASSWORD=mypassword" \
-v /storage/docker/mysql-datadir:/var/lib/mysql \
mysql
La commande docker-compose recherchera un fichier par défaut appelé "docker-compose.yml" dans le répertoire actuel. Alors, créons d'abord les répertoires nécessaires :
$ mkdir -p ~/compose-files/mysql/single
$ mkdir -p /storage/docker/mysql-datadir
$ cd ~/compose-files/mysql/single
En YAML, voici ce qu'il faut écrire :
version: '2'
services:
mysql:
image: mysql
container_name: test-mysql
ports:
- 6603:3306
environment:
MYSQL_ROOT_PASSWORD: "mypassword"
volumes:
- /storage/docker/mysql-datadir:/var/lib/mysql
Enregistrez le contenu ci-dessus dans "~/compose-files/mysql/single/docker-compose.yml". Assurez-vous d'être dans le répertoire courant ~/compose-files/mysql/single, puis lancez-le en exécutant la commande suivante :
$ docker-compose up -d
WARNING: The Docker Engine you're using is running in swarm mode.
Compose does not use swarm mode to deploy services to multiple nodes in a swarm. All containers will be scheduled on the current node.
To deploy your application across the swarm, use `docker stack deploy`.
Creating test-mysql
Vérifiez si le conteneur s'exécute en mode détaché :
[[email protected] single]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
379d5c15ef44 mysql "docker-entrypoint..." 8 minutes ago Up 8 minutes 0.0.0.0:6603->3306/tcp test-mysql
Toutes nos félicitations! Nous avons maintenant un conteneur MySQL en cours d'exécution avec une seule commande.
Déployer une pile
Compose-file simplifie les choses, il nous donne une vision plus claire de ce à quoi l'infrastructure devrait ressembler. Créons une pile de conteneurs composée d'un site Web fonctionnant sur Drupal, utilisant une instance MySQL sous un réseau dédié et lions-les ensemble.
Comme ci-dessus, examinons la version de la ligne de commande dans le bon ordre pour créer cette pile :
$ docker volume create mysql_data
$ docker network create drupal_mysql_net --driver=bridge
$ docker run -d --name=mysql-drupal --restart=always -v mysql_data:/var/lib/mysql --net=drupal_mysql_net -e MYSQL_ROOT_PASSWORD="mypassword" -e MYSQL_DATABASE="drupal" mysql
$ docker run -d --name=drupal -p 8080:80 --restart=always -v /var/www/html/modules -v /var/www/html/profiles -v /var/www/html/themes -v /var/www/html/sites --link mysql:mysql --net=drupal_mysql_net drupal
Pour commencer à composer, créons d'abord un répertoire pour notre nouvelle pile :
$ mkdir -p ~/compose-files/drupal-mysql
$ cd ~/compose-files/drupal-mysql
Ensuite, créez le contenu d'écriture de docker-compose.yml comme ci-dessous :
version: '2'
services:
mysql:
image: mysql
container_name: mysql-drupal
environment:
MYSQL_ROOT_PASSWORD: "mypassword"
MYSQL_DATABASE: "drupal"
volumes:
- mysql_data:/var/lib/mysql
restart: always
networks:
- drupal_mysql_net
drupal:
depends_on:
- mysql
image: drupal
container_name: drupal
ports:
- 8080:80
volumes:
- /var/www/html/modules
- /var/www/html/profiles
- /var/www/html/themes
- /var/www/html/sites
links:
- mysql:mysql
restart: always
networks:
- drupal_mysql_net
volumes:
mysql_data:
networks:
drupal_mysql_net:
driver: bridge
Allumez-les :
$ docker-compose up -d
..
Creating network "drupalmysql_drupal_mysql_net" with driver "bridge"
Creating volume "drupalmysql_mysql_data" with default driver
Pulling drupal (drupal:latest)...
..
Creating mysql-drupal
Creating drupal
Docker effectuera le déploiement comme suit :
- Créer un réseau
- Créer du volume
- Extraire des images
- Créer mysql-drupal (puisque le conteneur "drupal" en dépend)
- Créer le conteneur Drupal
À ce stade, notre architecture peut être illustrée comme suit :
Nous pouvons ensuite spécifier "mysql" comme hôte MySQL dans la page de l'assistant d'installation puisque les deux conteneurs sont liés. C'est ça. Pour les démonter, exécutez simplement la commande suivante sous le même répertoire :
$ docker-compose down
Les conteneurs correspondants seront résiliés et supprimés en conséquence. Notez que la commande docker-compose est liée à l'hôte physique individuel exécutant Docker. Afin de fonctionner sur plusieurs hôtes physiques dans Swarm, il doit être traité différemment en utilisant la commande « docker stack ». Nous expliquerons cela dans la section suivante.
Manynines MySQL sur Docker :comment conteneuriser votre base de donnéesDécouvrez tout ce que vous devez comprendre lorsque vous envisagez d'exécuter un service MySQL au-dessus de la virtualisation des conteneurs DockerTélécharger le livre blancComposer une pile sur Swarm
Tout d'abord, assurez-vous que le moteur Docker fonctionne sur la v1.13 et que le mode Swarm est activé et prêt :
$ docker node ls
ID HOSTNAME STATUS AVAILABILITY MANAGER STATUS
8n8t3r4fvm8u01yhli9522xi9 * docker1.local Ready Active Reachable
o1dfbbnmhn1qayjry32bpl2by docker2.local Ready Active Reachable
tng5r9ax0ve855pih1110amv8 docker3.local Ready Active Leader
Afin d'utiliser la fonctionnalité de pile pour le mode Docker Swarm, nous devons utiliser le format Docker Compose version 3. Nous allons déployer une configuration similaire à celle ci-dessus, à l'exception d'une configuration Galera à 3 nœuds en tant que backend MySQL. Nous avons déjà expliqué en détail dans cet article de blog.
Tout d'abord, créez un répertoire pour notre nouvelle pile :
$ mkdir -p ~/compose-files/drupal-galera
$ cd ~/compose-files/drupal-galera
Ajoutez ensuite les lignes suivantes dans "docker-compose.yml":
version: '3'
services:
galera:
deploy:
replicas: 3
restart_policy:
condition: on-failure
delay: 30s
max_attempts: 3
window: 60s
update_config:
parallelism: 1
delay: 10s
max_failure_ratio: 0.3
image: severalnines/pxc56
environment:
MYSQL_ROOT_PASSWORD: "mypassword"
CLUSTER_NAME: "my_galera"
XTRABACKUP_PASSWORD: "mypassword"
DISCOVERY_SERVICE: '192.168.55.111:2379,192.168.55.112:2379,192.168.55.207:2379'
MYSQL_DATABASE: 'drupal'
networks:
- galera_net
drupal:
depends_on:
- galera
deploy:
replicas: 1
image: drupal
ports:
- 8080:80
volumes:
- drupal_modules:/var/www/html/modules
- drupal_profile:/var/www/html/profiles
- drupal_theme:/var/www/html/themes
- drupal_sites:/var/www/html/sites
networks:
- galera_net
volumes:
drupal_modules:
drupal_profile:
drupal_theme:
drupal_sites:
networks:
galera_net:
driver: overlay
Notez que l'image Galera que nous avons utilisée (plusieurs neufs/pxc56) nécessite un cluster etcd en cours d'exécution installé sur chacun des hôtes physiques Docker. Veuillez vous référer à cet article de blog sur les étapes préalables.
L'une des parties importantes de notre fichier de composition est le paramètre max_attempts sous la section restart_policy. Nous devons spécifier une limite stricte sur le nombre de redémarrages en cas d'échec. Cela rendra le processus de déploiement plus sûr car, par défaut, le planificateur Swarm n'abandonnera jamais la tentative de redémarrage des conteneurs. Si cela se produit, la boucle de processus remplira l'espace disque de l'hôte physique avec des conteneurs inutilisables lorsque le planificateur ne pourra pas amener les conteneurs à l'état souhaité. Il s'agit d'une approche courante lors de la gestion de services avec état tels que MySQL. Il est préférable de les supprimer complètement plutôt que de les faire fonctionner dans un état incohérent.
Pour les démarrer tous, exécutez simplement la commande suivante dans le même répertoire où docker-compose.yml réside :
$ docker stack deploy --compose-file=docker-compose.yml my_drupal
Vérifiez que la pile est créée avec 2 services (drupal et galera) :
$ docker stack ls
NAME SERVICES
my_drupal 2
Nous pouvons également lister les tâches en cours dans la pile créée. Le résultat est une version combinée des commandes "docker service ps my_drupal_galera" et "docker service ps my_drupal_drupal" :
$ docker stack ps my_drupal
ID NAME IMAGE NODE DESIRED STATE CURRENT STATE ERROR PORTS
609jj9ji6rxt my_drupal_galera.1 severalnines/pxc56:latest docker3.local Running Running 7 minutes ago
z8mcqzf29lbq my_drupal_drupal.1 drupal:latest docker1.local Running Running 24 minutes ago
skblp9mfbbzi my_drupal_galera.2 severalnines/pxc56:latest docker1.local Running Running 10 minutes ago
cidn9kb0d62u my_drupal_galera.3 severalnines/pxc56:latest docker2.local Running Running 7 minutes ago
Une fois que nous obtenons le CURRENT STATE comme RUNNING, nous pouvons démarrer l'installation de Drupal en nous connectant à n'importe quelle adresse IP ou nom d'hôte de l'hôte Docker sur le port 8080, comme dans ce cas nous avons utilisé docker3 (bien que le conteneur drupal soit déployé sur docker1), http ://192.168.55.113:8080/. Procédez à l'installation et spécifiez "galera" comme hôte MySQL et "drupal" comme nom de base de données (comme défini dans le fichier de composition sous la variable d'environnement MYSQL_DATABASE) :
C'est ça. Le déploiement de la pile a été simplifié en utilisant Compose-file. À ce stade, notre architecture ressemble à ceci :
Enfin, pour supprimer la pile, exécutez simplement la commande suivante :
$ docker stack rm my_drupal
Removing service my_drupal_galera
Removing service my_drupal_drupal
Removing network my_drupal_galera_net
L'utilisation de compose-file peut vous faire gagner du temps et réduire le risque d'erreur humaine, par rapport à l'utilisation de longues lignes de commande. Il s'agit d'un outil parfait à maîtriser avant de travailler avec des applications Docker multi-conteneurs, traitant de plusieurs environnements de déploiement (par exemple, développement, test, staging, pré-prod, prod) et gérant des services beaucoup plus complexes, tout comme MySQL Galera Cluster. Bonne conteneurisation
!