Menyusun Stack - Menyederhanakan Deployment Docker dari MySQL Containers

Docker 1.13 memperkenalkan fitur yang telah lama ditunggu-tunggu yang disebut dukungan compose-file, yang memungkinkan kita untuk mendefinisikan container kita dengan file konfigurasi sederhana yang bagus alih-alih satu perintah panjang. Jika Anda melihat posting blog "MySQL di Docker" kami sebelumnya, kami menggunakan beberapa baris perintah panjang untuk menjalankan container dan layanan. Dengan menggunakan compose-file, container mudah ditentukan untuk penerapan. Ini mengurangi risiko kesalahan manusia karena Anda tidak perlu mengingat perintah panjang dengan banyak parameter.

Dalam posting blog ini, kami akan menunjukkan cara menggunakan file tulis dengan menggunakan contoh sederhana seputar penerapan MySQL. Kami berasumsi Anda telah menginstal Docker Engine 1.13 di 3 host fisik dan mode Swarm dikonfigurasi di semua host.

Pengantar Compose-File

Di file Compose, Anda menentukan semuanya dalam format YAML sebagai lawan dari mencoba mengingat semua argumen yang harus kita berikan ke perintah Docker. Anda dapat menentukan layanan, jaringan, dan volume di sini. Definisi tersebut akan diambil oleh Docker dan sangat mirip dengan meneruskan parameter baris perintah ke perintah “docker run|network|volume”.

Sebagai pengantar, kita akan menggunakan container MySQL mandiri yang sederhana. Sebelum Anda mulai menulis file Compose, Anda harus terlebih dahulu mengetahui perintah run. Diambil dari seri blog MySQL di Docker pertama kami, mari buat perintah “docker run” berikut:

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

Perintah docker-compose akan mencari file default bernama "docker-compose.yml" di direktori saat ini. Jadi, pertama-tama mari kita buat direktori yang diperlukan terlebih dahulu:

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

Dalam YAML, inilah yang harus ditulis:

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

Simpan konten di atas ke "~/compose-files/mysql/single/docker-compose.yml". Pastikan Anda berada di direktori saat ini ~/compose-files/mysql/single, lalu jalankan dengan menjalankan perintah berikut:

$ 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

Verifikasi apakah penampung berjalan dalam mode terpisah:

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

Selamat! Kami sekarang memiliki wadah MySQL yang berjalan hanya dengan satu perintah.

Menyebarkan Tumpukan

Compose-file menyederhanakan banyak hal, ini memberi kita pandangan yang lebih jelas tentang bagaimana infrastruktur seharusnya terlihat. Mari buat tumpukan penampung yang terdiri dari situs web yang berjalan di Drupal, menggunakan instance MySQL di bawah jaringan khusus dan menautkannya bersama-sama.

Mirip dengan di atas, mari kita lihat versi baris perintah dalam urutan yang benar untuk membangun tumpukan ini:

$ 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

Untuk mulai menulis, pertama-tama buat direktori untuk tumpukan baru kita:

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

Kemudian, buat konten tulis docker-compose.yml seperti di bawah ini:

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

Nyalakan mereka:

$ 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 akan melakukan penerapan sebagai berikut:

1. Buat jaringan
2. Buat volume
3. Tarik gambar
4. Buat mysql-drupal (karena container “drupal” bergantung padanya)
5. Buat wadah drupal

Pada titik ini, arsitektur kami dapat diilustrasikan sebagai berikut:

Kami kemudian dapat menentukan 'mysql' sebagai host MySQL di halaman panduan instalasi karena kedua wadah ditautkan bersama. Itu dia. Untuk meruntuhkannya, cukup jalankan perintah berikut di bawah direktori yang sama:

$ docker-compose down

Kontainer yang sesuai akan dihentikan dan dihapus sesuai dengan itu. Perhatikan bahwa perintah docker-compose terikat ke host fisik individu yang menjalankan Docker. Untuk berjalan di beberapa host fisik di seluruh Swarm, itu perlu diperlakukan secara berbeda dengan menggunakan perintah "docker stack". Kami akan menjelaskannya di bagian selanjutnya.

Menyusun Tumpukan di Seluruh Kawanan

Pertama, pastikan mesin Docker berjalan pada v1.13 dan mode Swarm diaktifkan dan dalam keadaan siap:

$ 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

Untuk menggunakan fitur stack untuk mode Docker Swarm, kita harus menggunakan format Docker Compose versi 3. Kami akan menerapkan pengaturan yang serupa dengan di atas, selain dari pengaturan Galera 3-node sebagai backend MySQL. Kami sudah menjelaskan secara detail di postingan blog ini.

Pertama, buat direktori untuk tumpukan baru kami:

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

Kemudian tambahkan baris berikut ke “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

Perhatikan bahwa gambar Galera yang kami gunakan (severalnines/pxc56) memerlukan cluster etcd yang sedang berjalan yang diinstal pada setiap host fisik Docker. Silakan merujuk ke posting blog ini pada langkah-langkah prasyarat.

Salah satu bagian penting dalam file penulisan kami adalah parameter max_attempts di bawah bagian restart_policy. Kita harus menentukan batas keras pada jumlah restart jika terjadi kegagalan. Ini akan membuat proses penerapan lebih aman karena, secara default, penjadwal Swarm tidak akan pernah menyerah dalam mencoba memulai ulang wadah. Jika ini terjadi, loop proses akan mengisi ruang disk host fisik dengan wadah yang tidak dapat digunakan ketika penjadwal tidak dapat membawa wadah ke keadaan yang diinginkan. Ini adalah pendekatan umum saat menangani layanan stateful seperti MySQL. Lebih baik menjatuhkannya sama sekali daripada membuatnya berjalan dalam kondisi yang tidak konsisten.

Untuk memulai semuanya, cukup jalankan perintah berikut di direktori yang sama tempat docker-compose.yml berada:

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

Verifikasi bahwa tumpukan dibuat dengan 2 layanan (drupal dan galera):

$ docker stack ls
NAME       SERVICES
my_drupal  2

Kami juga dapat membuat daftar tugas saat ini di tumpukan yang dibuat. Hasilnya adalah versi gabungan dari perintah “docker service ps my_drupal_galera” dan “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

Setelah kita mendapatkan CURRENT STATE sebagai RUNNING, kita dapat memulai instalasi Drupal dengan menghubungkan ke salah satu alamat IP host Docker atau nama host pada port 8080, seperti dalam kasus ini kita menggunakan docker3 (walaupun wadah drupal ditempatkan pada docker1), http ://192.168.55.113:8080/. Lanjutkan dengan penginstalan dan tentukan 'galera' sebagai host MySQL dan 'drupal' sebagai nama database (sebagaimana didefinisikan dalam file penulisan di bawah variabel lingkungan MYSQL_DATABASE):

Itu dia. Penyebaran tumpukan disederhanakan dengan menggunakan Compose-file. Pada titik ini, arsitektur kita terlihat seperti ini:

Terakhir, untuk menghapus tumpukan, jalankan saja perintah berikut:

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

Menggunakan compose-file dapat menghemat waktu Anda dan mengurangi risiko kesalahan manusia, dibandingkan dengan saat bekerja dengan baris perintah yang panjang. Ini adalah alat yang sempurna untuk Anda kuasai sebelum bekerja dengan aplikasi Docker multi-kontainer, menangani beberapa lingkungan penerapan (misalnya dev, pengujian, staging, pra-prod, prod) dan menangani layanan yang jauh lebih kompleks, seperti MySQL Galera Cluster. Selamat berkemas

!