Cara Memantau Kontainer MySQL dengan Prometheus - Penerapan di Standalone dan Swarm::Bagian Satu

Pemantauan menjadi perhatian bagi container, karena infrastrukturnya dinamis. Wadah dapat dibuat dan dihancurkan secara rutin, dan bersifat sementara. Jadi, bagaimana Anda melacak instance MySQL Anda berjalan di Docker?

Seperti halnya komponen perangkat lunak lainnya, ada banyak opsi di luar sana yang dapat digunakan. Kami akan melihat Prometheus sebagai solusi yang dibangun untuk infrastruktur terdistribusi, dan bekerja sangat baik dengan Docker.

Ini adalah blog dua bagian. Di blog bagian 1 ini, kita akan membahas aspek penerapan container MySQL dengan Prometheus dan komponennya, berjalan sebagai container Docker mandiri dan layanan Docker Swarm. Di bagian 2, kita akan melihat metrik penting untuk dipantau dari wadah MySQL kami, serta integrasi dengan sistem paging dan notifikasi.

Pengantar Prometheus

Prometheus adalah sistem pemantauan dan tren penuh yang mencakup pengikisan, penyimpanan, kueri, pembuatan grafik, dan peringatan bawaan dan aktif berdasarkan data deret waktu. Prometheus mengumpulkan metrik melalui mekanisme tarik dari target yang dikonfigurasi pada interval tertentu, mengevaluasi ekspresi aturan, menampilkan hasil, dan dapat memicu peringatan jika beberapa kondisi dianggap benar. Ini mendukung semua metrik target yang ingin kami ukur jika seseorang ingin menjalankan MySQL sebagai wadah Docker. Metrik tersebut mencakup metrik host fisik, metrik container Docker, dan metrik server MySQL.

Lihatlah diagram berikut yang menggambarkan arsitektur Prometheus (diambil dari dokumentasi resmi Prometheus):

Kami akan menyebarkan beberapa wadah MySQL (mandiri dan Docker Swarm) lengkap dengan server Prometheus, eksportir MySQL (yaitu, agen Prometheus untuk mengekspos metrik MySQL, yang kemudian dapat dikikis oleh server Prometheus) dan juga Alertmanager untuk menangani berbasis peringatan pada metrik yang dikumpulkan.

Untuk detail lebih lanjut, lihat dokumentasi Prometheus. Dalam contoh ini, kita akan menggunakan gambar Docker resmi yang disediakan oleh tim Prometheus.

Docker Mandiri

Menyebarkan Kontainer MySQL

Mari jalankan dua server MySQL mandiri di Docker untuk menyederhanakan panduan penerapan kami. Satu wadah akan menggunakan MySQL 8.0 terbaru dan yang lainnya adalah MySQL 5.7. Kedua kontainer berada di jaringan Docker yang sama yang disebut "db_network":

$ docker network create db_network
$ docker run -d \
--name mysql80 \
--publish 3306 \
--network db_network \
--restart unless-stopped \
--env MYSQL_ROOT_PASSWORD=mypassword \
--volume mysql80-datadir:/var/lib/mysql \
mysql:8 \
--default-authentication-plugin=mysql_native_password

MySQL 8 default ke plugin otentikasi baru yang disebut caching_sha2_password . Untuk kompatibilitas dengan wadah eksportir MySQL Prometheus, mari gunakan mysql_native_password yang banyak digunakan plugin setiap kali kita membuat pengguna MySQL baru di server ini.

Untuk wadah MySQL kedua yang menjalankan 5.7, kami menjalankan yang berikut:

$ docker run -d \
--name mysql57 \
--publish 3306 \
--network db_network \
--restart unless-stopped \
--env MYSQL_ROOT_PASSWORD=mypassword \
--volume mysql57-datadir:/var/lib/mysql \
mysql:5.7

Verifikasi apakah server MySQL kami berjalan dengan baik:

[[email protected] mysql]# docker ps | grep mysql
cc3cd3c4022a        mysql:5.7           "docker-entrypoint.s…"   12 minutes ago      Up 12 minutes       0.0.0.0:32770->3306/tcp   mysql57
9b7857c5b6a1        mysql:8             "docker-entrypoint.s…"   14 minutes ago      Up 14 minutes       0.0.0.0:32769->3306/tcp   mysql80

Pada titik ini, arsitektur kita terlihat seperti ini:

Mari kita mulai memantau mereka.

Mengekspos Metrik Docker ke Prometheus

Docker memiliki dukungan bawaan sebagai target Prometheus, di mana kita dapat menggunakannya untuk memantau statistik mesin Docker. Kita cukup mengaktifkannya dengan membuat file teks bernama "daemon.json" di dalam host Docker:

$ vim /etc/docker/daemon.json

Dan tambahkan baris berikut:

{
  "metrics-addr" : "12.168.55.161:9323",
  "experimental" : true
}

Di mana 192.168.55.161 adalah alamat IP utama host Docker. Kemudian, restart daemon Docker untuk memuat perubahan:

$ systemctl restart docker

Karena kita telah mendefinisikan --restart=unless-stopped dalam perintah run container MySQL, container akan otomatis dimulai setelah Docker berjalan.

Menyebarkan Eksportir MySQL

Sebelum kita melangkah lebih jauh, eksportir mysqld membutuhkan pengguna MySQL untuk digunakan untuk tujuan pemantauan. Di wadah MySQL kami, buat pengguna pemantauan:

$ docker exec -it mysql80 mysql -uroot -p
Enter password:

mysql> CREATE USER 'exporter'@'%' IDENTIFIED BY 'exporterpassword' WITH MAX_USER_CONNECTIONS 3;
mysql> GRANT PROCESS, REPLICATION CLIENT, SELECT ON *.* TO 'exporter'@'%';

Perhatikan bahwa disarankan untuk menetapkan batas koneksi maksimal bagi pengguna untuk menghindari kelebihan server dengan pemantauan goresan di bawah beban berat. Ulangi pernyataan di atas ke wadah kedua, mysql57:

$ docker exec -it mysql57 mysql -uroot -p
Enter password:

mysql> CREATE USER 'exporter'@'%' IDENTIFIED BY 'exporterpassword' WITH MAX_USER_CONNECTIONS 3;
mysql> GRANT PROCESS, REPLICATION CLIENT, SELECT ON *.* TO 'exporter'@'%';

Mari jalankan wadah eksportir mysqld yang disebut "mysql8-exporter" untuk mengekspos metrik untuk instance MySQL 8.0 kami seperti di bawah ini:

$ docker run -d \
--name mysql80-exporter \
--publish 9104 \
--network db_network \
--restart always \
--env DATA_SOURCE_NAME="exporter:[email protected](mysql80:3306)/" \
prom/mysqld-exporter:latest \
--collect.info_schema.processlist \
--collect.info_schema.innodb_metrics \
--collect.info_schema.tablestats \
--collect.info_schema.tables \
--collect.info_schema.userstats \
--collect.engine_innodb_status

Dan juga wadah eksportir lain untuk instance MySQL 5.7 kami:

$ docker run -d \
--name mysql57-exporter \
--publish 9104 \
--network db_network \
--restart always \
-e DATA_SOURCE_NAME="exporter:[email protected](mysql57:3306)/" \
prom/mysqld-exporter:latest \
--collect.info_schema.processlist \
--collect.info_schema.innodb_metrics \
--collect.info_schema.tablestats \
--collect.info_schema.tables \
--collect.info_schema.userstats \
--collect.engine_innodb_status

Kami mengaktifkan sekelompok tanda kolektor untuk wadah untuk mengekspos metrik MySQL. Anda juga dapat mengaktifkan --collect.slave_status, --collect.slave_hosts jika Anda menjalankan replikasi MySQL di container.

Kita harus dapat mengambil metrik MySQL melalui curl dari host Docker secara langsung (port 32771 adalah port yang diterbitkan yang ditetapkan secara otomatis oleh Docker untuk container mysql80-exporter):

$ curl 127.0.0.1:32771/metrics
...
mysql_info_schema_threads_seconds{state="waiting for lock"} 0
mysql_info_schema_threads_seconds{state="waiting for table flush"} 0
mysql_info_schema_threads_seconds{state="waiting for tables"} 0
mysql_info_schema_threads_seconds{state="waiting on cond"} 0
mysql_info_schema_threads_seconds{state="writing to net"} 0
...
process_virtual_memory_bytes 1.9390464e+07

Pada titik ini, arsitektur kita terlihat seperti ini:

Sekarang kami siap untuk menyiapkan server Prometheus.

Menerapkan Server Prometheus

Pertama, buat file konfigurasi Prometheus di ~/prometheus.yml dan tambahkan baris berikut:

$ vim ~/prometheus.yml
global:
  scrape_interval:     5s
  scrape_timeout:      3s
  evaluation_interval: 5s

# Our alerting rule files
rule_files:
  - "alert.rules"

# Scrape endpoints
scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'mysql'
    static_configs:
      - targets: ['mysql57-exporter:9104','mysql80-exporter:9104']

  - job_name: 'docker'
    static_configs:
      - targets: ['192.168.55.161:9323']

Dari file konfigurasi Prometheus, kami telah mendefinisikan tiga pekerjaan - "prometheus", "mysql" dan "docker". Yang pertama adalah tugas untuk memonitor server Prometheus itu sendiri. Tugas berikutnya adalah memonitor container MySQL kita yang bernama "mysql". Kami mendefinisikan titik akhir pada eksportir MySQL kami pada port 9104, yang mengekspos metrik yang kompatibel dengan Prometheus dari instans MySQL 8.0 dan 5.7. "alert.rules" adalah file aturan yang akan kami sertakan nanti di entri blog berikutnya untuk tujuan peringatan.

Kami kemudian dapat memetakan konfigurasi dengan wadah Prometheus. Kami juga perlu membuat volume Docker untuk data Prometheus untuk persistensi dan juga mengekspos port 9090 secara publik:

$ docker run -d \
--name prometheus-server \
--publish 9090:9090 \
--network db_network \
--restart unless-stopped \
--mount type=volume,src=prometheus-data,target=/prometheus \
--mount type=bind,src="$(pwd)"/prometheus.yml,target=/etc/prometheus/prometheus.yml \
--mount type=bind,src="$(pwd)
prom/prometheus

Sekarang server Prometheus kami sudah berjalan dan dapat diakses langsung di port 9090 dari host Docker. Buka browser web dan buka http://192.168.55.161:9090/ untuk mengakses UI web Prometheus. Verifikasi status target di bawah Status -> Target dan pastikan semuanya hijau:

Pada titik ini, arsitektur container kami terlihat seperti ini:

Sistem pemantauan Prometheus kami untuk wadah MySQL mandiri kami sekarang digunakan.

Kawanan Docker

Menerapkan Cluster Galera 3-simpul

Misalkan kita ingin menyebarkan Cluster Galera tiga node di Docker Swarm, kita harus membuat 3 layanan berbeda, masing-masing layanan mewakili satu node Galera. Dengan menggunakan pendekatan ini, kami dapat menyimpan nama host statis yang dapat diselesaikan untuk wadah Galera kami, bersama dengan wadah eksportir MySQL yang akan menyertai masing-masing wadah tersebut. Kami akan menggunakan gambar MariaDB 10.2 yang dikelola oleh tim Docker untuk menjalankan kluster Galera kami.

Pertama, buat file konfigurasi MySQL untuk digunakan oleh layanan Swarm kami:

$ vim ~/my.cnf
[mysqld]

default_storage_engine          = InnoDB
binlog_format                   = ROW

innodb_flush_log_at_trx_commit  = 0
innodb_flush_method             = O_DIRECT
innodb_file_per_table           = 1
innodb_autoinc_lock_mode        = 2
innodb_lock_schedule_algorithm  = FCFS # MariaDB >10.1.19 and >10.2.3 only

wsrep_on                        = ON
wsrep_provider                  = /usr/lib/galera/libgalera_smm.so
wsrep_sst_method                = mariabackup

Buat jaringan database khusus di Swarm kami yang disebut "db_swarm":

$ docker network create --driver overlay db_swarm

Impor file konfigurasi MySQL kami ke konfigurasi Docker sehingga kami dapat memuatnya ke layanan Swarm kami saat kami membuatnya nanti:

$ cat ~/my.cnf | docker config create my-cnf -

Buat layanan bootstrap Galera pertama, dengan "gcomm://" sebagai alamat cluster yang disebut "galera0". Ini adalah layanan sementara untuk proses bootstrap saja. Kami akan menghapus layanan ini setelah kami menjalankan 3 layanan Galera lainnya:

$ docker service create \
--name galera0 \
--replicas 1 \
--hostname galera0 \
--network db_swarm \
--publish 3306 \
--publish 4444 \
--publish 4567 \
--publish 4568 \
--config src=my-cnf,target=/etc/mysql/mariadb.conf.d/my.cnf \
--env MYSQL_ROOT_PASSWORD=mypassword \
--mount type=volume,src=galera0-datadir,dst=/var/lib/mysql \
mariadb:10.2 \
--wsrep_cluster_address=gcomm:// \
--wsrep_sst_auth="root:mypassword" \
--wsrep_node_address=galera0

Pada titik ini, arsitektur database kami dapat diilustrasikan seperti di bawah ini:

Kemudian, ulangi perintah berikut sebanyak 3 kali untuk membuat 3 layanan Galera yang berbeda. Ganti {name} masing-masing dengan galera1, galera2 dan galera3:

$ docker service create \
--name {name} \
--replicas 1 \
--hostname {name} \
--network db_swarm \
--publish 3306 \
--publish 4444 \
--publish 4567 \
--publish 4568 \
--config src=my-cnf,target=/etc/mysql/mariadb.conf.d/my.cnf \
--env MYSQL_ROOT_PASSWORD=mypassword \
--mount type=volume,src={name}-datadir,dst=/var/lib/mysql \
mariadb:10.2 \
--wsrep_cluster_address=gcomm://galera0,galera1,galera2,galera3 \
--wsrep_sst_auth="root:mypassword" \
--wsrep_node_address={name}

Verifikasi layanan Docker kami saat ini:

$ docker service ls 
ID                  NAME                MODE                REPLICAS            IMAGE               PORTS
wpcxye3c4e9d        galera0             replicated          1/1                 mariadb:10.2        *:30022->3306/tcp, *:30023->4444/tcp, *:30024-30025->4567-4568/tcp
jsamvxw9tqpw        galera1             replicated          1/1                 mariadb:10.2        *:30026->3306/tcp, *:30027->4444/tcp, *:30028-30029->4567-4568/tcp
otbwnb3ridg0        galera2             replicated          1/1                 mariadb:10.2        *:30030->3306/tcp, *:30031->4444/tcp, *:30032-30033->4567-4568/tcp
5jp9dpv5twy3        galera3             replicated          1/1                 mariadb:10.2        *:30034->3306/tcp, *:30035->4444/tcp, *:30036-30037->4567-4568/tcp

Arsitektur kami sekarang terlihat seperti ini:

Kita perlu menghapus layanan Galera bootstrap Swarm, galera0, untuk menghentikannya berjalan karena jika wadah sedang dijadwal ulang oleh Docker Swarm, replika baru akan dimulai dengan volume baru yang segar. Kami menanggung risiko kehilangan data karena --wsrep_cluster_address berisi "galera0" di node Galera lainnya (atau layanan Swarm). Jadi, mari kita hapus:

$ docker service rm galera0

Pada titik ini, kami memiliki Galera Cluster tiga simpul kami:

Kami sekarang siap untuk menggunakan eksportir MySQL dan Server Prometheus kami.

Layanan Swarm Eksportir MySQL

Masuk ke salah satu node Galera dan buat pengguna eksportir dengan hak istimewa yang tepat:

$ docker exec -it {galera1} mysql -uroot -p
Enter password:

mysql> CREATE USER 'exporter'@'%' IDENTIFIED BY 'exporterpassword' WITH MAX_USER_CONNECTIONS 3;
mysql> GRANT PROCESS, REPLICATION CLIENT, SELECT ON *.* TO 'exporter'@'%';

Kemudian, buat layanan eksportir untuk masing-masing layanan Galera (ganti {name} dengan galera1, galera2 dan galera3 masing-masing):

$ docker service create \
--name {name}-exporter \
--network db_swarm \
--replicas 1 \
-p 9104 \
-e DATA_SOURCE_NAME="exporter:[email protected]({name}:3306)/" \
prom/mysqld-exporter:latest \
--collect.info_schema.processlist \
--collect.info_schema.innodb_metrics \
--collect.info_schema.tablestats \
--collect.info_schema.tables \
--collect.info_schema.userstats \
--collect.engine_innodb_status

Pada titik ini, arsitektur kami terlihat seperti ini dengan layanan eksportir dalam gambar:

Layanan Swarm Server Prometheus

Terakhir, mari kita gunakan server Prometheus kita. Mirip dengan penerapan Galera, kita harus menyiapkan file konfigurasi Prometheus terlebih dahulu sebelum mengimpornya ke Swarm menggunakan perintah konfigurasi Docker:

$ vim ~/prometheus.yml
global:
  scrape_interval:     5s
  scrape_timeout:      3s
  evaluation_interval: 5s

# Our alerting rule files
rule_files:
  - "alert.rules"

# Scrape endpoints
scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'galera'
    static_configs:
      - targets: ['galera1-exporter:9104','galera2-exporter:9104', 'galera3-exporter:9104']

Dari file konfigurasi Prometheus, kami telah menetapkan tiga pekerjaan - "prometheus" dan "galera". Yang pertama adalah tugas untuk memonitor server Prometheus itu sendiri. Tugas berikutnya adalah memonitor container MySQL kita yang bernama "galera". Kami mendefinisikan titik akhir pada eksportir MySQL kami pada port 9104, yang mengekspos metrik yang kompatibel dengan Prometheus dari tiga node Galera masing-masing. "alert.rules" adalah file aturan yang akan kami sertakan nanti di entri blog berikutnya untuk tujuan peringatan.

Impor file konfigurasi ke dalam konfigurasi Docker untuk digunakan dengan wadah Prometheus nanti:

$ cat ~/prometheus.yml | docker config create prometheus-yml -

Mari jalankan wadah server Prometheus, dan publikasikan port 9090 dari semua host Docker untuk layanan UI web Prometheus:

$ docker service create \
--name prometheus-server \
--publish 9090:9090 \
--network db_swarm \
--replicas 1 \    
--config src=prometheus-yml,target=/etc/prometheus/prometheus.yml \
--mount type=volume,src=prometheus-data,dst=/prometheus \
prom/prometheus

Verifikasi dengan perintah layanan Docker bahwa kami memiliki 3 layanan Galera, 3 layanan eksportir, dan 1 layanan Prometheus:

$ docker service ls
ID                  NAME                MODE                REPLICAS            IMAGE                         PORTS
jsamvxw9tqpw        galera1             replicated          1/1                 mariadb:10.2                  *:30026->3306/tcp, *:30027->4444/tcp, *:30028-30029->4567-4568/tcp
hbh1dtljn535        galera1-exporter    replicated          1/1                 prom/mysqld-exporter:latest   *:30038->9104/tcp
otbwnb3ridg0        galera2             replicated          1/1                 mariadb:10.2                  *:30030->3306/tcp, *:30031->4444/tcp, *:30032-30033->4567-4568/tcp
jq8i77ch5oi3        galera2-exporter    replicated          1/1                 prom/mysqld-exporter:latest   *:30039->9104/tcp
5jp9dpv5twy3        galera3             replicated          1/1                 mariadb:10.2                  *:30034->3306/tcp, *:30035->4444/tcp, *:30036-30037->4567-4568/tcp
10gdkm1ypkav        galera3-exporter    replicated          1/1                 prom/mysqld-exporter:latest   *:30040->9104/tcp
gv9llxrig30e        prometheus-server   replicated          1/1                 prom/prometheus:latest        *:9090->9090/tcp

Sekarang server Prometheus kami sudah berjalan dan dapat diakses langsung di port 9090 dari node Docker mana pun. Buka browser web dan buka http://192.168.55.161:9090/ untuk mengakses UI web Prometheus. Verifikasi status target di bawah Status -> Target dan pastikan semuanya hijau:

Pada titik ini, arsitektur Swarm kami terlihat seperti ini:

Bersambung..

Kami sekarang memiliki basis data dan tumpukan pemantauan yang dikerahkan di Docker. Di bagian 2 blog, kita akan melihat metrik MySQL yang berbeda untuk diperhatikan. Kita juga akan melihat cara mengonfigurasi peringatan dengan Prometheus.