sql >> Base de Datos >  >> RDS >> Mysql

Composición de la pila:simplificar la implementación de Docker de contenedores MySQL

Docker 1.13 presenta una función largamente esperada llamada compatibilidad con archivos de composición, que nos permite definir nuestros contenedores con un archivo de configuración simple y agradable en lugar de un solo comando largo. Si echa un vistazo a nuestras publicaciones de blog anteriores "MySQL en Docker", usamos varias líneas de comando largas para ejecutar contenedores y servicios. Mediante el uso de archivos de composición, los contenedores se especifican fácilmente para su implementación. Esto reduce el riesgo de error humano ya que no tiene que recordar comandos largos con múltiples parámetros.

En esta publicación de blog, le mostraremos cómo usar el archivo de composición mediante ejemplos simples sobre las implementaciones de MySQL. Suponemos que tiene Docker Engine 1.13 instalado en 3 hosts físicos y el modo Swarm está configurado en todos los hosts.

Introducción a Compose-File

En el archivo Compose, especifica todo en formato YAML en lugar de intentar recordar todos los argumentos que tenemos que pasar a los comandos de Docker. Puede definir servicios, redes y volúmenes aquí. La definición será recogida por Docker y es muy parecido a pasar parámetros de la línea de comandos al comando "docker run|network|volume".

Como introducción, vamos a implementar un contenedor MySQL independiente simple. Antes de comenzar a escribir un archivo Compose, primero debe conocer el comando de ejecución. Tomado de nuestra primera serie de blogs MySQL en Docker, compongamos el siguiente comando "docker run":

$ docker run --detach \
--name=test-mysql \
--publish 6603:3306 \
--env="MYSQL_ROOT_PASSWORD=mypassword" \
-v /storage/docker/mysql-datadir:/var/lib/mysql \
mysql

El comando docker-compose buscará un archivo predeterminado llamado "docker-compose.yml" en el directorio actual. Entonces, primero creemos los directorios requeridos de antemano:

$ mkdir -p ~/compose-files/mysql/single
$ mkdir -p /storage/docker/mysql-datadir
$ cd ~/compose-files/mysql/single

En YAML, esto es lo que debe escribirse:

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

Guarde el contenido anterior en "~/compose-files/mysql/single/docker-compose.yml". Asegúrese de estar en el directorio actual ~/compose-files/mysql/single, luego enciéndalo ejecutando el siguiente comando:

$ 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

Verifique si el contenedor se está ejecutando en modo separado:

[[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

¡Felicidades! Ahora tenemos un contenedor MySQL ejecutándose con un solo comando.

Implementación de una pila

Compose-file simplifica las cosas, nos proporciona una visión más clara de cómo debería ser la infraestructura. Vamos a crear una pila de contenedores que consiste en un sitio web que se ejecuta en Drupal, usando una instancia de MySQL en una red dedicada y vinculándolos.

Similar a lo anterior, echemos un vistazo a la versión de la línea de comandos en el orden correcto para construir esta pila:

$ 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

Para comenzar a componer, primero creemos un directorio para nuestra nueva pila:

$ mkdir -p ~/compose-files/drupal-mysql
$ cd ~/compose-files/drupal-mysql

Luego, cree contenido de escritura de docker-compose.yml como se indica a continuación:

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

Enciéndelos:

$ 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 realizará la implementación de la siguiente manera:

  1. Crear red
  2. Crear volumen
  3. Extraer imágenes
  4. Cree mysql-drupal (ya que el contenedor "drupal" depende de él)
  5. Crear el contenedor Drupal

En este punto, nuestra arquitectura se puede ilustrar de la siguiente manera:

Luego podemos especificar 'mysql' como el host MySQL en la página del asistente de instalación, ya que ambos contenedores están vinculados entre sí. Eso es todo. Para derribarlos, simplemente ejecute el siguiente comando en el mismo directorio:

$ docker-compose down

Los contenedores correspondientes serán rescindidos y retirados en consecuencia. Tenga en cuenta que el comando docker-compose está vinculado al host físico individual que ejecuta Docker. Para ejecutarse en múltiples hosts físicos en Swarm, debe tratarse de manera diferente utilizando el comando "docker stack". Explicaremos esto en la siguiente sección.

Varios nueves MySQL en Docker:cómo contenerizar su base de datosDescubra todo lo que necesita saber al considerar ejecutar un servicio MySQL sobre la virtualización de contenedores de DockerDescargar el White Paper

Componer una pila en un enjambre

En primer lugar, asegúrese de que el motor Docker se esté ejecutando en v1.13 y que el modo Swarm esté habilitado y en estado listo:

$ 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

Para usar la función de pila para el modo Docker Swarm, tenemos que usar el formato de la versión 3 de Docker Compose. Vamos a implementar una configuración similar a la anterior, además de una configuración de Galera de 3 nodos como backend de MySQL. Ya lo explicamos en detalle en esta publicación de blog.

En primer lugar, cree un directorio para nuestra nueva pila:

$ mkdir -p ~/compose-files/drupal-galera
$ cd ~/compose-files/drupal-galera

Luego agregue las siguientes líneas en “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

Tenga en cuenta que la imagen de Galera que usamos (severalnines/pxc56) requiere un clúster etcd en ejecución instalado en cada uno de los hosts físicos de Docker. Consulte esta publicación de blog sobre los pasos de requisitos previos.

Una de las partes importantes de nuestro archivo de redacción es el parámetro max_attempts en la sección restart_policy. Tenemos que especificar un límite estricto en el número de reinicios en caso de falla. Esto hará que el proceso de implementación sea más seguro porque, de forma predeterminada, el programador de Swarm nunca dejará de intentar reiniciar los contenedores. Si esto sucede, el ciclo del proceso llenará el espacio en disco del host físico con contenedores inutilizables cuando el programador no pueda llevar los contenedores al estado deseado. Este es un enfoque común cuando se manejan servicios con estado como MySQL. Es mejor derribarlos por completo en lugar de hacerlos funcionar en un estado inconsistente.

Para iniciarlos todos, simplemente ejecute el siguiente comando en el mismo directorio donde reside docker-compose.yml:

$ docker stack deploy --compose-file=docker-compose.yml my_drupal

Verifique que la pila se cree con 2 servicios (drupal y galera):

$ docker stack ls
NAME       SERVICES
my_drupal  2

También podemos listar las tareas actuales en la pila creada. El resultado es una versión combinada de los comandos “docker service ps my_drupal_galera” y “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

Una vez que obtengamos el ESTADO ACTUAL como EN EJECUCIÓN, podemos iniciar la instalación de Drupal conectándonos a cualquiera de las direcciones IP o nombres de host de Docker en el puerto 8080, como en este caso usamos docker3 (aunque el contenedor de Drupal está implementado en docker1), http ://192.168.55.113:8080/. Continúe con la instalación y especifique 'galera' como servidor MySQL y 'drupal' como el nombre de la base de datos (como se define en el archivo de composición bajo la variable de entorno MYSQL_DATABASE):

Eso es todo. La implementación de la pila se simplificó mediante el uso de Compose-file. En este punto, nuestra arquitectura se parece a esto:

Por último, para eliminar la pila, simplemente ejecute el siguiente comando:

$ docker stack rm my_drupal
Removing service my_drupal_galera
Removing service my_drupal_drupal
Removing network my_drupal_galera_net

El uso de un archivo de composición puede ahorrarle tiempo y reducir el riesgo de errores humanos, en comparación con cuando se trabaja con largas líneas de comando. Esta es una herramienta perfecta para dominar antes de trabajar con aplicaciones Docker de múltiples contenedores, lidiar con múltiples entornos de implementación (por ejemplo, desarrollo, prueba, preparación, preproducción, producción) y manejar servicios mucho más complejos, como MySQL Galera Cluster. ¡Feliz contenedorización

!