sql >> Database >  >> RDS >> MariaDB

MySQL-containers bewaken met Prometheus - Implementatie op standalone en Swarm::deel één

Monitoring is een punt van zorg voor containers, omdat de infrastructuur dynamisch is. Containers kunnen routinematig worden gemaakt en vernietigd en zijn kortstondig. Dus hoe houdt u uw MySQL-instanties bij die op Docker draaien?

Zoals met elke softwarecomponent, zijn er veel opties die kunnen worden gebruikt. We zullen Prometheus zien als een oplossing die is gebouwd voor gedistribueerde infrastructuur en die heel goed werkt met Docker.

Dit is een blog in twee delen. In deze blog van deel 1 gaan we in op het implementatieaspect van onze MySQL-containers met Prometheus en zijn componenten, die worden uitgevoerd als zelfstandige Docker-containers en Docker Swarm-services. In deel 2 zullen we kijken naar de belangrijke statistieken die moeten worden gecontroleerd vanuit onze MySQL-containers, evenals naar integratie met de paging- en meldingssystemen.

Inleiding tot Prometheus

Prometheus is een volledig monitoring- en trendingsysteem met ingebouwde en actieve scraping, opslag, query's, grafieken en waarschuwingen op basis van tijdreeksgegevens. Prometheus verzamelt metrische gegevens via een pull-mechanisme van geconfigureerde doelen met bepaalde tussenpozen, evalueert regeluitdrukkingen, geeft de resultaten weer en kan waarschuwingen activeren als wordt vastgesteld dat een voorwaarde waar is. Het ondersteunt alle doelstatistieken die we willen meten als men MySQL als Docker-containers wil gebruiken. Die statistieken omvatten fysieke hosts-statistieken, Docker-containerstatistieken en MySQL-serverstatistieken.

Bekijk het volgende diagram dat de Prometheus-architectuur illustreert (overgenomen uit de officiële documentatie van Prometheus):

We gaan een aantal MySQL-containers (standalone en Docker Swarm) inzetten, compleet met een Prometheus-server, MySQL-exporteur (d.w.z. een Prometheus-agent om MySQL-statistieken bloot te leggen, die vervolgens door de Prometheus-server kunnen worden geschraapt) en ook Alertmanager om waarschuwingen te verwerken op de verzamelde statistieken.

Raadpleeg de Prometheus-documentatie voor meer informatie. In dit voorbeeld gaan we de officiële Docker-afbeeldingen gebruiken die door het Prometheus-team zijn geleverd.

Standalone Docker

MySQL-containers implementeren

Laten we twee zelfstandige MySQL-servers op Docker draaien om onze implementatie-walkthrough te vereenvoudigen. De ene container gebruikt de nieuwste MySQL 8.0 en de andere is MySQL 5.7. Beide containers bevinden zich in hetzelfde Docker-netwerk genaamd "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 is standaard ingesteld op een nieuwe authenticatie-plug-in genaamd caching_sha2_password . Laten we voor compatibiliteit met de Prometheus MySQL-exportercontainer het veelgebruikte mysql_native_password gebruiken plug-in wanneer we een nieuwe MySQL-gebruiker op deze server maken.

Voor de tweede MySQL-container met 5.7 voeren we het volgende uit:

$ 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

Controleer of onze MySQL-servers goed werken:

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

Op dit moment ziet onze architectuur er ongeveer zo uit:

Laten we beginnen ze in de gaten te houden.

Dockerstatistieken blootstellen aan Prometheus

Docker heeft ingebouwde ondersteuning als Prometheus-doelwit, waar we de Docker-enginestatistieken kunnen volgen. We kunnen het eenvoudig inschakelen door een tekstbestand met de naam "daemon.json" in de Docker-host te maken:

$ vim /etc/docker/daemon.json

En voeg de volgende regels toe:

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

Waarbij 192.168.55.161 het primaire IP-adres van de Docker-host is. Start vervolgens de Docker-daemon opnieuw om de wijziging te laden:

$ systemctl restart docker

Omdat we --restart=unless-stopped hebben gedefinieerd in het run-commando van onze MySQL-containers, worden de containers automatisch gestart nadat Docker is gestart.

MySQL Exporter implementeren

Voordat we verder gaan, vereist de mysqld-exporteur dat een MySQL-gebruiker wordt gebruikt voor controledoeleinden. Maak op onze MySQL-containers de monitoringgebruiker:

$ 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'@'%';

Houd er rekening mee dat het wordt aanbevolen om een ​​maximale verbindingslimiet voor de gebruiker in te stellen om te voorkomen dat de server wordt overbelast met bewakingsschaafwonden onder zware belasting. Herhaal de bovenstaande uitspraken op de tweede container, 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'@'%';

Laten we de mysqld-exportercontainer met de naam "mysql8-exporter" uitvoeren om de statistieken voor onze MySQL 8.0-instantie weer te geven, zoals hieronder:

$ 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

En ook nog een exportcontainer voor onze MySQL 5.7-instantie:

$ 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

We hebben een aantal verzamelvlaggen voor de container ingeschakeld om de MySQL-statistieken bloot te leggen. U kunt ook --collect.slave_status, --collect.slave_hosts inschakelen als u een MySQL-replicatie op containers heeft.

We zouden de MySQL-statistieken via curl rechtstreeks van de Docker-host moeten kunnen ophalen (poort 32771 is de gepubliceerde poort die automatisch door Docker wordt toegewezen voor 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

Op dit moment ziet onze architectuur er ongeveer zo uit:

We zijn nu klaar om de Prometheus-server in te stellen.

Prometheus Server implementeren

Maak eerst het Prometheus-configuratiebestand op ~/prometheus.yml en voeg de volgende regels toe:

$ 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']

Vanuit het Prometheus-configuratiebestand hebben we drie taken gedefinieerd:"prometheus", "mysql" en "docker". De eerste is de taak om de Prometheus-server zelf te bewaken. De volgende is de taak om onze MySQL-containers met de naam "mysql" te bewaken. We definiëren de eindpunten op onze MySQL-exporteurs op poort 9104, die de Prometheus-compatibele statistieken van respectievelijk de MySQL 8.0- en 5.7-instanties blootlegden. De "alert.rules" is het regelbestand dat we later in de volgende blogpost zullen opnemen voor waarschuwingsdoeleinden.

Vervolgens kunnen we de configuratie in kaart brengen met de Prometheus-container. We moeten ook een Docker-volume maken voor Prometheus-gegevens voor persistentie en ook poort 9090 openbaar maken:

$ 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

Nu draait onze Prometheus-server al en is direct toegankelijk op poort 9090 van de Docker-host. Open een webbrowser en ga naar http://192.168.55.161:9090/ om toegang te krijgen tot de Prometheus-webgebruikersinterface. Controleer de doelstatus onder Status -> Doelen en zorg ervoor dat ze allemaal groen zijn:

Op dit moment ziet onze containerarchitectuur er ongeveer zo uit:

Ons Prometheus-monitoringsysteem voor onze zelfstandige MySQL-containers is nu geïmplementeerd.

Dockerzwerm

Een Galera-cluster met 3 knooppunten implementeren

Stel dat we een Galera-cluster met drie knooppunten in Docker Swarm willen implementeren, dan zouden we 3 verschillende services moeten maken, waarbij elke service één Galera-knooppunt vertegenwoordigt. Met deze aanpak kunnen we een statisch oplosbare hostnaam voor onze Galera-container behouden, samen met MySQL-exportercontainers die bij elk van hen zullen worden geleverd. We zullen MariaDB 10.2-image gebruiken die wordt onderhouden door het Docker-team om ons Galera-cluster uit te voeren.

Maak eerst een MySQL-configuratiebestand dat door onze Swarm-service kan worden gebruikt:

$ 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

Maak een speciaal databasenetwerk in onze Swarm genaamd "db_swarm":

$ docker network create --driver overlay db_swarm

Importeer ons MySQL-configuratiebestand in Docker-configuratie, zodat we het in onze Swarm-service kunnen laden wanneer we het later maken:

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

Maak de eerste Galera-bootstrap-service, met "gcomm://" als het clusteradres met de naam "galera0". Dit is een tijdelijke service voor alleen het bootstrapping-proces. We zullen deze service verwijderen zodra we 3 andere Galera-services hebben laten draaien:

$ 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

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

Herhaal vervolgens de volgende opdracht 3 keer om 3 verschillende Galera-services te maken. Vervang {name} door respectievelijk galera1, galera2 en 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}

Controleer onze huidige Docker-services:

$ 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

Onze architectuur ziet er nu ongeveer zo uit:

We moeten de Galera bootstrap Swarm-service, galera0, verwijderen om te voorkomen dat deze wordt uitgevoerd, want als de container opnieuw wordt gepland door Docker Swarm, wordt er een nieuwe replica gestart met een nieuw nieuw volume. We lopen het risico op gegevensverlies omdat het --wsrep_cluster_address bevat "galera0" in de andere Galera-knooppunten (of Swarm-services). Laten we het dus verwijderen:

$ docker service rm galera0

Op dit moment hebben we onze Galera-cluster met drie knooppunten:

We zijn nu klaar om onze MySQL-exporteur en Prometheus Server in te zetten.

MySQL Exporter Swarm Service

Log in op een van de Galera-knooppunten en maak de exportgebruiker aan met de juiste rechten:

$ 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'@'%';

Maak vervolgens de exportservice voor elk van de Galera-services (vervang {name} door respectievelijk galera1, galera2 en galera3):

$ 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

Op dit moment ziet onze architectuur er ongeveer zo uit met exportdiensten in beeld:

Prometheus Server Swarm-service

Laten we tot slot onze Prometheus-server implementeren. Net als bij de Galera-implementatie, moeten we eerst het Prometheus-configuratiebestand voorbereiden voordat we het in Swarm importeren met de Docker-configuratieopdracht:

$ 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']

Vanuit het Prometheus-configuratiebestand hebben we drie taken gedefinieerd:"prometheus" en "galera". De eerste is de taak om de Prometheus-server zelf te bewaken. De volgende is de taak om onze MySQL-containers met de naam "galera" te bewaken. We definiëren de eindpunten op onze MySQL-exporteurs op poort 9104, die respectievelijk de Prometheus-compatibele statistieken van de drie Galera-knooppunten blootleggen. De "alert.rules" is het regelbestand dat we later in de volgende blogpost zullen opnemen voor waarschuwingsdoeleinden.

Importeer het configuratiebestand in Docker-configuratie om later te gebruiken met de Prometheus-container:

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

Laten we de Prometheus-servercontainer uitvoeren en poort 9090 van alle Docker-hosts publiceren voor de Prometheus-web-UI-service:

$ 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

Controleer met het Docker-servicecommando dat we 3 Galera-services, 3 exportservices en 1 Prometheus-service hebben:

$ 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

Nu draait onze Prometheus-server al en is rechtstreeks toegankelijk op poort 9090 vanaf elk Docker-knooppunt. Open een webbrowser en ga naar http://192.168.55.161:9090/ om toegang te krijgen tot de Prometheus-webgebruikersinterface. Controleer de doelstatus onder Status -> Doelen en zorg ervoor dat ze allemaal groen zijn:

Op dit moment ziet onze Swarm-architectuur er ongeveer zo uit:

Wordt vervolgd..

We hebben nu onze database en monitoringstack geïmplementeerd op Docker. In deel 2 van de blog zullen we kijken naar de verschillende MySQL-statistieken om in de gaten te houden. We zullen ook zien hoe u waarschuwingen kunt configureren met Prometheus.


  1. Deelnemen aan meerdere kolommen

  2. SQLite Beschrijf Tabel

  3. wat is @JoinColumn en hoe wordt het gebruikt in Hibernate

  4. 5 manieren om tijdelijke tabellen weer te geven met T-SQL