MariaDB MaxScale Load Balancing di Docker:Deployment:Bagian Satu

MariaDB MaxScale adalah proxy database plug-in canggih untuk server database MariaDB. Itu duduk di antara aplikasi klien dan server database, merutekan kueri klien dan respons server. MaxScale juga memonitor server, sehingga dengan cepat akan melihat perubahan status server atau topologi replikasi. Ini menjadikan MaxScale pilihan yang wajar untuk mengontrol failover dan fitur serupa.

Dalam seri blog dua bagian ini, kami akan memberikan panduan lengkap tentang cara menjalankan MariaDB MaxScale di Docker. Bagian ini mencakup penerapan sebagai wadah Docker mandiri dan pengelompokan MaxScale melalui Docker Swarm untuk ketersediaan tinggi.

MariaDB MaxScale di Docker

Ada sejumlah gambar MariaDB Docker yang tersedia di Docker Hub. Di blog ini, kita akan menggunakan gambar resmi yang dikelola dan diterbitkan oleh MariaDB yang disebut "mariadb/maxscale" (tag:terbaru). Gambar berukuran sekitar 71MB. Pada saat penulisan ini, image sudah diinstal sebelumnya dengan MaxScale 2.3.4 sebagai bagian dari paket yang diperlukan.

Umumnya, langkah-langkah berikut diperlukan untuk menjalankan MaxScale dengan image ini di lingkungan container:

Replikasi MariaDB (master-slave atau master-master) yang sedang berjalan/Cluster Galera atau Cluster NDB
Membuat dan memberikan pengguna database yang didedikasikan untuk pemantauan MaxScale
Siapkan file konfigurasi MaxScale
Petakan file konfigurasi ke dalam container atau muat ke Kubernetes ConfigMap atau Docker Swarm Configs
Mulai container/pod/service/replicaset

Perhatikan bahwa MaxScale adalah produk MariaDB, yang berarti disesuaikan dengan server MariaDB. Sebagian besar fitur masih kompatibel dengan MySQL kecuali beberapa bagian seperti penanganan GTID, konfigurasi Galera Cluster dan file data internal. Versi yang akan kita gunakan adalah 2.3.4, yang dirilis di bawah Business Source License (BSL). Ini memungkinkan semua kode terbuka dan penggunaan di bawah TIGA server gratis. Ketika penggunaan melewati tiga server backend, perusahaan yang menggunakannya harus membayar langganan komersial. Setelah jangka waktu tertentu (2 tahun dalam kasus MaxScale) rilis berpindah ke GPL dan semua penggunaan gratis.

Untuk memperjelas, karena ini adalah lingkungan pengujian, kami boleh saja memiliki lebih dari 2 node. Sebagaimana dinyatakan dalam halaman FAQ MariaDB BSL:

T:Dapatkah saya menggunakan produk MariaDB yang dilisensikan di bawah BSL dalam lingkungan pengujian dan pengembangan?
A:Ya, Dalam lingkungan pengujian dan pengembangan non-produksi, Anda dapat menggunakan produk yang dilisensikan di bawah BSL tanpa perlu berlangganan dari MariaDB

Dalam panduan ini, kita sudah memiliki Replikasi MariaDB tiga simpul yang dikerahkan menggunakan ClusterControl. Diagram berikut mengilustrasikan penyiapan yang akan kita terapkan:

Arsitektur sistem kami terdiri dari:

mariadb1 - 192.168.0.91 (master)
mariadb2 - 192.168.0.92 (budak)
mariadb3 - 192.168.0.93 (budak)
docker1 - 192.168.0.200 (Host Docker untuk container - maxscale, aplikasi)

Menyiapkan Pengguna MaxScale

Pertama, buat pengguna database MySQL untuk MaxScale dan izinkan semua host di jaringan 192.168.0.0/24:

MariaDB> CREATE USER 'maxscale'@'192.168.0.%' IDENTIFIED BY 'my_s3cret';

Kemudian, berikan hak istimewa yang diperlukan. Jika Anda hanya ingin memantau server backend dengan penyeimbangan beban, hibah berikut sudah cukup:

MariaDB> GRANT SHOW DATABASES ON *.* TO 'maxscale'@'192.168.0.%';
MariaDB> GRANT SELECT ON `mysql`.* TO 'maxscale'@'192.168.0.%';

Namun, MaxScale dapat melakukan lebih dari sekadar merutekan kueri. Ia memiliki kemampuan untuk melakukan failover dan switchover misalnya mempromosikan budak ke master baru. Ini membutuhkan hak istimewa SUPER dan REPLICATION CLIENT. Jika Anda ingin menggunakan fitur ini, tetapkan SEMUA HAK ISTIMEWA kepada pengguna:

mysql> GRANT ALL PRIVILEGES ON *.* TO [email protected]'192.168.0.%';

Itu saja untuk bagian pengguna.

Menyiapkan File Konfigurasi MaxScale

Gambar memerlukan file konfigurasi yang berfungsi untuk dipetakan ke dalam wadah sebelum dimulai. File konfigurasi minimal yang disediakan dalam wadah tidak akan membantu kita membangun proxy terbalik yang kita inginkan. Oleh karena itu, file konfigurasi harus disiapkan terlebih dahulu.

Daftar berikut dapat membantu kami mengumpulkan informasi dasar yang diperlukan untuk membuat file konfigurasi kami:

Jenis cluster - MaxScale mendukung replikasi MariaDB (master-slave, master-master), Galera Cluster, Amazon Aurora, MariaDB ColumnStore, dan NDB Cluster (alias MySQL Cluster).
Alamat IP backend dan/atau nama host - Alamat IP atau nama host yang dapat dijangkau untuk semua server backend.
Algoritme perutean - MaxScale mendukung dua jenis perutean kueri - pemisahan baca-tulis dan penyeimbangan beban secara round-robin.
Port untuk mendengarkan oleh MaxScale - Secara default, MaxScale menggunakan port 4006 untuk koneksi round-robin dan 4008 untuk koneksi split baca-tulis. Anda dapat menggunakan soket UNIX jika Anda mau.

Di direktori saat ini, buat file teks bernama maxscale.cnf sehingga kami dapat memetakannya ke dalam wadah saat memulai. Rekatkan baris berikut ke dalam file:

########################
## Server list
########################

[mariadb1]
type            = server
address         = 192.168.0.91
port            = 3306
protocol        = MariaDBBackend
serv_weight     = 1

[mariadb2]
type            = server
address         = 192.168.0.92
port            = 3306
protocol        = MariaDBBackend
serv_weight     = 1

[mariadb3]
type            = server
address         = 192.168.0.93
port            = 3306
protocol        = MariaDBBackend
serv_weight     = 1

#########################
## MaxScale configuration
#########################

[maxscale]
threads                 = auto
log_augmentation        = 1
ms_timestamp            = 1
syslog                  = 1

#########################
# Monitor for the servers
#########################

[monitor]
type                    = monitor
module                  = mariadbmon
servers                 = mariadb1,mariadb2,mariadb3
user                    = maxscale
password                = my_s3cret
auto_failover           = true
auto_rejoin             = true
enforce_read_only_slaves = 1

#########################
## Service definitions for read/write splitting and read-only services.
#########################

[rw-service]
type            = service
router          = readwritesplit
servers         = mariadb1,mariadb2,mariadb3
user            = maxscale
password        = my_s3cret
max_slave_connections           = 100%
max_sescmd_history              = 1500
causal_reads                    = true
causal_reads_timeout            = 10
transaction_replay              = true
transaction_replay_max_size     = 1Mi
delayed_retry                   = true
master_reconnection             = true
master_failure_mode             = fail_on_write
max_slave_replication_lag       = 3

[rr-service]
type            = service
router          = readconnroute
servers         = mariadb1,mariadb2,mariadb3
router_options  = slave
user            = maxscale
password        = my_s3cret

##########################
## Listener definitions for the service
## Listeners represent the ports the service will listen on.
##########################

[rw-listener]
type            = listener
service         = rw-service
protocol        = MariaDBClient
port            = 4008

[ro-listener]
type            = listener
service         = rr-service
protocol        = MariaDBClient
port            = 4006

Sedikit penjelasan untuk setiap bagian:

Daftar Server - Server backend. Tentukan setiap server MariaDB dari cluster ini dalam baitnya sendiri. Nama stanza akan digunakan saat kami menentukan definisi layanan lebih jauh ke bawah. Jenis komponen harus "server".
Konfigurasi MaxScale - Tentukan semua konfigurasi terkait MaxScale di sana.
Modul monitor - Bagaimana MaxScale harus memantau server backend. Jenis komponen harus "monitor" diikuti oleh salah satu modul pemantauan. Untuk daftar monitor yang didukung, lihat Monitor MaxScale 2.3.
Layanan - Tempat untuk merutekan kueri. Jenis komponen harus "layanan". Untuk daftar router yang didukung, lihat Router MaxScale 2.3.
Listener - Bagaimana MaxScale harus mendengarkan koneksi masuk. Ini bisa berupa file port atau socket. Jenis komponen harus "pendengar". Biasanya, pendengar terikat pada layanan.

Jadi pada dasarnya, kami ingin MaxScale mendengarkan di dua port, 4006 dan 4008. Port 4006 khusus untuk koneksi round-robin, cocok untuk beban kerja hanya-baca untuk Replikasi MariaDB kami sementara port 4008 khusus untuk beban kerja baca dan tulis kritis. Kami juga ingin menggunakan MaxScale untuk melakukan tindakan pada replikasi kami jika terjadi failover, switchover, atau slave rejoining, oleh karena itu kami menggunakan modul monitor yang disebut "mariadbmon".

Menjalankan Penampung

Kami sekarang siap untuk menjalankan wadah MaxScale mandiri kami. Petakan file konfigurasi dengan -v dan pastikan untuk memublikasikan kedua port listener 4006 dan 4008. Secara opsional, Anda dapat mengaktifkan antarmuka MaxScale REST API di port 8989:

$ docker run -d \
--name maxscale \
--restart always \
-p 4006:4006 \
-p 4008:4008 \
-p 8989:8989 \
-v $PWD/maxscale.cnf:/etc/maxscale.cnf \
mariadb/maxscale

Verifikasi dengan:

$ docker logs -f maxscale
...
2019-06-14 07:15:41.060   notice : (main): Started REST API on [127.0.0.1]:8989
2019-06-14 07:15:41.060   notice : (main): MaxScale started with 8 worker threads, each with a stack size of 8388608 bytes.

Pastikan Anda tidak melihat kesalahan saat melihat log di atas. Verifikasi apakah proses docker-proxy mendengarkan pada port yang diterbitkan - 4006, 4008, dan 8989:

$ netstat -tulpn | grep docker-proxy
tcp6       0      0 :::8989                 :::*                    LISTEN      4064/docker-proxy
tcp6       0      0 :::4006                 :::*                    LISTEN      4092/docker-proxy
tcp6       0      0 :::4008                 :::*                    LISTEN      4078/docker-proxy

Pada titik ini, MaxScale kami berjalan dan mampu memproses kueri.

MaxCtrl

MaxCtrl adalah klien administratif baris perintah untuk MaxScale yang menggunakan API REST MaxScale untuk komunikasi. Ini dimaksudkan sebagai perangkat lunak pengganti untuk klien baris perintah MaxAdmin yang lama.

Untuk masuk ke konsol MaxCtrl, jalankan perintah "maxctrl" di dalam wadah:

$ docker exec -it maxscale maxctrl
 maxctrl: list servers
┌──────────┬──────────────┬──────┬─────────────┬─────────────────┬─────────────┐
│ Server   │ Address      │ Port │ Connections │ State           │ GTID        │
├──────────┼──────────────┼──────┼─────────────┼─────────────────┼─────────────┤
│ mariadb1 │ 192.168.0.91 │ 3306 │ 0           │ Master, Running │ 0-5001-1012 │
├──────────┼──────────────┼──────┼─────────────┼─────────────────┼─────────────┤
│ mariadb2 │ 192.168.0.92 │ 3306 │ 0           │ Slave, Running  │ 0-5001-1012 │
├──────────┼──────────────┼──────┼─────────────┼─────────────────┼─────────────┤
│ mariadb3 │ 192.168.0.93 │ 3306 │ 0           │ Slave, Running  │ 0-5001-1012 │
└──────────┴──────────────┴──────┴─────────────┴─────────────────┴─────────────┘

Untuk memverifikasi apakah semuanya baik-baik saja, cukup jalankan perintah berikut:

maxctrl: list servers
maxctrl: list services
maxctrl: list filters
maxctrl: list sessions

Untuk mendapatkan info lebih lanjut tentang setiap komponen, awali dengan perintah "show", misalnya:

maxctrl: show servers
┌──────────────────┬──────────────────────────────────────────┐
│ Server           │ mariadb3                                 │
├──────────────────┼──────────────────────────────────────────┤
│ Address          │ 192.168.0.93                             │
├──────────────────┼──────────────────────────────────────────┤
│ Port             │ 3306                                     │
├──────────────────┼──────────────────────────────────────────┤
│ State            │ Slave, Running                           │
├──────────────────┼──────────────────────────────────────────┤
│ Last Event       │ new_slave                                │
├──────────────────┼──────────────────────────────────────────┤
│ Triggered At     │ Mon, 17 Jun 2019 08:57:59 GMT            │
├──────────────────┼──────────────────────────────────────────┤
│ Services         │ rw-service                               │
│                  │ rr-service                               │
├──────────────────┼──────────────────────────────────────────┤
│ Monitors         │ monitor                                  │
├──────────────────┼──────────────────────────────────────────┤
│ Master ID        │ 5001                                     │
├──────────────────┼──────────────────────────────────────────┤
│ Node ID          │ 5003                                     │
├──────────────────┼──────────────────────────────────────────┤
│ Slave Server IDs │                                          │
├──────────────────┼──────────────────────────────────────────┤
│ Statistics       │ {                                        │
│                  │     "connections": 0,                    │
│                  │     "total_connections": 0,              │
│                  │     "persistent_connections": 0,         │
│                  │     "active_operations": 0,              │
│                  │     "routed_packets": 0,                 │
│                  │     "adaptive_avg_select_time": "0ns"    │
│                  │ }                                        │
├──────────────────┼──────────────────────────────────────────┤
│ Parameters       │ {                                        │
│                  │     "address": "192.168.0.93",           │
│                  │     "protocol": "MariaDBBackend",        │
│                  │     "port": 3306,                        │
│                  │     "extra_port": 0,                     │
│                  │     "authenticator": null,               │
│                  │     "monitoruser": null,                 │
│                  │     "monitorpw": null,                   │
│                  │     "persistpoolmax": 0,                 │
│                  │     "persistmaxtime": 0,                 │
│                  │     "proxy_protocol": false,             │
│                  │     "ssl": "false",                      │
│                  │     "ssl_cert": null,                    │
│                  │     "ssl_key": null,                     │
│                  │     "ssl_ca_cert": null,                 │
│                  │     "ssl_version": "MAX",                │
│                  │     "ssl_cert_verify_depth": 9,          │
│                  │     "ssl_verify_peer_certificate": true, │
│                  │     "disk_space_threshold": null,        │
│                  │     "type": "server",                    │
│                  │     "serv_weight": "1"                   │
│                  │ }                                        │
└──────────────────┴──────────────────────────────────────────┘

Menghubungkan ke Basis Data

Pengguna database aplikasi harus diberikan host MaxScale karena dari sudut pandang server MariaDB, hanya dapat melihat host MaxScale. Perhatikan contoh berikut tanpa MaxScale pada gambar:

Nama basis data:aplikasi saya
Pengguna:myapp_user
Host:192.168.0.133 (server aplikasi)

Untuk mengizinkan pengguna mengakses database di dalam server MariaDB, kita harus menjalankan pernyataan berikut:

MariaDB> CREATE USER 'myapp_user'@'192.168.0.133' IDENTIFIED BY 'mypassword';
MariaDB> GRANT ALL PRIVILEGES ON myapp.* to 'myapp_user'@'192.168.0.133';

Dengan MaxScale dalam gambar, kita harus menjalankan pernyataan berikut sebagai gantinya (ganti alamat IP server aplikasi dengan alamat IP MaxScale, 192.168.0.200):

MariaDB> CREATE USER 'myapp_user'@'192.168.0.200' IDENTIFIED BY 'mypassword';
MariaDB> GRANT ALL PRIVILEGES ON myapp.* to 'myapp_user'@'192.168.0.200';

Dari aplikasi, ada dua port yang dapat Anda gunakan untuk terhubung ke database:

4006 - Pendengar serba guna, cocok untuk beban kerja hanya-baca.
4008 - Pendengar terpisah baca-tulis, cocok untuk beban kerja menulis.

Jika aplikasi Anda diizinkan untuk menentukan hanya satu port MySQL (misalnya, Wordpress, Joomla, dll), pilih port RW 4008 sebagai gantinya. Ini adalah koneksi titik akhir teraman terlepas dari jenis cluster. Namun, jika aplikasi Anda dapat menangani koneksi ke beberapa port MySQL, Anda dapat mengirim pembacaan ke pendengar round-robin. Listener ini memiliki overhead yang lebih sedikit dan jauh lebih cepat jika dibandingkan dengan listener split baca-tulis.

Untuk penyiapan replikasi MariaDB kami, sambungkan ke salah satu dari titik akhir ini sebagai kombinasi host/port database:

192.168.0.200 port 4008 - MaxScale - baca/tulis atau tulis saja
192.168.0.200 port 4006 - MaxScale - hanya-baca seimbang
192.168.0.91 port 3306 - Server MariaDB (master) - baca/tulis
192.168.0.92 port 3306 - Server MariaDB (slave) - hanya-baca
192.168.0.93 port 3306 - Server MariaDB (slave) - hanya-baca

Catatan untuk tipe cluster multi-master seperti Galera Cluster dan NDB Cluster, port 4006 dapat digunakan sebagai koneksi seimbang multi-tulis. Dengan MaxScale, Anda memiliki banyak opsi untuk dipilih saat menghubungkan ke database, dengan masing-masing memberikan keunggulannya sendiri.

Pengelompokan Skala Maks dengan Docker Swarm

Dengan Docker Swarm, kita dapat membuat grup instance MaxScale melalui layanan Swarm dengan lebih dari satu replika bersama dengan Swarm Configs. Pertama, impor file konfigurasi ke Swarm:

$ cat maxscale.conf | docker config create maxscale_config -

Verifikasi dengan:

$ docker config inspect --pretty maxscale_config

Kemudian, beri pengguna database MaxScale untuk terhubung dari host Swarm mana pun di jaringan:

MariaDB> CREATE USER 'maxscale'@'192.168.0.%' IDENTIFIED BY 'my_s3cret';
MariaDB> GRANT ALL PRIVILEGES ON *.* TO [email protected]'192.168.0.%';

Saat memulai layanan Swarm untuk MaxScale, kita dapat membuat beberapa wadah (disebut replika) pemetaan ke file konfigurasi yang sama seperti di bawah ini:

$ docker service create \
--name maxscale-cluster  \
--replicas=3 \
--publish published=4008,target=4008 \
--publish published=4006,target=4006 \
--config source=maxscale_config,target=/etc/maxscale.cnf \
mariadb/maxscale

Di atas akan membuat tiga wadah MaxScale yang tersebar di seluruh node Swarm. Verifikasi dengan:

$ docker service ls
ID                  NAME                MODE                REPLICAS            IMAGE                     PORTS
yj6u2xcdj7lo        maxscale-cluster    replicated          3/3                 mariadb/maxscale:latest   *:4006->4006/tcp, *:4008->4008/tcp

Jika aplikasi berjalan dalam jaringan Swarm, Anda cukup menggunakan nama layanan "maxscale-cluster" sebagai host database untuk aplikasi Anda. Secara eksternal, Anda dapat terhubung ke salah satu host Docker pada port yang diterbitkan dan jaringan Swarm akan merutekan dan menyeimbangkan koneksi ke wadah yang benar secara round-robin. Pada titik ini arsitektur kita dapat diilustrasikan seperti di bawah ini:

Di bagian kedua, kita akan melihat kasus penggunaan lanjutan MaxScale di Docker seperti kontrol layanan, manajemen konfigurasi, pemrosesan kueri, keamanan, dan rekonsiliasi cluster.