Admin-Sistemas ·

Prometheus y Grafana: monitoriza tu VPS y recibe alertas antes de que pete

Descubrir que tu servidor se ha quedado sin disco porque los usuarios te lo dicen es la peor forma de monitorización que existe. Con Prometheus (recolección de métricas), Node Exporter (el agente del sistema) y Grafana (los dashboards) montas en una hora un sistema de observabilidad que te avisa en Telegram antes de que el problema llegue a los usuarios. Todo open source, todo en tu propio VPS.

1. Instala Prometheus

Prometheus no necesita instalación compleja: es un binario estático. Crea un usuario dedicado, descarga la última versión estable (revisa siempre la página de releases; en octubre de 2026 la rama estable es la 3.15.x) y móntalo como servicio:

# Usuario sin shell ni home, solo para Prometheus
useradd --no-create-home --shell /usr/sbin/nologin prometheus
mkdir -p /etc/prometheus /var/lib/prometheus

PROM_VERSION="3.15.0"
wget -q https://github.com/prometheus/prometheus/releases/download/v${PROM_VERSION}/prometheus-${PROM_VERSION}.linux-amd64.tar.gz
tar xzf prometheus-${PROM_VERSION}.linux-amd64.tar.gz
cd prometheus-${PROM_VERSION}.linux-amd64
cp prometheus promtool /usr/local/bin/
chown -R prometheus:prometheus /etc/prometheus /var/lib/prometheus
chown prometheus:prometheus /usr/local/bin/prometheus /usr/local/bin/promtool

Ahora la configuración en /etc/prometheus/prometheus.yml. Definimos dos jobs: Prometheus a sí mismo y el Node Exporter (puerto 9100), más la conexión con Alertmanager (puerto 9093), que veremos en el paso 4:

global:
  scrape_interval: 15s
  evaluation_interval: 15s

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

rule_files:
  - "/etc/prometheus/alerts/*.yml"

scrape_configs:
  - job_name: "prometheus"
    static_configs:
      - targets: ["localhost:9090"]
  - job_name: "node"
    static_configs:
      - targets: ["localhost:9100"]

Y el servicio systemd en /etc/systemd/system/prometheus.service:

[Unit]
Description=Prometheus
Wants=network-online.target
After=network-online.target

[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/prometheus \
  --config.file=/etc/prometheus/prometheus.yml \
  --storage.tsdb.path=/var/lib/prometheus \
  --web.enable-lifecycle
ExecReload=/bin/kill -HUP $MAINPID
Restart=always

[Install]
WantedBy=multi-user.target

Antes de arrancar, valida siempre la configuración con promtool check config /etc/prometheus/prometheus.yml. Si sale SUCCESS, habilita y arranca:

promtool check config /etc/prometheus/prometheus.yml
systemctl daemon-reload
systemctl enable --now prometheus
curl -s http://localhost:9090/api/v1/status/config | head -c 200

2. Node Exporter: las métricas del sistema

Node Exporter expone CPU, memoria, disco, red y temperaturas en formato que Prometheus entiende. En Debian/Ubuntu va directo por apt:

apt update && apt install -y prometheus-node-exporter
systemctl enable --now prometheus-node-exporter
curl -s http://localhost:9100/metrics | grep -E '^node_cpu_seconds_total' | head -2

En Status → Targets de Prometheus (http://localhost:9090) deberías ver los dos jobs en estado UP. Prueba tu primera consulta PromQL en la pestaña Graph: 100 - (avg by (instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) te da el porcentaje de CPU usada. Ya tienes datos históricos con retención de 15 días por defecto.

3. Grafana: del dato al gráfico

Grafana convierte esas métricas en dashboards. Instálalo desde el repositorio oficial para tener siempre la versión reciente (la rama 13.x es la estable actual):

sudo apt install -y apt-transport-https ca-certificates wget
sudo mkdir -p /etc/apt/keyrings/
wget -q -O - https://apt.grafana.com/gpg.key | gpg --dearmor | sudo tee /etc/apt/keyrings/grafana.gpg > /dev/null
echo "deb [signed-by=/etc/apt/keyrings/grafana.gpg] https://apt.grafana.com stable main" | sudo tee /etc/apt/sources.list.d/grafana.list
sudo apt update && sudo apt install -y grafana
sudo systemctl enable --now grafana-server

Abre http://IP-del-servidor:3000 (usuario admin / admin, te pide cambiarla) y añade Prometheus como data source con URL http://localhost:9090. El atajo más rápido para tener un panel serio: importa el dashboard 1860 (“Node Exporter Full”) desde Dashboards → Import. En minutos tienes CPU, memoria, disco, red y temperatura en un solo vistazo.

Panel frontal de un switch con LEDs de actividad verdes y cables de red de colores

No expongas el puerto 3000 a internet sin protección. Lo recomendable es servir Grafana detrás de nginx con HTTPS y cabeceras de seguridad, como se explicó en el artículo sobre nginx blindado de esta misma web.

4. Alertas que avisan antes del desastre

Monitorizar sin alertas es mirar gráficas por hobby. Alertmanager recibe las alertas que Prometheus evalúa y las reenvía a Telegram, email o Slack. Dos piezas:

a) Regla en Prometheus (/etc/prometheus/alerts/sistema.yml):

groups:
  - name: sistema
    rules:
      - alert: DiscoLleno
        expr: (node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"}) < 0.10
        for: 10m
        labels:
          severity: critical
        annotations:
          summary: "Disco casi lleno en {{ $labels.instance }} (queda menos del 10%)"

      - alert: MemoriaCritica
        expr: (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) < 0.10
        for: 10m
        labels:
          severity: critical
        annotations:
          summary: "Memoria disponible por debajo del 10% en {{ $labels.instance }}"

      - alert: CaidaDeServicio
        expr: up == 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "El job {{ $labels.job }} ha dejado de responder"

b) Alertmanager con Telegram (/etc/alertmanager/alertmanager.yml; descarga el binario desde la página de releases de Alertmanager igual que Prometheus):

global:
  telegram_api_url: "https://api.telegram.org"
route:
  receiver: telegram
receivers:
  - name: telegram
    telegram_configs:
      - bot_token: "<TU_BOT_TOKEN>"
        chat_id: <TU_CHAT_ID>
        send_resolved: true

Crea el bot con @BotFather, obtén el chat_id enviándole un mensaje y consultando https://api.telegram.org/bot<TU_BOT_TOKEN>/getUpdates, y recarga Prometheus con curl -X POST http://localhost:9090/-/reload. Desde ese momento, un disco lleno te llega al móvil antes de que Tumbe el servicio.

Checklist final

Paso Verificación
Prometheus corre systemctl is-active prometheus → active
Targets en UP http://localhost:9090/targets
Node Exporter expone métricas curl -s localhost:9100/metrics devuelve datos
Grafana con dashboard 1860 Visible en el puerto 3000
Alertas configuradas http://localhost:9090/alerts muestra las reglas
Aviso en Telegram Dispara una alerta de prueba bajando un umbral

Con esto dejas de ser el último en enterarte de tus propios problemas. El siguiente nivel natural: añadir el exporter de nginx o de PostgreSQL y centralizar las alertas de varios servidores en un solo Prometheus.