Cómo monitorear implementaciones de MySQL con Prometheus y Grafana en ScaleGrid

Supervisar el rendimiento de su base de datos MySQL en tiempo real le ayuda a identificar inmediatamente problemas y otros factores que podrían estar causando problemas ahora o en el futuro. También es una buena manera de determinar qué componentes de la base de datos se pueden mejorar u optimizar para aumentar su eficiencia y rendimiento. Esto generalmente se hace a través de software y herramientas de monitoreo integrados en el software de administración de la base de datos o instalados por proveedores externos.

Prometheus es una aplicación de software de código abierto que se utiliza para monitorear y alertar eventos. Se puede utilizar junto con una herramienta de visualización como Grafana para crear y editar fácilmente paneles, consultar, visualizar, alertar y comprender sus métricas. ScaleGrid proporciona acceso de administrador completo a sus implementaciones de MySQL; esto facilita la integración del ecosistema de herramientas de MySQL existente con sus implementaciones de ScaleGrid MySQL en AWS o Azure. Prometheus funciona bien para registrar cualquier serie de tiempo puramente numérica y también ofrece soporte para la recopilación y consulta de datos multidimensionales. Grafana se puede usar con él para crear paneles que ayuden a visualizar estos datos de una manera que sea fácil de interpretar y utilizar. Estas herramientas proporcionarán información adicional sobre sus métricas, patrones de uso y conjuntos de datos junto con su supervisión, análisis de consultas y alertas de ScaleGrid MySQL. En esta publicación de blog, discutimos cómo puede configurar y usar Prometheus y Grafana con sus implementaciones ScaleGrid MySQL para monitoreo y alertas de bases de datos avanzadas.

Cómo configurar su monitoreo de MySQL

Repasemos los pasos necesarios para instalar y configurar el servidor Prometheus para almacenar y mostrar las métricas, un exportador (MySQL Exporter en este caso) para recopilar las métricas y transmitirlas a el servidor Prometheus y Grafana para crear tableros. La herramienta MySQL Exporter se puede instalar localmente en un servidor MySQL o centralmente en el servidor Prometheus. En el caso de uso a continuación, explicaremos cómo configurar y comenzar a usar Prometheus, MySQL Exporter y Grafana desde un host central que se ejecuta en Ubuntu para monitorear múltiples servidores MySQL. También puede consultar las instrucciones paso a paso en nuestro documento de ayuda de Prometheus y Grafana para MySQL.

El siguiente diagrama de bloques muestra la configuración de una implementación de MySQL maestro-esclavo-quórum que incluye dos nodos portadores de datos (maestro y esclavo) y un miembro votante (quórum) usando el Exportador MySQL, host Prometheus y Grafana:

Instalación y configuración del servidor Prometheus

Prometheus es la herramienta que usaremos para centralizar y almacenar sus métricas de MySQL. Extrae las métricas de uno o varios exportadores a intervalos regulares y las muestra en su interfaz de usuario. A continuación se muestran los pasos para instalar y configurar Prometheus en un host central de Ubuntu. Para obtener más detalles, puede consultar este artículo.

1. Crear un grupo y usuario del sistema Prometheus

$sudo groupadd --system prometheus
$sudo useradd -s /sbin/nologin --system -g prometheus prometheus

2. Crear un directorio de datos para Prometheus

$sudo mkdir /var/lib/prometheus

3. Crear directorios de configuración para Prometheus

$for i in rules rules.d files_sd; do sudo mkdir -p /etc/prometheus/${i}; done

4. Descargue el archivo de Prometheus y extraiga el archivo

Para descargar el último archivo binario de Prometheus:

$mkdir -p /tmp/prometheus && cd /tmp/prometheus
$curl -s https://api.github.com/repos/prometheus/prometheus/releases/latest \
| grep browser_download_url \
| grep linux-amd64 \
| cut -d '"' -f 4 \
| wget -qi -

Para extraer el archivo:

$tar xvf prometheus*.tar.gz
$cd prometheus*/

5. Mover los archivos de Prometheus a ubicaciones estándar

Mover archivos binarios de Prometheus a /usr/local/bin:

$sudo mv prometheus promtool /usr/local/bin/

Mueva la plantilla de configuración de Prometheus al directorio /etc:

$sudo mv prometheus.yml  /etc/prometheus/prometheus.yml

También mueva las consolas y console_libraries al directorio /etc/prometheus:

$sudo mv consoles/ console_libraries/ /etc/prometheus/

6. Crear/Editar un archivo de configuración de Prometheus

Las configuraciones de la plantilla deben ser similares a las siguientes:

$cat /etc/prometheus/prometheus.yml

 #my global config
 global:
 scrape_interval: 15s # Set the scrape interval to every 15 seconds. Default is every 1 minute.
 evaluation_interval: 15s # Evaluate rules every 15 seconds. The default is every 1 minute.
 #scrape_timeout is set to the global default (10s).

 #Alertmanager configuration
 alerting:
 alertmanagers:
 - static_configs:
 - targets:
 #- alertmanager:9093

 #Load rules once and periodically evaluate them according to the global 'evaluation_interval'.
 rule_files:
 #- "first_rules.yml"
 #- "second_rules.yml"

 #A scrape configuration containing exactly one endpoint to scrape:
 #Here it's Prometheus itself.
 scrape_configs:
 #The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
 - job_name: 'prometheus'

 #metrics_path defaults to '/metrics'
 #scheme defaults to 'http'.

 static_configs:
 - targets: ['localhost:9090']

7. Cree un archivo de unidad de servicio systemd de Prometheus

$sudo vim /etc/systemd/system/prometheus.service

Agregue el siguiente contenido:

 [Unit]
 Description=Prometheus
 Documentation=https://prometheus.io/docs/introduction/overview/
 Wants=network-online.target
 After=network-online.target

 [Service]
 Type=simple
 Environment="GOMAXPROCS=1"
 User=prometheus
 Group=prometheus
 ExecReload=/bin/kill -HUP $MAINPID
 ExecStart=/usr/local/bin/prometheus \
 --config.file=/etc/prometheus/prometheus.yml \
 --storage.tsdb.path=/var/lib/prometheus \
 --web.console.templates=/etc/prometheus/consoles \
 --web.console.libraries=/etc/prometheus/console_libraries \
 --web.listen-address=0.0.0.0:9090 \
 --web.external-url=

 SyslogIdentifier=prometheus
 Restart=always

 [Install]
 WantedBy=multi-user.target

Recuerde editar la línea:Environment=”GOMAXPROCS=1 reemplazando 1 con el número de vcpus en su servidor.

8. Cambiar permisos de directorio

Cambiar la propiedad de estos directorios al usuario y grupo de Prometheus:

$for i in rules rules.d files_sd; do sudo chown -R prometheus:prometheus /etc/prometheus/${i}; done
$for i in rules rules.d files_sd; do sudo chmod -R 775 /etc/prometheus/${i}; done
$sudo chown -R prometheus:prometheus /var/lib/prometheus/

9. Vuelva a cargar systemd Daemon e inicie el servicio

$sudo systemctl daemon-reload
$sudo systemctl start prometheus
$sudo systemctl enable prometheus

Verificar el estado usando systemctl status prometheus comando:

10. Configurar un cortafuegos para abrir el puerto 9090

$sudo firewall-cmd --add-port=9090/tcp --permanent
$sudo firewall-cmd --reload

Una vez que se completa la configuración, puede acceder a la interfaz de usuario de Prometheus iniciando sesión en http://:9090

Cómo monitorear las implementaciones de #MySQL con Prometheus y Grafana en ScaleGridHaga clic para tuitear

Instalación y configuración del exportador MySQL Prometheus

Prometheus requiere un exportador para recopilar las métricas del servidor MySQL. Este exportador se puede ejecutar de forma centralizada en el servidor Prometheus o en el servidor de la base de datos. Para leer más, consulte la documentación de Prometheus.

Siga los pasos a continuación para instalar y configurar MySQL Prometheus Exporter en el host central de Prometheus. Para obtener más detalles, consulte este artículo.

1. Descargar e instalar Prometheus MySQL Exporter

$curl -s https://api.github.com/repos/prometheus/mysqld_exporter/releases/latest   | grep browser_download_url   | grep linux-amd64 | cut -d '"' -f 4   | wget -qi -
$tar xvf mysqld_exporter*.tar.gz
$sudo mv  mysqld_exporter-*.linux-amd64/mysqld_exporter /usr/local/bin/
$sudo chmod +x /usr/local/bin/mysqld_exporter

2. Cree un usuario de la base de datos del exportador de Prometheus para acceder a la base de datos, raspar métricas y proporcionar subvenciones

CREATE USER 'mysqld_exporter'@'<PrometheusHostIP>' IDENTIFIED BY 'StrongPassword' WITH MAX_USER_CONNECTIONS 2;
GRANT PROCESS, REPLICATION CLIENT, SELECT ON *.* TO 'mysqld_exporter'@'<PrometheusHostIP>';
FLUSH PRIVILEGES;
EXIT

CON MAX_USER_CONNECTIONS 2 se utiliza para establecer un límite máximo de conexión para que el usuario evite sobrecargar el servidor con raspaduras de monitoreo bajo una carga pesada.

3. Configurar las credenciales de la base de datos

Edite el archivo de configuración del exportador en el host central:

$sudo vim /etc/.mysqld_exporter.cnf

Agregue el nombre de usuario y la contraseña del usuario creado y el servidor ScaleGrid MySQL que desea monitorear:

$sudo vim /etc/.mysqld_exporter.cnf

[client]
user=mysqld_exporter
password=StrongPassword
host=SG-mysqltestcluster-123456.servers.mongodirector.com

Establecer permisos de propiedad:

$sudo chown root:prometheus /etc/.mysqld_exporter.cnf

4. Crear archivo de unidad systemd

Cree un nuevo archivo de servicio en el host central:

$sudo vim /etc/systemd/system/mysql_exporter.service

Agregue el siguiente contenido:

 [Unit]
 Description=Prometheus MySQL Exporter
 After=network.target
 User=prometheus
 Group=prometheus

 [Service]
 Type=simple
 Restart=always
 ExecStart=/usr/local/bin/mysqld_exporter \
 --config.my-cnf /etc/.mysqld_exporter.cnf \
 --collect.global_status \
 --collect.info_schema.innodb_metrics \
 --collect.auto_increment.columns \
 --collect.info_schema.processlist \
 --collect.binlog_size \
 --collect.info_schema.tablestats \
 --collect.global_variables \
 --collect.info_schema.query_response_time \
 --collect.info_schema.userstats \
 --collect.info_schema.tables \
 --collect.perf_schema.tablelocks \
 --collect.perf_schema.file_events \
 --collect.perf_schema.eventswaits \
 --collect.perf_schema.indexiowaits \
 --collect.perf_schema.tableiowaits \
 --collect.slave_status \
 --web.listen-address=0.0.0.0:9104
 
 [Install]
 WantedBy=multi-user.target

web.listen-address=0.0.0.0:9104 especifica que el servidor está escuchando en el puerto 9104. Si su servidor tiene una red pública y una privada, es posible que deba reemplazar 0.0.0.0:9104 con una IP privada, por ejemplo:192.168.4.5:9104.

Cuando termine, vuelva a cargar systemd e inicie el servicio mysql_exporter:

$sudo systemctl daemon-reload
$sudo systemctl enable mysql_exporter
$sudo systemctl start mysql_exporter

5. Configure MySQL Endpoint para ser raspado por Prometheus

Haz cambios como los siguientes en el archivo prometheus.yml:

scrape_configs:
- job_name: mysql_server1
static_configs:
- targets: ['localhost:9104']
labels:
alias: db1

scrape_configs:
- job_name: mysql_server1
static_configs:
- targets: ['localhost:9104']
labels:
alias: db1
- job_name: mysql_server2
static_configs:
- targets: ['localhost:9105']
labels:
alias: db2
- job_name: mysql_server3
static_configs:
- targets: ['localhost:9106']
labels:
alias: db3

$wget <debian package url>
$sudo apt-get install -y adduser libfontconfig1
$sudo dpkg -i grafana_<version>_amd64.deb

$apt-get install -y software-properties-common

$sudo add-apt-repository "deb https://packages.grafana.com/oss/deb stable main"

$sudo add-apt-repository "deb https://packages.grafana.com/oss/deb beta main"

$wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -

$sudo apt-get update
$sudo apt-get install grafana

$systemctl daemon-reload
$systemctl start grafana-server
$systemctl status grafana-server

$sudo systemctl enable grafana-server.service