Come distribuire il server MariaDB in un contenitore Docker

Al giorno d'oggi, termini come Docker, Immagini o Contenitori sono piuttosto comuni in tutti gli ambienti di database, quindi è normale vedere un server MariaDB in esecuzione su Docker sia in configurazioni di produzione che non di produzione. È possibile, tuttavia, che mentre potresti aver sentito i termini, ora potresti conoscere le differenze tra loro. In questo blog, forniamo una panoramica di questi termini e di come possiamo applicarli nella pratica per distribuire un server MariaDB.

Cos'è Docker?

Docker è lo strumento più comune per creare, distribuire ed eseguire applicazioni utilizzando i container. Ti consente di impacchettare un'applicazione con tutte le parti di cui ha bisogno (come librerie e altre dipendenze) e spedire il tutto come un unico pacchetto, consentendo la condivisione portatile di contenitori su macchine diverse.

Contenitore vs macchina virtuale

Cos'è un'immagine?

Risorse correlate ClusterControl e Docker MySQL su Docker Blog Series MySQL su Docker - Come containerizzare il database

Un'immagine è come un modello di macchina virtuale. Ha tutte le informazioni necessarie per eseguire il container. Ciò include il sistema operativo, i pacchetti software, i driver, i file di configurazione e gli script di supporto... il tutto racchiuso in un unico pacchetto.

Un'immagine Docker può essere creata da chiunque abbia la capacità di scrivere uno script. Ecco perché ci sono molte immagini simili costruite dalla community, ognuna con piccole differenze... ma che servono a uno scopo comune.

Cos'è un Docker Container?

Un Docker Container è un'istanza di un'immagine Docker. Viene eseguito completamente isolato dall'ambiente host per impostazione predefinita, accedendo ai file host e alle porte solo se configurato per farlo.

Un container può essere considerato come una macchina virtuale, ma invece di creare un intero sistema operativo virtuale, consente alle applicazioni di utilizzare lo stesso kernel Linux del sistema su cui sono in esecuzione. Richiede solo che le applicazioni vengano spedite con parti non già in esecuzione sul computer host. Questo ti dà un notevole incremento delle prestazioni e riduce le dimensioni dell'applicazione.

Tieni presente che tutte le modifiche apportate al contenitore vengono registrate su un livello separato, non nella stessa immagine Docker. Ciò significa che se elimini il contenitore o se ne crei uno nuovo basato sulla stessa immagine Docker, le modifiche non ci saranno. Per preservare le modifiche, devi salvarle in una nuova immagine Docker o creare un file Docker.

Cos'è un DockerFile?

Un DockerFile è uno script utilizzato per generare un'immagine Docker in cui hai i passaggi per generarla in base alle modifiche che desideri applicare.

Componenti Docker

Vediamo un esempio di file 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

Ora possiamo creare una nuova immagine Docker da questo file Docker:

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

Controlla la nuova immagine creata:

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

E ora possiamo utilizzare la nuova immagine come un'immagine Docker comune, come vedremo nella prossima sezione.

Diversinines DevOps Guide to Database ManagementScopri cosa devi sapere per automatizzare e gestire i tuoi database open sourceScarica gratuitamente

Come distribuire MariaDB su Docker senza Dockerfile

Ora che sappiamo di più sul mondo Docker, vediamo come utilizzarlo per creare un server MariaDB. Per questo, supponiamo che tu abbia già installato Docker.

Possiamo usare l'immagine creata usando il Dockerfile, ma estrarremo l'immagine Docker ufficiale di MariaDB.

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

Senza specificare un TAG, per impostazione predefinita, estrarrà l'ultima versione dell'immagine, in questo caso, MariaDB Server 10.3 su Ubuntu 18.04.

$ docker pull mariadb

Possiamo controllare l'immagine scaricata.

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

Quindi, creeremo due directory nella nostra directory Docker di MariaDB, una per la datadir e un'altra per i file di configurazione di MariaDB. Li aggiungeremo entrambi nel nostro MariaDB Docker Container.

$ cd ~/Docker
$ mkdir datadir
$ mkdir config

La configurazione di avvio è specificata nel file /etc/mysql/my.cnf e include tutti i file trovati nella directory /etc/mysql/conf.d che terminano con .cnf.

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

Il contenuto di questi file sovrascriverà qualsiasi parametro ripetuto configurato in /etc/mysql/my.cnf, quindi puoi creare una configurazione alternativa qui.

Eseguiamo il nostro primo MariaDB Docker Container:

$ 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

Successivamente, possiamo controllare i nostri contenitori in esecuzione:

$ 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

Il registro del contenitore:

$ 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

E il contenuto del nostro percorso datadir 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

Possiamo accedere al contenitore MariaDB eseguendo il seguente comando e utilizzando la password specificata nella variabile MYSQL_ROOT_PASSWORD:

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

Qui possiamo vedere il nostro dbtest creato.

Comandi Docker

Infine, vediamo alcuni comandi utili per la gestione di Docker.

Ricerca immagine
```
$ docker search Image_Name
```
Scarica immagine
```
$ docker pull Image_Name
```
Elenca le immagini installate
```
$ docker images
```
Elenca i contenitori (aggiungendo il flag -a possiamo vedere anche i contenitori fermi)
```
$ docker ps -a
```
Elimina un'immagine Docker
```
$ docker rmi Image_Name
```
Elimina un Docker Container (il container deve essere interrotto)
```
$ docker rm Container_Name
```
Esegui un container da un'immagine Docker (aggiungendo il flag -p possiamo mappare una porta container su localhost)
```
$ docker run -d --name Container_Name -p Host_Port:Guest_Port Image_Name
```
Arresta container
```
$ docker stop Container_Name
```
Avvia contenitore
```
$ docker start Container_Name
```
Controlla i registri del contenitore
```
$ docker logs Container_Name
```
Controlla le informazioni sul contenitore
```
$ docker inspect Container_Name
```

Crea un contenitore collegato

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

Connetti a un container da localhost
```
$ docker exec -it Container_Name bash
```

Crea un contenitore con il volume aggiunto

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

Imposta le modifiche a una nuova immagine

$ docker commit Container_ID Image_Name:TAG

Conclusione

Docker è uno strumento davvero utile per condividere facilmente un ambiente di sviluppo utilizzando un Dockerfile o pubblicando un'immagine Docker. Usandolo puoi assicurarti che tutti utilizzino lo stesso ambiente. Allo stesso tempo è anche utile ricreare o clonare un ambiente esistente. Docker può condividere volumi, utilizzare reti private, mappare le porte e altro ancora.

In questo blog, abbiamo visto come distribuire MariaDB Server su Docker come server autonomo. Se desideri utilizzare un ambiente più complesso come Replication o Galera Cluster, puoi utilizzare bitnami/mariadb per ottenere questa configurazione.