Sammensætning af stakken - Forenkling af Docker-implementering af MySQL-containere

Docker 1.13 introducerer en længe ventet funktion kaldet compose-file support, som giver os mulighed for at definere vores containere med en fin simpel konfigurationsfil i stedet for en enkelt lang kommando. Hvis du har et kig på vores tidligere "MySQL på Docker" blogindlæg, brugte vi flere lange kommandolinjer til at køre containere og tjenester. Ved at bruge compose-file kan containere nemt specificeres til implementering. Dette reducerer risikoen for menneskelige fejl, da du ikke skal huske lange kommandoer med flere parametre.

I dette blogindlæg viser vi dig, hvordan du bruger compose-fil ved at bruge simple eksempler omkring MySQL-implementeringer. Vi antager, at du har Docker Engine 1.13 installeret på 3 fysiske værter, og Swarm-tilstand er konfigureret på alle værter.

Introduktion til Compose-File

I Compose-filen angiver du alt i YAML-format i modsætning til at prøve at huske alle de argumenter, vi skal videregive til Docker-kommandoer. Du kan definere tjenester, netværk og mængder her. Definitionen vil blive opfanget af Docker, og det er meget som at overføre kommandolinjeparametre til kommandoen "docker run|network|volume".

Som en introduktion vil vi implementere en simpel selvstændig MySQL-container. Før du begynder at skrive en Compose-fil, skal du først kende kommandoen run. Taget fra vores første MySQL på Docker-blogserie, lad os komponere følgende "docker run"-kommando:

$ docker run --detach \
--name=test-mysql \
--publish 6603:3306 \
--env="MYSQL_ROOT_PASSWORD=mypassword" \
-v /storage/docker/mysql-datadir:/var/lib/mysql \
mysql

Docker-compose kommandoen vil lede efter en standardfil kaldet "docker-compose.yml" i den aktuelle mappe. Så lad os først oprette de nødvendige mapper på forhånd:

$ mkdir -p ~/compose-files/mysql/single
$ mkdir -p /storage/docker/mysql-datadir
$ cd ~/compose-files/mysql/single

I YAML, her er hvad der skal skrives:

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

Gem ovenstående indhold i "~/compose-files/mysql/single/docker-compose.yml". Sørg for, at du er i den aktuelle mappe ~/compose-files/mysql/single, og tænd den derefter ved at køre følgende kommando:

$ 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

Bekræft, om containeren kører i frakoblet tilstand:

[[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

Tillykke! Vi har nu fået en MySQL-beholder kørende med kun en enkelt kommando.

Implementering af en stak

Compose-file forenkler tingene, det giver os et klarere overblik over, hvordan infrastrukturen skal se ud. Lad os oprette en containerstak, der består af et websted, der kører på Drupal, ved at bruge en MySQL-instans under et dedikeret netværk og linke dem sammen.

I lighed med ovenfor, lad os tage et kig på kommandolinjeversionen i den rigtige rækkefølge for at bygge denne stak:

$ 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

For at begynde at komponere, lad os først oprette en mappe til vores nye stak:

$ mkdir -p ~/compose-files/drupal-mysql
$ cd ~/compose-files/drupal-mysql

Opret derefter skriveindhold af docker-compose.yml som beskrevet nedenfor:

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

Fyr dem op:

$ 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 vil udføre implementeringen som følger:

1. Opret netværk
2. Opret volumen
3. Træk billeder
4. Opret mysql-drupal (da container "drupal" er afhængig af det)
5. Opret drupal-beholderen

På dette tidspunkt kan vores arkitektur illustreres som følger:

Vi kan derefter angive 'mysql' som MySQL-værten på siden med installationsguiden, da begge containere er linket sammen. Det er det. For at rive dem ned skal du blot køre følgende kommando under samme mappe:

$ docker-compose down

De tilsvarende beholdere vil blive afsluttet og fjernet i overensstemmelse hermed. Bemærk, at kommandoen docker-compose er bundet til den individuelle fysiske vært, der kører Docker. For at kunne køre på flere fysiske værter på tværs af Swarm, skal det behandles anderledes ved at bruge kommandoen "docker stack". Vi forklarer dette i næste afsnit.

Sådan komponerer du en stak på tværs af sværm

For det første skal du sørge for, at Docker-motoren kører på v1.13, og at Swarm-tilstand er aktiveret og er klar:

$ 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

For at bruge stak-funktionen til Docker Swarm-tilstand, skal vi bruge Docker Compose version 3-formatet. Vi vil implementere en opsætning, der ligner ovenstående, bortset fra en 3-node Galera-opsætning som MySQL-backend. Vi har allerede forklaret i detaljer i dette blogindlæg.

Først skal du oprette en mappe til vores nye stak:

$ mkdir -p ~/compose-files/drupal-galera
$ cd ~/compose-files/drupal-galera

Tilføj derefter følgende linjer i "docker-compose.yml":

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

Bemærk, at Galera-billedet, som vi brugte (severalnines/pxc56) kræver en kørende etcd-klynge installeret på hver af de fysiske Docker-værter. Se venligst dette blogindlæg om de nødvendige trin.

En af de vigtige dele i vores compose-fil er parameteren max_attempts under restart_policy sektionen. Vi er nødt til at angive en hård grænse for antallet af genstarter i tilfælde af fejl. Dette vil gøre implementeringsprocessen mere sikker, fordi Swarm-planlæggeren som standard aldrig vil give op i forsøget på at genstarte containere. Hvis dette sker, vil procesløkken fylde den fysiske værts diskplads op med ubrugelige containere, når planlæggeren ikke kan bringe containerne op til den ønskede tilstand. Dette er en almindelig tilgang, når du håndterer stateful tjenester som MySQL. Det er bedre at bringe dem helt ned i stedet for at få dem til at køre i en inkonsekvent tilstand.

For at starte dem alle skal du bare udføre følgende kommando i den samme mappe, hvor docker-compose.yml findes:

$ docker stack deploy --compose-file=docker-compose.yml my_drupal

Bekræft, at stakken er oprettet med 2 tjenester (drupal og galera):

$ docker stack ls
NAME       SERVICES
my_drupal  2

Vi kan også liste de aktuelle opgaver i den oprettede stak. Resultatet er en kombineret version af kommandoerne "docker service ps my_drupal_galera" og "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

Når vi får den AKTUELLE TILSTAND som KØRER, kan vi starte Drupal-installationen ved at oprette forbindelse til en hvilken som helst Docker-værts IP-adresse eller værtsnavn på port 8080, da vi i dette tilfælde brugte docker3 (omend drupal-beholderen er installeret på docker1), http ://192.168.55.113:8080/. Fortsæt med installationen og angiv 'galera' som MySQL-værten og 'drupal' som databasenavnet (som defineret i compose-filen under MYSQL_DATABASE miljøvariabel):

Det er det. Stakimplementeringen blev forenklet ved at bruge Compose-fil. På dette tidspunkt ser vores arkitektur nogenlunde sådan her ud:

Til sidst, for at fjerne stakken, skal du bare køre følgende kommando:

$ docker stack rm my_drupal
Removing service my_drupal_galera
Removing service my_drupal_drupal
Removing network my_drupal_galera_net

Brug af compose-file kan spare dig tid og reducere risikoen for menneskelige fejl, sammenlignet med når du arbejder med lange kommandolinjer. Dette er et perfekt værktøj for dig at mestre, før du arbejder med multi-container Docker-applikationer, håndterer flere implementeringsmiljøer (f.eks. dev, test, staging, pre-prod, prod) og håndterer meget mere komplekse tjenester, ligesom MySQL Galera Cluster. God fornøjelse med containerisering

!