De stapel samenstellen - Docker-implementatie van MySQL-containers vereenvoudigen

Docker 1.13 introduceert een langverwachte functie genaamd compose-file support, waarmee we onze containers kunnen definiëren met een mooi eenvoudig configuratiebestand in plaats van een enkele lange opdracht. Als je onze eerdere blogposts "MySQL on Docker" bekijkt, hebben we meerdere lange opdrachtregels gebruikt om containers en services uit te voeren. Door gebruik te maken van compose-file kunnen containers eenvoudig worden gespecificeerd voor implementatie. Dit vermindert het risico op menselijke fouten, omdat u geen lange opdrachten met meerdere parameters hoeft te onthouden.

In deze blogpost laten we u zien hoe u een opstelbestand kunt gebruiken aan de hand van eenvoudige voorbeelden rond MySQL-implementaties. We gaan ervan uit dat Docker Engine 1.13 op 3 fysieke hosts is geïnstalleerd en dat de zwermmodus op alle hosts is geconfigureerd.

Inleiding tot Compose-File

In het Compose-bestand specificeert u alles in YAML-formaat in plaats van te proberen alle argumenten te onthouden die we moeten doorgeven aan Docker-commando's. Hier kunt u diensten, netwerken en volumes definiëren. De definitie wordt opgepikt door Docker en het lijkt veel op het doorgeven van opdrachtregelparameters aan de opdracht "docker run|network|volume".

Als introductie gaan we een eenvoudige stand-alone MySQL-container implementeren. Voordat u begint met het schrijven van een Compose-bestand, moet u eerst de opdracht run kennen. Laten we het volgende "docker run" -commando samenstellen uit onze eerste MySQL op Docker-blogserie:

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

De opdracht docker-compose zoekt naar een standaardbestand met de naam "docker-compose.yml" in de huidige map. Laten we dus eerst de vereiste mappen maken:

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

In YAML moet het volgende worden geschreven:

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

Sla de bovenstaande inhoud op in "~/compose-files/mysql/single/docker-compose.yml". Zorg ervoor dat u zich in de huidige map ~/compose-files/mysql/single bevindt en start deze vervolgens door de volgende opdracht uit te voeren:

$ 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

Controleer of de container in de ontkoppelde modus draait:

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

Gefeliciteerd! We hebben nu een MySQL-container die draait met slechts een enkele opdracht.

Een stapel implementeren

Compose-file vereenvoudigt de zaken, het geeft ons een duidelijker beeld van hoe de infrastructuur eruit zou moeten zien. Laten we een containerstack maken die bestaat uit een website die draait op Drupal, met behulp van een MySQL-instantie onder een speciaal netwerk en deze aan elkaar koppelen.

Laten we, net als hierboven, eens kijken naar de opdrachtregelversie in de juiste volgorde om deze stapel te bouwen:

$ 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

Laten we, om te beginnen met componeren, eerst een map maken voor onze nieuwe stapel:

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

Maak vervolgens schrijfinhoud van docker-compose.yml zoals hieronder:

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

Start ze 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 voert de implementatie als volgt uit:

1. Netwerk maken
2. Volume maken
3. Afbeeldingen ophalen
4. Maak mysql-drupal aan (aangezien container "drupal" hiervan afhankelijk is)
5. Maak de drupal-container

Op dit punt kan onze architectuur als volgt worden geïllustreerd:

We kunnen dan 'mysql' specificeren als de MySQL-host op de installatiewizardpagina, aangezien beide containers aan elkaar zijn gekoppeld. Dat is het. Om ze af te breken, voert u gewoon de volgende opdracht uit in dezelfde map:

$ docker-compose down

De bijbehorende containers worden dienovereenkomstig beëindigd en verwijderd. Houd er rekening mee dat de opdracht docker-compose gebonden is aan de individuele fysieke host waarop Docker wordt uitgevoerd. Om op meerdere fysieke hosts in Swarm te kunnen draaien, moet het anders worden behandeld door de opdracht "docker stack" te gebruiken. We zullen dit in het volgende gedeelte uitleggen.

Een stapel samenstellen over een zwerm

Zorg er eerst voor dat de Docker-engine draait op v1.13 en dat de zwermmodus is ingeschakeld en gereed is:

$ 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

Om de stapelfunctie voor de Docker Swarm-modus te gebruiken, moeten we de Docker Compose versie 3-indeling gebruiken. We gaan een soortgelijke opstelling als hierboven implementeren, afgezien van een 3-node Galera-opstelling als de MySQL-backend. We hebben het al in detail uitgelegd in deze blogpost.

Maak eerst een map voor onze nieuwe stapel:

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

Voeg vervolgens de volgende regels toe aan "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

Merk op dat de Galera-afbeelding die we gebruikten (severalnines/pxc56) een actief etcd-cluster vereist dat op elke fysieke Docker-host is geïnstalleerd. Raadpleeg deze blogpost over de vereiste stappen.

Een van de belangrijke onderdelen in ons samenstellingsbestand is de parameter max_attempts onder het gedeelte restart_policy. We moeten een harde limiet opgeven voor het aantal herstarts in geval van een storing. Dit maakt het implementatieproces veiliger omdat de Swarm-planner standaard nooit zal opgeven om containers opnieuw te starten. Als dit gebeurt, vult de proceslus de schijfruimte van de fysieke host met onbruikbare containers wanneer de planner de containers niet in de gewenste staat kan brengen. Dit is een gebruikelijke benadering bij het omgaan met stateful services zoals MySQL. Het is beter om ze helemaal naar beneden te halen in plaats van ze in een inconsistente staat te laten werken.

Om ze allemaal te starten, voert u gewoon de volgende opdracht uit in dezelfde map waar docker-compose.yml zich bevindt:

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

Controleer of de stapel is gemaakt met 2 services (drupal en galera):

$ docker stack ls
NAME       SERVICES
my_drupal  2

We kunnen ook de huidige taken in de gemaakte stapel weergeven. Het resultaat is een gecombineerde versie van de commando's "docker service ps my_drupal_galera" en "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

Zodra we de HUIDIGE STATUS als RUNNING krijgen, kunnen we de Drupal-installatie starten door verbinding te maken met een van de Docker-host-IP-adressen of hostnamen op poort 8080, omdat we in dit geval docker3 hebben gebruikt (hoewel de drupal-container is geïmplementeerd op docker1), http ://192.168.55.113:8080/. Ga verder met de installatie en specificeer 'galera' als de MySQL-host en 'drupal' als de databasenaam (zoals gedefinieerd in het samenstellingsbestand onder de MYSQL_DATABASE-omgevingsvariabele):

Dat is het. De stack-implementatie is vereenvoudigd door Compose-file te gebruiken. Op dit moment ziet onze architectuur er ongeveer zo uit:

Als laatste, om de stapel te verwijderen, voer je gewoon de volgende opdracht uit:

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

Het gebruik van een opstelbestand kan u tijd besparen en het risico op menselijke fouten verkleinen, in vergelijking met het werken met lange opdrachtregels. Dit is een perfecte tool om onder de knie te krijgen voordat je met Docker-applicaties met meerdere containers gaat werken, met meerdere implementatieomgevingen (bijv. Gelukkig containervervoer

!