Docker 1.13 führt eine lang erwartete Funktion namens Compose-File-Unterstützung ein, die es uns ermöglicht, unsere Container mit einer netten einfachen Konfigurationsdatei anstelle eines einzigen langen Befehls zu definieren. Wenn Sie sich unsere vorherigen Blogbeiträge „MySQL auf Docker“ ansehen, haben wir mehrere lange Befehlszeilen verwendet, um Container und Dienste auszuführen. Durch die Verwendung von compose-file können Container einfach für die Bereitstellung angegeben werden. Dies verringert das Risiko menschlicher Fehler, da Sie sich keine langen Befehle mit mehreren Parametern merken müssen.
In diesem Blogbeitrag zeigen wir Ihnen anhand einfacher Beispiele rund um MySQL-Bereitstellungen, wie Sie „compose-file“ verwenden. Wir gehen davon aus, dass Sie Docker Engine 1.13 auf 3 physischen Hosts installiert haben und der Swarm-Modus auf allen Hosts konfiguriert ist.
Einführung in Compose-File
In der Compose-Datei geben Sie alles im YAML-Format an, anstatt zu versuchen, sich alle Argumente zu merken, die wir an Docker-Befehle übergeben müssen. Hier können Sie Dienste, Netze und Volumes definieren. Die Definition wird von Docker übernommen und ähnelt dem Übergeben von Befehlszeilenparametern an den Befehl „docker run|network|volume“.
Als Einführung werden wir einen einfachen eigenständigen MySQL-Container bereitstellen. Bevor Sie mit dem Schreiben einer Compose-Datei beginnen, müssen Sie zunächst den Ausführungsbefehl kennen. Lassen Sie uns aus unserer ersten MySQL on Docker-Blogserie den folgenden „docker run“-Befehl verfassen:
$ docker run --detach \
--name=test-mysql \
--publish 6603:3306 \
--env="MYSQL_ROOT_PASSWORD=mypassword" \
-v /storage/docker/mysql-datadir:/var/lib/mysql \
mysql
Der Befehl docker-compose sucht im aktuellen Verzeichnis nach einer Standarddatei namens „docker-compose.yml“. Erstellen wir also zunächst die erforderlichen Verzeichnisse:
$ mkdir -p ~/compose-files/mysql/single
$ mkdir -p /storage/docker/mysql-datadir
$ cd ~/compose-files/mysql/single
In YAML sollte Folgendes geschrieben werden:
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
Speichern Sie den obigen Inhalt in „~/compose-files/mysql/single/docker-compose.yml“. Stellen Sie sicher, dass Sie sich im aktuellen Verzeichnis ~/compose-files/mysql/single befinden, und starten Sie es dann, indem Sie den folgenden Befehl ausführen:
$ 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
Überprüfen Sie, ob der Container im getrennten Modus ausgeführt wird:
[[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
Herzliche Glückwünsche! Wir haben jetzt einen MySQL-Container, der mit nur einem einzigen Befehl läuft.
Bereitstellen eines Stacks
Compose-file vereinfacht die Dinge, es gibt uns einen klareren Überblick darüber, wie die Infrastruktur aussehen sollte. Lassen Sie uns einen Container-Stack erstellen, der aus einer Website besteht, die auf Drupal läuft, eine MySQL-Instanz in einem dedizierten Netzwerk verwendet und sie miteinander verbindet.
Schauen wir uns ähnlich wie oben die Befehlszeilenversion in der richtigen Reihenfolge an, um diesen Stack zu erstellen:
$ 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
Um mit dem Komponieren zu beginnen, erstellen wir zunächst ein Verzeichnis für unseren neuen Stack:
$ mkdir -p ~/compose-files/drupal-mysql
$ cd ~/compose-files/drupal-mysql
Erstellen Sie dann den Schreibinhalt von docker-compose.yml wie unten beschrieben:
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
Feuern Sie sie an:
$ 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 führt die Bereitstellung wie folgt durch:
- Netzwerk erstellen
- Volume erstellen
- Bilder abrufen
- Erstellen Sie mysql-drupal (da der Container „drupal“ davon abhängig ist)
- Drupal-Container erstellen
An dieser Stelle kann unsere Architektur wie folgt dargestellt werden:
Wir können dann „mysql“ als MySQL-Host auf der Seite des Installationsassistenten angeben, da beide Container miteinander verknüpft sind. Das ist es. Um sie abzureißen, führen Sie einfach den folgenden Befehl im selben Verzeichnis aus:
$ docker-compose down
Die entsprechenden Container werden entsprechend beendet und entfernt. Beachten Sie, dass der Befehl docker-compose an den einzelnen physischen Host gebunden ist, auf dem Docker ausgeführt wird. Um auf mehreren physischen Hosts in Swarm ausgeführt zu werden, muss es anders behandelt werden, indem der Befehl „docker stack“ verwendet wird. Wir erklären dies im nächsten Abschnitt.
Multiplenines MySQL on Docker:How to Containerize Your DatabaseEntdecken Sie alles, was Sie verstehen müssen, wenn Sie erwägen, einen MySQL-Dienst zusätzlich zur Docker-Containervirtualisierung auszuführen. Laden Sie das White Paper herunterZusammenstellen eines Stapels über den Schwarm
Stellen Sie zunächst sicher, dass die Docker-Engine auf v1.13 läuft und der Swarm-Modus aktiviert und bereit ist:
$ 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
Um die Stack-Funktion für den Docker Swarm-Modus nutzen zu können, müssen wir das Format Docker Compose Version 3 verwenden. Wir werden ein ähnliches Setup wie oben bereitstellen, abgesehen von einem 3-Knoten-Galera-Setup als MySQL-Backend. Wir haben es bereits ausführlich in diesem Blogbeitrag erklärt.
Erstellen Sie zunächst ein Verzeichnis für unseren neuen Stack:
$ mkdir -p ~/compose-files/drupal-galera
$ cd ~/compose-files/drupal-galera
Fügen Sie dann die folgenden Zeilen in „docker-compose.yml“ hinzu:
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
Beachten Sie, dass das von uns verwendete Galera-Image (severalnines/pxc56) einen laufenden etcd-Cluster erfordert, der auf jedem physischen Docker-Host installiert ist. Weitere Informationen zu den erforderlichen Schritten finden Sie in diesem Blogbeitrag.
Einer der wichtigen Teile in unserer Compose-Datei ist der Parameter max_attempts im Abschnitt restart_policy. Wir müssen eine feste Grenze für die Anzahl der Neustarts im Fehlerfall festlegen. Dadurch wird der Bereitstellungsprozess sicherer, da der Swarm-Scheduler standardmäßig niemals den Versuch aufgibt, Container neu zu starten. In diesem Fall füllt die Prozessschleife den Speicherplatz des physischen Hosts mit unbrauchbaren Containern, wenn der Scheduler die Container nicht in den gewünschten Zustand bringen kann. Dies ist ein gängiger Ansatz beim Umgang mit zustandsbehafteten Diensten wie MySQL. Es ist besser, sie ganz herunterzufahren, anstatt sie in einem inkonsistenten Zustand laufen zu lassen.
Um sie alle zu starten, führen Sie einfach den folgenden Befehl in demselben Verzeichnis aus, in dem sich docker-compose.yml befindet:
$ docker stack deploy --compose-file=docker-compose.yml my_drupal
Stellen Sie sicher, dass der Stack mit 2 Diensten (drupal und galera) erstellt wurde:
$ docker stack ls
NAME SERVICES
my_drupal 2
Wir können auch die aktuellen Aufgaben im erstellten Stapel auflisten. Das Ergebnis ist eine kombinierte Version der Befehle „docker service ps my_drupal_galera“ und „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
Sobald wir den CURRENT STATE als RUNNING erhalten, können wir die Drupal-Installation starten, indem wir eine Verbindung zu einer der Docker-Host-IP-Adressen oder Hostnamen auf Port 8080 herstellen, da wir in diesem Fall Docker3 verwendet haben (obwohl der Drupal-Container auf Docker1 bereitgestellt wird), http ://192.168.55.113:8080/. Fahren Sie mit der Installation fort und geben Sie „galera“ als MySQL-Host und „drupal“ als Datenbanknamen an (wie in der Compose-Datei unter der Umgebungsvariable MYSQL_DATABASE definiert):
Das ist es. Die Stack-Bereitstellung wurde durch die Verwendung von Compose-file vereinfacht. An diesem Punkt sieht unsere Architektur in etwa so aus:
Um den Stack schließlich zu entfernen, führen Sie einfach den folgenden Befehl aus:
$ docker stack rm my_drupal
Removing service my_drupal_galera
Removing service my_drupal_drupal
Removing network my_drupal_galera_net
Die Verwendung von compose-file kann Ihnen Zeit sparen und das Risiko menschlicher Fehler verringern, verglichen mit der Arbeit mit langen Befehlszeilen. Dies ist ein perfektes Tool, das Sie beherrschen sollten, bevor Sie mit Docker-Anwendungen mit mehreren Containern arbeiten, sich mit mehreren Bereitstellungsumgebungen (z. B. Entwicklung, Test, Staging, Pre-Prod, Prod) befassen und viel komplexere Dienste handhaben, genau wie MySQL Galera Cluster. Viel Spaß beim Containerisieren
!