Mysql
 sql >> Datenbank >  >> RDS >> Mysql

Zusammenstellen des Stapels – Vereinfachen Sie die Docker-Bereitstellung von MySQL-Containern

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:

  1. Netzwerk erstellen
  2. Volume erstellen
  3. Bilder abrufen
  4. Erstellen Sie mysql-drupal (da der Container „drupal“ davon abhängig ist)
  5. 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 herunter

Zusammenstellen 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

!