Mysql
 sql >> Base de données >  >> RDS >> Mysql

Composer la pile - Simplifier le déploiement Docker des conteneurs MySQL

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 :

  1. Créer un réseau
  2. Créer du volume
  3. Extraire des images
  4. Créer mysql-drupal (puisque le conteneur "drupal" en dépend)
  5. 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 blanc

Composer 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

 !