Komponowanie stosu — uproszczenie wdrażania kontenerów MySQL przez Docker

Docker 1.13 wprowadza długo oczekiwaną funkcję zwaną obsługą tworzenia plików, która pozwala nam definiować nasze kontenery za pomocą ładnego prostego pliku konfiguracyjnego zamiast pojedynczego długiego polecenia. Jeśli spojrzysz na nasze poprzednie wpisy na blogu „MySQL on Docker”, używaliśmy wielu długich wierszy poleceń do uruchamiania kontenerów i usług. Korzystając z tworzenia pliku, kontenery można łatwo określić do wdrożenia. Zmniejsza to ryzyko błędu ludzkiego, ponieważ nie musisz pamiętać długich poleceń z wieloma parametrami.

W tym poście na blogu pokażemy, jak korzystać z funkcji tworzenia pliku, korzystając z prostych przykładów dotyczących wdrożeń MySQL. Zakładamy, że masz zainstalowany Docker Engine 1.13 na 3 fizycznych hostach, a tryb Swarm jest skonfigurowany na wszystkich hostach.

Wprowadzenie do tworzenia plików

W pliku Compose określasz wszystko w formacie YAML, w przeciwieństwie do próby zapamiętania wszystkich argumentów, które musimy przekazać do poleceń Dockera. Tutaj możesz zdefiniować usługi, sieci i wolumeny. Definicja zostanie pobrana przez Docker i jest to bardzo podobne do przekazywania parametrów wiersza poleceń do polecenia „docker run|network|volume”.

Jako wprowadzenie zamierzamy wdrożyć prosty samodzielny kontener MySQL. Zanim zaczniesz pisać plik Compose, najpierw musisz znać polecenie run. Zaczerpnięte z naszej pierwszej serii blogów MySQL on Docker, skomponujmy następujące polecenie „uruchom docker”:

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

Polecenie docker-compose wyszuka domyślny plik o nazwie „docker-compose.yml” w bieżącym katalogu. Dlatego najpierw utwórzmy wymagane katalogi:

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

W YAML, oto, co powinno być napisane:

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

Zapisz powyższą treść w „~/compose-files/mysql/single/docker-compose.yml”. Upewnij się, że jesteś w bieżącym katalogu ~/compose-files/mysql/single, a następnie uruchom go, uruchamiając następujące polecenie:

$ 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

Sprawdź, czy kontener działa w trybie odłączonym:

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

Gratulacje! Mamy teraz kontener MySQL działający za pomocą tylko jednego polecenia.

Wdrażanie stosu

Compose-file upraszcza rzeczy, daje nam jaśniejszy obraz tego, jak powinna wyglądać infrastruktura. Stwórzmy stos kontenerów, który składa się ze strony działającej na Drupalu, używając instancji MySQL w dedykowanej sieci i połączmy je ze sobą.

Podobnie jak powyżej, spójrzmy na wersję wiersza poleceń we właściwej kolejności, aby zbudować ten stos:

$ 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

Aby rozpocząć komponowanie, najpierw utwórzmy katalog dla naszego nowego stosu:

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

Następnie utwórz zawartość zapisu docker-compose.yml zgodnie z poniższym:

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

Odpal je:

$ 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 wykona wdrożenie w następujący sposób:

1. Utwórz sieć
2. Utwórz wolumin
3. Wyciągnij obrazy
4. Utwórz mysql-drupal (ponieważ kontener „drupal” jest od niego zależny)
5. Utwórz kontener Drupala

W tym momencie naszą architekturę można zilustrować w następujący sposób:

Następnie możemy określić „mysql” jako host MySQL na stronie kreatora instalacji, ponieważ oba kontenery są ze sobą połączone. Otóż ​​to. Aby je zniszczyć, po prostu uruchom następujące polecenie w tym samym katalogu:

$ docker-compose down

Odpowiednie kontenery zostaną odpowiednio zakończone i usunięte. Zwróć uwagę, że polecenie docker-compose jest powiązane z indywidualnym hostem fizycznym, na którym działa Docker. Aby działać na wielu fizycznych hostach w Swarm, należy go traktować inaczej, używając polecenia „stos dockera”. Wyjaśnimy to w następnej sekcji.

Tworzenie stosu w roju

Po pierwsze, upewnij się, że silnik Dockera działa w wersji 1.13, a tryb Swarm jest włączony i gotowy:

$ 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

Aby skorzystać z funkcji stosu w trybie Docker Swarm, musimy użyć formatu Docker Compose w wersji 3. Zamierzamy wdrożyć konfigurację podobną do powyższej, z wyjątkiem konfiguracji Galera z trzema węzłami jako backendu MySQL. Szczegółowo wyjaśniliśmy już to w tym poście na blogu.

Najpierw utwórz katalog dla naszego nowego stosu:

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

Następnie dodaj następujące wiersze do „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

Zwróć uwagę, że używany przez nas obraz Galera (severalnines/pxc56) wymaga działającego klastra etcd zainstalowanego na każdym fizycznym hoście platformy Docker. Zapoznaj się z tym wpisem na blogu na temat wymaganych czynności.

Jedną z ważnych części naszego pliku do komponowania jest parametr max_attempts w sekcji restart_policy. Musimy określić sztywny limit liczby ponownych uruchomień w przypadku awarii. Dzięki temu proces wdrażania będzie bezpieczniejszy, ponieważ domyślnie harmonogram Swarm nigdy nie podda się przy próbie ponownego uruchomienia kontenerów. Jeśli tak się stanie, pętla procesu wypełni przestrzeń dyskową hosta fizycznego bezużytecznymi kontenerami, gdy planista nie może doprowadzić kontenerów do pożądanego stanu. Jest to powszechne podejście podczas obsługi usług stanowych, takich jak MySQL. Lepiej jest całkowicie je zniszczyć, niż sprawić, by działały w niespójnym stanie.

Aby je wszystkie uruchomić, po prostu wykonaj następujące polecenie w tym samym katalogu, w którym znajduje się docker-compose.yml:

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

Sprawdź, czy stos został utworzony z 2 usługami (drupal i galera):

$ docker stack ls
NAME       SERVICES
my_drupal  2

W utworzonym stosie możemy również wylistować bieżące zadania. Rezultatem jest połączona wersja poleceń „docker service ps my_drupal_galera” i „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

Gdy otrzymamy CURRENT STATE jako RUNNING, możemy rozpocząć instalację Drupala łącząc się z dowolnym adresem IP hosta Docker lub nazwą hosta na porcie 8080, ponieważ w tym przypadku użyliśmy docker3 (choć kontener drupal jest wdrożony na docker1), http ://192.168.55.113:8080/. Kontynuuj instalację i określ „galera” jako host MySQL i „drupal” jako nazwę bazy danych (zgodnie z definicją w pliku Compose w zmiennej środowiskowej MYSQL_DATABASE):

Otóż ​​to. Wdrażanie stosu zostało uproszczone przy użyciu pliku Compose. W tym momencie nasza architektura wygląda mniej więcej tak:

Na koniec, aby usunąć stos, po prostu uruchom następujące polecenie:

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

Korzystanie z tworzenia pliku może zaoszczędzić czas i zmniejszyć ryzyko błędów ludzkich w porównaniu z pracą z długimi wierszami poleceń. Jest to idealne narzędzie do opanowania przed rozpoczęciem pracy z wielokontenerowymi aplikacjami Docker, radzenie sobie z wieloma środowiskami wdrożeniowymi (np. dev, test, staging, pre-prod, prod) i obsługą znacznie bardziej złożonych usług, takich jak MySQL Galera Cluster. Miłego kontenerowania

!