Monitorización con Prometheus y Grafana: Guía 2025-2026

Introducción a la Monitorización Moderna

En el mundo de la infraestructura moderna, donde los servicios se ejecutan en contenedores, clústeres de Kubernetes o máquinas virtuales efímeras, la monitorización ya no es un lujo, sino una necesidad absoluta. Sin un sistema de alertas y métricas adecuado, cualquier administrador de sistemas (SysAdmin) opera a ciegas. Aquí es donde entran en juego dos herramientas que se han convertido en el estándar de facto: Prometheus para la recolección y almacenamiento de métricas, y Grafana para la visualización y análisis de esas métricas.

Este artículo cubre desde los fundamentos hasta la configuración avanzada de un stack de monitorización completo, incluyendo la gestión de alertas, todo ello con ejemplos prácticos y configuración real.

¿Qué es Prometheus?

Prometheus es un sistema de monitorización y alerta de código abierto, diseñado originalmente en SoundCloud y ahora parte de la Cloud Native Computing Foundation (CNCF). A diferencia de soluciones tradicionales como Nagios o Zabbix, Prometheus utiliza un modelo de extracción (pull) en lugar de envío (push). Esto significa que Prometheus "raspa" (scrape) las métricas de los endpoints expuestos por las aplicaciones o servicios.

Características clave de Prometheus

Modelo de datos multidimensional: Las métricas se almacenan con etiquetas (labels) que permiten realizar consultas muy flexibles.
Lenguaje de consulta PromQL: Potente y expresivo para agregar y filtrar datos.
Almacenamiento local eficiente: Utiliza un formato de serie temporal (TSDB) optimizado.
Alertmanager integrado: Permite definir reglas de alerta y enviar notificaciones a múltiples canales (Slack, PagerDuty, correo, etc.).
Ecosistema de exportadores: Existen exportadores para casi cualquier servicio (Node Exporter, MySQL Exporter, Nginx Exporter, etc.).

¿Qué es Grafana?

Grafana es una plataforma de análisis y visualización de métricas. Permite crear dashboards interactivos a partir de múltiples fuentes de datos, siendo Prometheus una de las más comunes. Grafana no almacena datos por sí mismo; actúa como un frontend que consulta las fuentes de datos y dibuja gráficos, tablas y alertas visuales.

Características clave de Grafana

Paneles personalizables: Arrastra y suelta paneles para crear dashboards a medida.
Múltiples fuentes de datos: Además de Prometheus, soporta InfluxDB, Elasticsearch, Graphite, CloudWatch, etc.
Alertas visuales: Crea reglas de alerta directamente desde los paneles.
Anotaciones: Marca eventos importantes (despliegues, picos de tráfico) en las gráficas.
Autenticación y roles: Control de acceso basado en equipos.

Instalación del Stack de Monitorización

Vamos a instalar Prometheus y Grafana en un servidor Linux (Ubuntu 22.04). También instalaremos el Node Exporter para recolectar métricas del sistema.

Instalación de Prometheus

Primero, creamos un usuario y descargamos la última versión estable.

sudo useradd --no-create-home --shell /bin/false prometheus
wget https://github.com/prometheus/prometheus/releases/download/v2.45.0/prometheus-2.45.0.linux-amd64.tar.gz
tar xvf prometheus-2.45.0.linux-amd64.tar.gz
sudo mv prometheus-2.45.0.linux-amd64 /etc/prometheus
sudo chown -R prometheus:prometheus /etc/prometheus

Creamos un archivo de configuración básico /etc/prometheus/prometheus.yml:

global:
  scrape_interval: 15s

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

  - job_name: 'node_exporter'
    static_configs:
      - targets: ['localhost:9100']

Luego creamos un servicio systemd para Prometheus:

[Unit]
Description=Prometheus
After=network.target

[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/etc/prometheus/prometheus --config.file=/etc/prometheus/prometheus.yml --storage.tsdb.path=/var/lib/prometheus/
Restart=always

[Install]
WantedBy=multi-user.target

Iniciamos y habilitamos el servicio:

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

Instalación de Node Exporter

Node Exporter expone métricas del sistema operativo (CPU, RAM, disco, red).

wget https://github.com/prometheus/node_exporter/releases/download/v1.6.0/node_exporter-1.6.0.linux-amd64.tar.gz
tar xvf node_exporter-1.6.0.linux-amd64.tar.gz
sudo mv node_exporter-1.6.0.linux-amd64/node_exporter /usr/local/bin/

Creamos un servicio systemd similar:

[Unit]
Description=Node Exporter
After=network.target

[Service]
User=node_exporter
Group=node_exporter
Type=simple
ExecStart=/usr/local/bin/node_exporter
Restart=always

[Install]
WantedBy=multi-user.target

Iniciamos y verificamos que expone métricas en http://localhost:9100/metrics.

Instalación de Grafana

Grafana se instala desde su repositorio oficial:

sudo apt-get install -y software-properties-common
sudo add-apt-repository "deb https://packages.grafana.com/oss/deb stable main"
wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -
sudo apt-get update
sudo apt-get install grafana
sudo systemctl start grafana-server
sudo systemctl enable grafana-server

Accede a http://localhost:3000 con usuario admin y contraseña admin (se te pedirá cambiarla).

Configuración de Fuentes de Datos en Grafana

Una vez dentro de Grafana, debemos añadir Prometheus como fuente de datos.

Ve a Configuration > Data Sources > Add data source.
Selecciona Prometheus.
En URL, introduce http://localhost:9090.
Haz clic en Save & Test.

Si todo está correcto, verás un mensaje verde de éxito.

Creación de Dashboards y Consultas con PromQL

Grafana viene con dashboards predefinidos, pero vamos a crear uno personalizado para monitorizar una máquina Linux.

Añadir un panel de uso de CPU

Crea un nuevo dashboard: + > Dashboard > Add new panel.
En la pestaña Query, escribe la siguiente consulta PromQL:

100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

Esta consulta calcula el porcentaje de CPU utilizado. El rate calcula la tasa por segundo de tiempo idle, y lo restamos de 100.

En Visualization, selecciona Gauge o Stat para un solo valor, o Time series para ver la evolución.
Ajusta el título, las unidades (porcentaje) y los umbrales (por ejemplo, verde < 80, amarillo 80-90, rojo > 90).

Añadir un panel de uso de memoria RAM

Consulta PromQL para memoria usada en porcentaje:

(1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) * 100

Añadir un panel de espacio en disco

(node_filesystem_size_bytes{mountpoint="/"} - node_filesystem_free_bytes{mountpoint="/"}) / node_filesystem_size_bytes{mountpoint="/"} * 100

Configuración de Alertas

La monitorización sin alertas es como tener un perro guardián que no ladra. Prometheus incluye un componente llamado Alertmanager que gestiona las notificaciones.

Instalación y configuración de Alertmanager

Descargamos e instalamos Alertmanager:

wget https://github.com/prometheus/alertmanager/releases/download/v0.25.0/alertmanager-0.25.0.linux-amd64.tar.gz
tar xvf alertmanager-0.25.0.linux-amd64.tar.gz
sudo mv alertmanager-0.25.0.linux-amd64 /etc/alertmanager

Creamos un archivo de configuración /etc/alertmanager/alertmanager.yml para enviar alertas a un canal de Slack (ejemplo):

global:
  slack_api_url: 'https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX'

route:
  receiver: 'slack-notifications'

receivers:
- name: 'slack-notifications'
  slack_configs:
  - channel: '#alerts'
    send_resolved: true

Luego, en el archivo de Prometheus (prometheus.yml), añadimos la sección rule_files y la configuración de Alertmanager:

rule_files:
  - "alerts.yml"

alerting:
  alertmanagers:
  - static_configs:
    - targets: ['localhost:9093']

Creamos el archivo /etc/prometheus/alerts.yml con reglas de ejemplo:

groups:
- name: node_alerts
  rules:
  - alert: HighCPUUsage
    expr: 100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "CPU usage above 80% on {{ $labels.instance }}"
      description: "CPU usage is at {{ $value }}% for more than 5 minutes."

  - alert: DiskSpaceLow
    expr: (node_filesystem_size_bytes{mountpoint="/"} - node_filesystem_free_bytes{mountpoint="/"}) / node_filesystem_size_bytes{mountpoint="/"} * 100 > 90
    for: 10m
    labels:
      severity: critical
    annotations:
      summary: "Disk space low on {{ $labels.instance }}"
      description: "Disk usage is at {{ $value }}% on mountpoint /."

[TIP] Ajusta los umbrales según tus necesidades. Para entornos de producción, considera umbrales más conservadores (70% para CPU, 80% para disco).

Reiniciamos Prometheus y Alertmanager:

sudo systemctl restart prometheus
sudo systemctl start alertmanager

Ahora, si la CPU supera el 80% durante 5 minutos, recibirás una alerta en Slack.

Buenas Prácticas y Recomendaciones

1. Etiquetado consistente

Usa etiquetas descriptivas en tus métricas. Por ejemplo, job, instance, service, env. Esto facilita las consultas y la agregación.

2. No sobrecargues el scrape

Ajusta el scrape_interval según la criticidad. Para métricas de infraestructura, 15-30 segundos es suficiente. Para métricas de aplicaciones de alta frecuencia, reduce a 5-10 segundos.

3. Usa dashboards predefinidos

Grafana tiene una biblioteca de dashboards oficiales. Busca "Node Exporter Full" o "Prometheus 2.0 Stats" para empezar rápidamente.

4. Monitoriza el propio monitor

Asegúrate de que Prometheus y Grafana estén monitorizados. Puedes usar el propio Node Exporter o exportadores específicos.

5. Alertas con sentido

No crees alertas para todo. Prioriza las que realmente requieren acción humana. Usa for para evitar falsos positivos por picos momentáneos.

[WARNING] No configures alertas para métricas que no entiendes completamente. Una alerta mal diseñada puede generar ruido y hacer que el equipo ignore las alertas reales.

Conclusión

La combinación de Prometheus y Grafana ofrece una solución de monitorización potente, escalable y flexible. Con Prometheus recolectando métricas mediante un modelo de extracción y Grafana visualizándolas en dashboards interactivos, cualquier SysAdmin puede tener visibilidad total de su infraestructura. Además, la integración con Alertmanager permite reaccionar rápidamente ante problemas.

Este stack es la base de la monitorización moderna en entornos cloud-native, pero también funciona perfectamente en servidores tradicionales. Empieza con Node Exporter para métricas del sistema y luego añade exportadores para tus servicios específicos (MySQL, Nginx, Redis, etc.). Con el tiempo, podrás crear dashboards complejos que te den una visión de 360 grados de tu infraestructura.

Recuerda: no puedes gestionar lo que no puedes medir. Con Prometheus y Grafana, tendrás todas las métricas que necesitas para tomar decisiones informadas y mantener tus sistemas funcionando sin problemas.