Monitorizar servidores con Prometheus, Node Exporter y Grafana

En este laboratorio monto una monitorización básica de infraestructura: Prometheus recoge las métricas, Node Exporter las expone en cada máquina y Grafana las muestra en un panel sencillo con alertas. Todo con Docker Compose, para que podáis levantarlo en pocos minutos.

¿Qué es Prometheus?

Prometheus es un software de monitorización. Las métricas que recoge ayudan a diagnosticar errores o problemas en los sistemas y aplicaciones que se monitorizan.

¿Qué es Node Exporter?

Node Exporter expone una gran variedad de métricas del hardware y del kernel: por ejemplo, el tiempo que lleva encendida la instancia (uptime) o el uso de disco, CPU y memoria.

Laboratorio

Instalar Grafana

Lo primero es tener un espacio de Grafana. Si aún no lo tenéis, seguid la guía oficial de instalación de Grafana (en inglés).

Configurar Prometheus

Preparad el archivo de configuración prometheus.yml e indicad todas las instancias que queréis monitorizar:

1. Sustituid job_name por el nombre de vuestra instancia.
2. Sustituid targets por la dirección IP de la instancia que queréis monitorizar.
3. Sustituid replacement por el nombre que queréis que aparezca en Grafana.

global:
  scrape_interval: 1m

scrape_configs:
  - job_name: "Instance1"
    static_configs:
    - targets: ["127.0.0.1:9100"]
    relabel_configs:
    - source_labels: [__address__]
      regex: '.*'
      target_label: instance
      replacement: 'instance1'

  - job_name: "Instance2"
    static_configs:
    - targets: ["127.0.0.2:9100"]
    relabel_configs:
    - source_labels: [__address__]
      regex: '.*'
      target_label: instance
      replacement: 'instance2'

Instalad Prometheus con Docker Compose en la instancia. El docker-compose.yml tiene que estar en la misma carpeta que el archivo de configuración anterior. Tendréis que abrir el puerto 9090 de la máquina para aceptar tráfico.

services:
    prometheus:
        image: prom/prometheus:latest
        container_name: prometheus
        user: root
        restart: unless-stopped
        volumes:
        - ./prometheus.yml:/etc/prometheus/prometheus.yml
        - ./prometheus_data:/prometheus
        command:
        - '--config.file=/etc/prometheus/prometheus.yml'
        - '--storage.tsdb.path=/prometheus'
        - '--web.console.libraries=/etc/prometheus/console_libraries'
        - '--web.console.templates=/etc/prometheus/consoles'
        - '--web.enable-lifecycle'
        ports:
        - 9090:9090

Origen de datos en Grafana

Ahora configurad el origen de datos (data source) en vuestro Grafana. En el campo URL escribid el endpoint de Prometheus, http://$IP_Address:9090, sustituyendo $IP_Address por la dirección pública o privada del servidor donde tenéis Prometheus.

Configurar Node Exporter

Entrad en la máquina que queréis monitorizar e instalad el servicio Node Exporter con Docker Compose. Tendréis que abrir el puerto 9100 de la máquina para aceptar tráfico.

services:
    node-exporter:
        image: prom/node-exporter:latest
        container_name: node-exporter
        user: root
        restart: unless-stopped
        volumes:
        - /proc:/host/proc:ro
        - /sys:/host/sys:ro
        - /:/rootfs:ro
        command:
        - '--path.procfs=/host/proc'
        - '--path.rootfs=/rootfs'
        - '--path.sysfs=/host/sys'
        - '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)'
        ports:
        - 9100:9100

Crear el panel en Grafana

Cread un panel (dashboard) sencillo en Grafana para ver las métricas básicas, con cuatro paneles. En todos, la leyenda es la misma:

{{instance}}

Uptime (días encendida):

(time() - node_boot_time_seconds) / 86400

Uso de disco (%):

100 - (100 * ((node_filesystem_avail_bytes{mountpoint="/",fstype!="rootfs"}) / (node_filesystem_size_bytes{mountpoint="/",fstype!="rootfs"})))

Uso de CPU (%):

(1 - avg by (instance) (irate(node_cpu_seconds_total{mode="idle"}[10m]))) * 100

Uso de memoria (%):

100 * (1 - ((avg_over_time(node_memory_MemFree_bytes[10m]) + avg_over_time(node_memory_Cached_bytes[10m]) + avg_over_time(node_memory_Buffers_bytes[10m])) / avg_over_time(node_memory_MemTotal_bytes[10m])))

Alertas en Grafana

1. Cread un punto de contacto (contact point) y elegid el tipo: correo, Slack, Discord…
2. Entrad en los paneles que acabáis de crear y configurad una regla de alerta nueva, enviando las notificaciones a ese punto de contacto.
3. Configurad en cada alerta los límites que marcan el problema.

Las capturas son de cuando escribí el artículo, con el sistema de alertas antiguo de Grafana; en las versiones actuales se configura desde Alerting, con reglas de alerta y puntos de contacto, pero la idea es la misma: una condición sobre la consulta del panel y un destino para el aviso.

Si queréis ir más allá de este laboratorio, en monitorización con Grafana y Prometheus explico cómo lo monto y lo mantengo en producción, y en observabilidad cómo lo amplío con logs, trazas y alertas que no despiertan a nadie sin motivo. Si queréis que revise la vuestra, escribidme desde contacto.

Publicado originalmente en inglés en Medium.