Cómo implementar el servidor MariaDB en un contenedor Docker

Hoy en día, términos como Docker, Imágenes o Contenedores son bastante comunes en todos los entornos de bases de datos, por lo que es normal ver un servidor MariaDB ejecutándose en Docker tanto en configuraciones de producción como de no producción. Sin embargo, es posible que, aunque haya escuchado los términos, ahora conozca las diferencias entre ellos. En este blog, brindamos una descripción general de estos términos y cómo podemos aplicarlos en la práctica para implementar un servidor MariaDB.

¿Qué es Docker?

Docker es la herramienta más común para crear, implementar y ejecutar aplicaciones mediante el uso de contenedores. Le permite empaquetar una aplicación con todas las partes que necesita (como bibliotecas y otras dependencias) y enviarlo todo como un solo paquete, lo que permite el intercambio portátil de contenedores entre diferentes máquinas.

Contenedor frente a máquina virtual

¿Qué es una Imagen?

Recursos relacionados ClusterControl y Docker MySQL on Docker Blog Series MySQL on Docker:cómo contener su base de datos

Una imagen es como una plantilla de máquina virtual. Tiene toda la información necesaria para ejecutar el contenedor. Esto incluye el sistema operativo, los paquetes de software, los controladores, los archivos de configuración y las secuencias de comandos auxiliares... todo en un solo paquete.

Cualquiera que tenga la capacidad de escribir un script puede crear una imagen de Docker. Es por eso que la comunidad está creando muchas imágenes similares, cada una con pequeñas diferencias... pero con un propósito común.

¿Qué es un contenedor Docker?

Un contenedor Docker es una instancia de una imagen Docker. Se ejecuta completamente aislado del entorno del host de forma predeterminada y solo accede a los archivos y puertos del host si está configurado para hacerlo.

Un contenedor podría considerarse como una máquina virtual, pero en lugar de crear un sistema operativo virtual completo, permite que las aplicaciones usen el mismo kernel de Linux que el sistema en el que se ejecutan. Solo requiere que las aplicaciones se envíen con partes que aún no se ejecutan en la computadora host. Esto le brinda un aumento significativo del rendimiento y reduce el tamaño de la aplicación.

Tenga en cuenta que cualquier cambio realizado en el contenedor se registra en una capa separada, no en la misma imagen de Docker. Esto significa que si elimina el contenedor o si crea uno nuevo basado en la misma imagen de Docker, los cambios no estarán allí. Para conservar los cambios, debe confirmarlos en una nueva imagen de Docker o crear un archivo de Docker.

¿Qué es un DockerFile?

Un DockerFile es un script que se utiliza para generar una imagen de Docker donde tiene los pasos para generarla en función de las modificaciones que desee aplicar.

Componentes de Docker

Veamos un ejemplo de archivo Docker.

$ vi Dockerfile
# MariaDB 10.3 with SSH
# Pull the mariadb latest image
FROM mariadb:latest
# List all the packages that we want to install
ENV PACKAGES openssh-server openssh-client
# Install Packages
RUN apt-get update && apt-get install -y $PACKAGES
# Allow SSH Root Login
RUN sed -i 's|^#PermitRootLogin.*|PermitRootLogin yes|g' /etc/ssh/sshd_config
# Configure root password
RUN echo "root:root123" | chpasswd

Ahora, podemos crear una nueva imagen de Docker a partir de este archivo de Docker:

$ docker build --rm=true -t severalnines/mariadb-ssh .

Compruebe la nueva imagen creada:

$ docker images
REPOSITORY                                 TAG                 IMAGE ID            CREATED             SIZE
severalnines/mariadb-ssh                   latest              a8022951f195        17 seconds ago      485MB

Y ahora, podemos usar la nueva imagen como una imagen de Docker común, como veremos en la siguiente sección.

Guía de DevOps para la gestión de bases de datos de VariousninesConozca lo que necesita saber para automatizar y gestionar sus bases de datos de código abiertoDescargar gratis

Cómo implementar MariaDB en Docker sin Dockerfile

Ahora que sabemos más sobre el mundo Docker, veamos cómo usarlo para crear un servidor MariaDB. Para esto, asumiremos que ya tiene Docker instalado.

Podemos usar la imagen creada con Dockerfile, pero extraeremos la imagen Docker oficial de MariaDB.

$ docker search mariadb
NAME                                   DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
mariadb                                MariaDB is a community-developed fork of MyS…   2804                [OK]

Sin especificar una ETIQUETA, de manera predeterminada, extraerá la última versión de la imagen, en este caso, MariaDB Server 10.3 en Ubuntu 18.04.

$ docker pull mariadb

Podemos comprobar la imagen descargada.

$ docker images
REPOSITORY                                 TAG                 IMAGE ID            CREATED             SIZE
mariadb                                    latest              e07bb20373d8        2 weeks ago         349MB

Luego, crearemos dos directorios en nuestro directorio MariaDB Docker, uno para datadir y otro para los archivos de configuración de MariaDB. Agregaremos ambos en nuestro MariaDB Docker Container.

$ cd ~/Docker
$ mkdir datadir
$ mkdir config

La configuración de inicio se especifica en el archivo /etc/mysql/my.cnf e incluye todos los archivos que se encuentran en el directorio /etc/mysql/conf.d que terminan en .cnf.

$ tail -1 /etc/mysql/my.cnf
!includedir /etc/mysql/conf.d/

El contenido de estos archivos anulará cualquier parámetro repetido configurado en /etc/mysql/my.cnf, por lo que puede crear una configuración alternativa aquí.

Ejecutemos nuestro primer contenedor MariaDB Docker:

$ docker run -d --name mariadb1 \
-p 33061:3306 \
-v ~/Docker/mariadb1/config:/etc/mysql/conf.d \
-v ~/Docker/mariadb1/datadir:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=root123 \
-e MYSQL_DATABASE=dbtest \
mariadb

Después de esto, podemos verificar nuestros contenedores ejecutando:

$ docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED              STATUS              PORTS                     NAMES
12805cc2d7b5        mariadb             "docker-entrypoint.s…"   About a minute ago   Up About a minute   0.0.0.0:33061->3306/tcp   mariadb1

El registro del contenedor:

$ docker logs mariadb1
MySQL init process done. Ready for start up.
2019-06-03 23:18:01 0 [Note] mysqld (mysqld 10.3.15-MariaDB-1:10.3.15+maria~bionic) starting as process 1 ...
2019-06-03 23:18:01 0 [Note] InnoDB: Using Linux native AIO
2019-06-03 23:18:01 0 [Note] InnoDB: Mutexes and rw_locks use GCC atomic builtins
2019-06-03 23:18:01 0 [Note] InnoDB: Uses event mutexes
2019-06-03 23:18:01 0 [Note] InnoDB: Compressed tables use zlib 1.2.11
2019-06-03 23:18:01 0 [Note] InnoDB: Number of pools: 1
2019-06-03 23:18:01 0 [Note] InnoDB: Using SSE2 crc32 instructions
2019-06-03 23:18:01 0 [Note] InnoDB: Initializing buffer pool, total size = 256M, instances = 1, chunk size = 128M
2019-06-03 23:18:01 0 [Note] InnoDB: Completed initialization of buffer pool
2019-06-03 23:18:01 0 [Note] InnoDB: If the mysqld execution user is authorized, page cleaner thread priority can be changed. See the man page of setpriority().
2019-06-03 23:18:01 0 [Note] InnoDB: 128 out of 128 rollback segments are active.
2019-06-03 23:18:01 0 [Note] InnoDB: Creating shared tablespace for temporary tables
2019-06-03 23:18:01 0 [Note] InnoDB: Setting file './ibtmp1' size to 12 MB. Physically writing the file full; Please wait ...
2019-06-03 23:18:02 0 [Note] InnoDB: File './ibtmp1' size is now 12 MB.
2019-06-03 23:18:02 0 [Note] InnoDB: Waiting for purge to start
2019-06-03 23:18:02 0 [Note] InnoDB: 10.3.15 started; log sequence number 1630824; transaction id 21
2019-06-03 23:18:02 0 [Note] Plugin 'FEEDBACK' is disabled.
2019-06-03 23:18:02 0 [Note] InnoDB: Loading buffer pool(s) from /var/lib/mysql/ib_buffer_pool
2019-06-03 23:18:02 0 [Note] Server socket created on IP: '::'.
2019-06-03 23:18:02 0 [Note] InnoDB: Buffer pool(s) load completed at 190603 23:18:02
2019-06-03 23:18:02 0 [Note] Reading of all Master_info entries succeded
2019-06-03 23:18:02 0 [Note] Added new Master_info '' to hash table
2019-06-03 23:18:02 0 [Note] mysqld: ready for connections.
Version: '10.3.15-MariaDB-1:10.3.15+maria~bionic'  socket: '/var/run/mysqld/mysqld.sock'  port: 3306  mariadb.org binary distribution

Y el contenido de nuestra ruta datadir de Docker (host):

$ ls -l ~/Docker/mariadb1/datadir/
total 249664
-rw-rw----   1 sinsausti  staff     16384 Jun  3 20:18 aria_log.00000001
-rw-rw----   1 sinsausti  staff        52 Jun  3 20:18 aria_log_control
drwx------   3 sinsausti  staff        96 Jun  3 20:18 dbtest
-rw-rw----   1 sinsausti  staff       976 Jun  3 20:18 ib_buffer_pool
-rw-rw----   1 sinsausti  staff  50331648 Jun  3 20:18 ib_logfile0
-rw-rw----   1 sinsausti  staff  50331648 Jun  3 20:17 ib_logfile1
-rw-rw----   1 sinsausti  staff  12582912 Jun  3 20:18 ibdata1
-rw-rw----   1 sinsausti  staff  12582912 Jun  3 20:18 ibtmp1
-rw-rw----   1 sinsausti  staff         0 Jun  3 20:17 multi-master.info
drwx------  92 sinsausti  staff      2944 Jun  3 20:18 mysql
drwx------   3 sinsausti  staff        96 Jun  3 20:17 performance_schema
-rw-rw----   1 sinsausti  staff     24576 Jun  3 20:18 tc.log

Podemos acceder al contenedor de MariaDB ejecutando el siguiente comando y usando la contraseña especificada en la variable MYSQL_ROOT_PASSWORD:

$ docker exec -it mariadb1 bash
[email protected]:/# mysql -p -e "SHOW DATABASES;"
Enter password:
+--------------------+
| Database           |
+--------------------+
| dbtest             |
| information_schema |
| mysql              |
| performance_schema |
+--------------------+

Aquí podemos ver nuestro dbtest creado.

Comandos de Docker

Finalmente, veamos algunos comandos útiles para administrar Docker.

Búsqueda de imágenes
```
$ docker search Image_Name
```
Descarga de imagen
```
$ docker pull Image_Name
```
Lista de las imágenes instaladas
```
$ docker images
```
Contenedores de lista (agregando la bandera -a podemos ver también los contenedores detenidos)
```
$ docker ps -a
```
Eliminar una imagen de Docker
```
$ docker rmi Image_Name
```
Eliminar un contenedor Docker (el contenedor debe estar detenido)
```
$ docker rm Container_Name
```
Ejecute un contenedor desde una imagen de Docker (agregando el indicador -p podemos asignar un puerto de contenedor a localhost)
```
$ docker run -d --name Container_Name -p Host_Port:Guest_Port Image_Name
```
Detener contenedor
```
$ docker stop Container_Name
```
Iniciar contenedor
```
$ docker start Container_Name
```
Comprobar los registros del contenedor
```
$ docker logs Container_Name
```
Verifique la información del contenedor
```
$ docker inspect Container_Name
```

Cree un contenedor vinculado

$ docker run -d --name Container_Name --link Container_Name:Image_Name Image_Name

Conéctese a un contenedor desde localhost
```
$ docker exec -it Container_Name bash
```

Cree un contenedor con volumen agregado

$ docker run -d --name Container_Name --volume=/home/docker/Container_Name/conf.d:/etc/mysql/conf.d Image_Name

Confirmar cambios en una nueva imagen

$ docker commit Container_ID Image_Name:TAG

Conclusión

Docker es una herramienta realmente útil para compartir un entorno de desarrollo fácilmente usando un Dockerfile o publicando una imagen de Docker. Al usarlo, puede asegurarse de que todos estén usando el mismo entorno. Al mismo tiempo, también es útil para recrear o clonar un entorno existente. Docker puede compartir volúmenes, usar redes privadas, asignar puertos y mucho más.

En este blog, vimos cómo implementar MariaDB Server en Docker como un servidor independiente. Si desea utilizar un entorno más complejo como Replicación o Galera Cluster, puede utilizar bitnami/mariadb para lograr esta configuración.