Hur man distribuerar MariaDB Server till en Docker Container

Nuförtiden är termer som Docker, Images eller Containers ganska vanliga i alla databasmiljöer, så det är normalt att se en MariaDB-server som körs på Docker i både produktions- och icke-produktionsinställningar. Det är dock möjligt att även om du kanske har hört termerna, kanske du nu känner till skillnaderna mellan dem. I den här bloggen ger vi en översikt över dessa termer och hur vi kan tillämpa dem i praktiken för att distribuera en MariaDB-server.

Vad är Docker?

Docker är det vanligaste verktyget för att skapa, distribuera och köra applikationer med hjälp av behållare. Det låter dig paketera en applikation med alla delar den behöver (som bibliotek och andra beroenden) och skicka ut allt som ett paket, vilket möjliggör portabel delning av containrar mellan olika maskiner.

Behållare vs virtuell maskin

Vad är en bild?

Relaterade resurser ClusterControl &Docker MySQL on Docker Blog Series MySQL on Docker – How to Containerize Your Database

En bild är som en virtuell maskinmall. Den har all nödvändig information för att köra behållaren. Detta inkluderar operativsystemet, mjukvarupaket, drivrutiner, konfigurationsfiler och hjälpskript... allt packat i ett paket.

En Docker-bild kan byggas av alla som har förmågan att skriva ett skript. Det är därför det finns många liknande bilder som skapas av samhället, var och en med mindre skillnader...men tjänar ett gemensamt syfte.

Vad är en Docker Container?

En Docker Container är en instans av en Docker Image. Den körs helt isolerad från värdmiljön som standard, och kommer bara åt värdfiler och portar om den är konfigurerad för att göra det.

En behållare kan betraktas som en virtuell maskin, men istället för att skapa ett helt virtuellt operativsystem tillåter den applikationer att använda samma Linux-kärna som det system de körs på. Det kräver bara att applikationer levereras med delar som inte redan körs på värddatorn. Detta ger dig en betydande prestandaökning och minskar storleken på applikationen.

Tänk på att alla ändringar som görs i behållaren registreras på ett separat lager, inte i samma Docker-bild. Det betyder att om du tar bort behållaren, eller om du skapar en ny baserat på samma Docker-bild, kommer ändringarna inte att finnas där. För att bevara ändringarna måste du lägga till den i en ny Docker-bild eller skapa en Docker-fil.

Vad är en DockerFile?

En DockerFile är ett skript som används för att generera en Docker-bild där du har stegen för att generera den baserat på eventuella ändringar som du vill tillämpa.

Docker-komponenter

Låt oss se ett Docker File-exempel.

$ 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

Nu kan vi bygga en ny Docker-bild från denna Docker-fil:

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

Kontrollera den nya bilden som skapats:

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

Och nu kan vi använda den nya bilden som en vanlig Docker-bild som vi kommer att se i nästa avsnitt.

Severalnines DevOps Guide to Database ManagementLär dig om vad du behöver veta för att automatisera och hantera dina databaser med öppen källkod Ladda ner gratis

Hur man distribuerar MariaDB på Docker utan Dockerfile

Nu när vi vet mer om Docker-världen, låt oss se hur man använder den för att skapa en MariaDB-server. För detta antar vi att du redan har Docker installerat.

Vi kan använda bilden som skapats genom att använda Dockerfilen, men vi hämtar den officiella MariaDB Docker-bilden.

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

Utan att ange en TAG kommer den som standard att dra den senaste bildversionen, i det här fallet MariaDB Server 10.3 på Ubuntu 18.04.

$ docker pull mariadb

Vi kan kontrollera den nedladdade bilden.

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

Sedan skapar vi två kataloger under vår MariaDB Docker-katalog, en för datadir och en annan för MariaDB-konfigurationsfilerna. Vi lägger till båda på vår MariaDB Docker Container.

$ cd ~/Docker
$ mkdir datadir
$ mkdir config

Startkonfigurationen anges i filen /etc/mysql/my.cnf, och den inkluderar alla filer som finns i katalogen /etc/mysql/conf.d som slutar med .cnf.

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

Innehållet i dessa filer kommer att åsidosätta alla upprepade parametrar som konfigurerats i /etc/mysql/my.cnf, så du kan skapa en alternativ konfiguration här.

Låt oss köra vår första 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

Efter detta kan vi kontrollera att våra behållare körs:

$ 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

Behållarloggen:

$ 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

Och innehållet i vår Docker datadir-sökväg (värd):

$ 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

Vi kan komma åt MariaDB-behållaren som kör följande kommando och använder lösenordet som anges i variabeln MYSQL_ROOT_PASSWORD:

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

Här kan vi se vårt dbtest skapat.

Docker-kommandon

Slutligen, låt oss se några användbara kommandon för att hantera Docker.

Bildsökning
```
$ docker search Image_Name
```
Hämta bild
```
$ docker pull Image_Name
```
Lista de installerade bilderna
```
$ docker images
```
Lista behållare (om vi lägger till flaggan -a kan vi även se de stoppade behållarna)
```
$ docker ps -a
```
Ta bort en Docker-bild
```
$ docker rmi Image_Name
```
Ta bort en Docker Container (behållaren måste stoppas)
```
$ docker rm Container_Name
```
Kör en container från en Docker-bild (med flaggan -p kan vi mappa en containerport till localhost)
```
$ docker run -d --name Container_Name -p Host_Port:Guest_Port Image_Name
```
Stopp container
```
$ docker stop Container_Name
```
Starta container
```
$ docker start Container_Name
```
Kontrollera containerloggarna
```
$ docker logs Container_Name
```
Kontrollera containerinformationen
```
$ docker inspect Container_Name
```

Skapa en container länkad

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

Anslut till en behållare från localhost
```
$ docker exec -it Container_Name bash
```

Skapa en behållare med volym tillagd

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

Bekräfta ändringar i en ny bild

$ docker commit Container_ID Image_Name:TAG

Slutsats

Docker är ett riktigt användbart verktyg för att enkelt dela en utvecklingsmiljö med hjälp av en Dockerfile eller publicera en Docker-bild. Genom att använda den kan du se till att alla använder samma miljö. Samtidigt är det också användbart att återskapa eller klona en befintlig miljö. Docker kan dela volymer, använda privata nätverk, kartportar och till och med mer.

I den här bloggen såg vi hur man distribuerar MariaDB Server på Docker som en fristående server. Om du vill använda en mer komplex miljö som Replication eller Galera Cluster kan du använda bitnami/mariadb för att uppnå denna konfiguration.