Sammansättning av stacken - Förenkla Docker-distributionen av MySQL-behållare

Docker 1.13 introducerar en efterlängtad funktion som kallas compose-file support, som tillåter oss att definiera våra behållare med en trevlig enkel konfigurationsfil istället för ett enda långt kommando. Om du tittar på våra tidigare "MySQL on Docker"-blogginlägg, använde vi flera långa kommandorader för att köra behållare och tjänster. Genom att använda compose-fil kan behållare enkelt specificeras för distribution. Detta minskar risken för mänskliga fel eftersom du inte behöver komma ihåg långa kommandon med flera parametrar.

I det här blogginlägget kommer vi att visa dig hur du använder compose-file genom att använda enkla exempel kring MySQL-distributioner. Vi antar att du har Docker Engine 1.13 installerat på 3 fysiska värdar och Swarm-läget är konfigurerat på alla värdar.

Introduktion till Compose-File

I Compose-filen anger du allt i YAML-format i motsats till att försöka komma ihåg alla argument vi måste skicka till Docker-kommandon. Du kan definiera tjänster, nätverk och volymer här. Definitionen kommer att hämtas av Docker och det är mycket som att skicka kommandoradsparametrar till kommandot "docker run|network|volume".

Som en introduktion kommer vi att distribuera en enkel fristående MySQL-behållare. Innan du börjar skriva en Compose-fil måste du först känna till körkommandot. Taget från vår första MySQL på Docker-bloggserie, låt oss komponera följande "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

Kommandot docker-compose kommer att leta efter en standardfil som heter "docker-compose.yml" i den aktuella katalogen. Så låt oss först skapa de nödvändiga katalogerna i förväg:

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

I YAML, här är vad som ska skrivas:

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

Spara ovanstående innehåll i "~/compose-files/mysql/single/docker-compose.yml". Se till att du befinner dig i den aktuella katalogen ~/compose-files/mysql/single, starta den sedan genom att köra följande 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

Kontrollera om behållaren körs i frånkopplat läge:

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

Grattis! Vi har nu en MySQL-behållare som körs med bara ett enda kommando.

Distribuera en stack

Compose-file förenklar saker, det ger oss en tydligare bild av hur infrastrukturen ska se ut. Låt oss skapa en containerstack som består av en webbplats som körs på Drupal, med hjälp av en MySQL-instans under ett dedikerat nätverk och länka ihop dem.

I likhet med ovan, låt oss ta en titt på kommandoradsversionen i rätt ordning för att bygga denna stack:

$ 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

För att börja komponera, låt oss först skapa en katalog för vår nya stack:

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

Skapa sedan skrivinnehåll för docker-compose.yml enligt nedan:

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

Sätt igång dem:

$ 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 kommer att utföra distributionen enligt följande:

1. Skapa nätverk
2. Skapa volym
3. Ta bilder
4. Skapa mysql-drupal (eftersom behållaren "drupal" är beroende av det)
5. Skapa drupal-behållaren

Vid det här laget kan vår arkitektur illustreras enligt följande:

Vi kan sedan ange 'mysql' som MySQL-värd i installationsguidens sida eftersom båda behållarna är sammanlänkade. Det är allt. För att riva dem, kör helt enkelt följande kommando under samma katalog:

$ docker-compose down

Motsvarande containrar kommer att avslutas och tas bort i enlighet med detta. Observera att kommandot docker-compose är bundet till den individuella fysiska värd som kör Docker. För att kunna köras på flera fysiska värdar över Swarm måste den behandlas annorlunda genom att använda kommandot "docker stack". Vi kommer att förklara detta i nästa avsnitt.

Komponera en stack över svärm

Se först till att Docker-motorn körs på v1.13 och att Swarm-läget är aktiverat och i redo-läge:

$ 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

För att kunna använda stackfunktionen för Docker Swarm-läge måste vi använda Docker Compose version 3-formatet. Vi kommer att distribuera en inställning som liknar ovanstående, förutom en 3-nods Galera-installation som MySQL-backend. Vi har redan förklarat i detalj i det här blogginlägget.

Skapa först en katalog för vår nya stack:

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

Lägg sedan till följande rader 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

Observera att Galera-bilden som vi använde (severalnines/pxc56) kräver ett körande etcd-kluster installerat på var och en av Dockers fysiska värdar. Se detta blogginlägg om de nödvändiga stegen.

En av de viktiga delarna i vår compose-fil är parametern max_attempts under restart_policy-avsnittet. Vi måste ange en hård gräns för antalet omstarter vid fel. Detta kommer att göra distributionsprocessen säkrare eftersom, som standard, kommer Swarm-schemaläggaren aldrig att ge upp i försöken att starta om containrar. Om detta händer kommer processslingan att fylla upp den fysiska värdens diskutrymme med oanvändbara behållare när schemaläggaren inte kan föra upp behållarna till önskat tillstånd. Detta är ett vanligt tillvägagångssätt när man hanterar stateful tjänster som MySQL. Det är bättre att ta bort dem helt och hållet istället för att få dem att köra i ett inkonsekvent tillstånd.

För att starta dem alla, kör bara följande kommando i samma katalog där docker-compose.yml finns:

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

Verifiera att stacken är skapad med 2 tjänster (drupal och galera):

$ docker stack ls
NAME       SERVICES
my_drupal  2

Vi kan också lista de aktuella uppgifterna i den skapade stacken. Resultatet är en kombinerad version av kommandona "docker service ps my_drupal_galera" och "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 AKTUELLT TILLSTÅND som KÖR, kan vi starta Drupal-installationen genom att ansluta till någon av Docker-värdens IP-adresser eller värdnamn på port 8080, som i det här fallet använde vi docker3 (även om drupal-behållaren är utplacerad på docker1), http ://192.168.55.113:8080/. Fortsätt med installationen och ange "galera" som MySQL-värd och "drupal" som databasnamn (enligt definitionen i compose-filen under MYSQL_DATABASE miljövariabel):

Det är allt. Stackdistributionen förenklades genom att använda Compose-fil. Vid det här laget ser vår arkitektur ut ungefär så här:

Slutligen, för att ta bort stacken, kör bara följande kommando:

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

Att använda compose-file kan spara tid och minska risken för mänskliga fel, jämfört med när du arbetar med långa kommandorader. Detta är ett perfekt verktyg för dig att bemästra innan du arbetar med Docker-applikationer med flera behållare, hanterar flera distributionsmiljöer (t.ex. dev, test, staging, pre-prod, prod) och hanterar mycket mer komplexa tjänster, precis som MySQL Galera Cluster. Lycka till med containersändningen

!