ARQUITECTURA DE MONITOREO PROMETHEUS + GRAFANA Objetivos node_exporter :9100 cAdvisor :8080 scrape Prometheus TSDB Storage PromQL Engine Alert Rules :9090 alertas Alertmanager :9093 consulta Grafana Dashboards Panels & Graphs Alert Contacts :3000 ver Navegador Paneles en tiempo real & Alertas

Saber lo que esta sucediendo en tus servidores no es opcional — es esencial. Ya sea que administres un solo VPS o una flota de maquinas de produccion, la visibilidad en tiempo real del uso de CPU, consumo de memoria, E/S de disco y trafico de red es lo que separa la gestion proactiva de infraestructura de apagar incendios. Prometheus y Grafana juntos forman el stack de monitoreo de codigo abierto mas ampliamente adoptado en la industria, potenciando la observabilidad en organizaciones desde startups hasta empresas.

Esta guia te lleva a traves del proceso completo: instalar Prometheus y node_exporter para recopilar metricas del sistema, configurar Grafana para visualizacion, escribir consultas PromQL, configurar alertas con Alertmanager y monitorear contenedores Docker con cAdvisor. Al final, tendras un stack de monitoreo completamente funcional ejecutandose en Ubuntu.

Requisitos Previos

Antes de comenzar, asegurate de tener:

  • Un servidor con Ubuntu 22.04 o 24.04 (edicion de escritorio o servidor)
  • Acceso a la terminal con privilegios sudo
  • Al menos 2 GB de RAM y 20 GB de espacio libre en disco
  • Puertos 9090 (Prometheus), 9100 (node_exporter), 3000 (Grafana) y 9093 (Alertmanager) disponibles
  • Familiaridad basica con la linea de comandos de Linux y sintaxis YAML
  • Docker instalado (opcional, para la seccion de cAdvisor) — consulta nuestra guia de instalacion de Docker

Nota: Todos los comandos en esta guia son para Ubuntu en la arquitectura amd64. Si estas ejecutando ARM64, ajusta las URLs de descarga para usar las variantes de binarios linux-arm64.

Que son Prometheus y Grafana?

Prometheus es un conjunto de herramientas de monitoreo y alertas de sistemas de codigo abierto, construido originalmente en SoundCloud en 2012. Recopila metricas raspando endpoints HTTP a intervalos regulares, las almacena en una base de datos de series temporales (TSDB) y proporciona un poderoso lenguaje de consulta llamado PromQL para analisis. Prometheus sigue un modelo basado en extraccion (pull) — activamente obtiene metricas de tus servidores en lugar de esperar a que los datos sean enviados.

Grafana es una plataforma de analisis y visualizacion interactiva de codigo abierto. Se conecta a fuentes de datos como Prometheus, Elasticsearch, InfluxDB y PostgreSQL para renderizar paneles de control en tiempo real con graficos, tablas, mapas de calor y alertas. Grafana no almacena datos por si mismo; consulta la fuente de datos subyacente bajo demanda.

Juntos, forman un pipeline de monitoreo completo:

  1. Exportadores (como node_exporter) exponen metricas en endpoints HTTP
  2. Prometheus raspa y almacena esas metricas
  3. Grafana consulta Prometheus y muestra los datos visualmente
  4. Alertmanager maneja las notificaciones cuando las metricas cruzan umbrales definidos

Vision General de la Arquitectura de Monitoreo

Entender el flujo de datos es critico antes de desplegar el stack:

┌─────────────────┐     scrape      ┌──────────────┐     query     ┌──────────────┐
│  node_exporter  │────────────────>│  Prometheus   │<─────────────│   Grafana    │
│  :9100          │  /metrics       │  :9090        │              │   :3000      │
└─────────────────┘                 │              │              │              │
                                    │  TSDB        │              │  Dashboards  │
┌─────────────────┐     scrape      │  PromQL      │              │  Panels      │
│  cAdvisor       │────────────────>│  Alert Rules  │              │  Alerts      │
│  :8080          │  /metrics       │              │              └──────────────┘
└─────────────────┘                 └──────┬───────┘
                                           │ fire alerts
                                    ┌──────▼───────┐
                                    │ Alertmanager  │──> Email / Slack / PagerDuty
                                    │ :9093         │
                                    └──────────────┘

Prometheus usa un modelo de extraccion (pull): periodicamente envia peticiones HTTP GET a los objetivos configurados (exportadores) para obtener las metricas mas recientes. Cada exportador expone un endpoint /metrics que devuelve datos en formato de exposicion de Prometheus. Esta arquitectura significa que los objetivos no necesitan saber sobre Prometheus — simplemente sirven sus metricas cuando se les solicita.

Instalacion de Prometheus

Comienza creando un usuario de sistema dedicado y los directorios necesarios:

sudo useradd --no-create-home --shell /bin/false prometheus
sudo mkdir -p /etc/prometheus /var/lib/prometheus
sudo chown prometheus:prometheus /var/lib/prometheus

Descarga la ultima version de Prometheus (consulta prometheus.io/download para la version actual):

cd /tmp
wget https://github.com/prometheus/prometheus/releases/download/v2.53.0/prometheus-2.53.0.linux-amd64.tar.gz
tar xvf prometheus-2.53.0.linux-amd64.tar.gz
cd prometheus-2.53.0.linux-amd64

Copia los binarios y archivos de configuracion:

sudo cp prometheus promtool /usr/local/bin/
sudo cp -r consoles console_libraries /etc/prometheus/
sudo cp prometheus.yml /etc/prometheus/
sudo chown -R prometheus:prometheus /etc/prometheus

Verifica la instalacion:

prometheus --version

Deberias ver una salida mostrando la version, fecha de compilacion y version de Go.

Configuracion de Prometheus

El archivo de configuracion principal es /etc/prometheus/prometheus.yml. Este archivo YAML define la configuracion global, intervalos de raspado y endpoints de destino.

Crea una configuracion limpia:

sudo nano /etc/prometheus/prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s
  scrape_timeout: 10s

alerting:
  alertmanagers:
    - static_configs:
        - targets:
            - localhost:9093

rule_files:
  - "alert_rules.yml"

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

  - job_name: "node"
    static_configs:
      - targets: ["localhost:9100"]

Parametros clave de configuracion:

  • scrape_interval: Con que frecuencia Prometheus raspa los objetivos (15 segundos es el valor recomendado por defecto)
  • evaluation_interval: Con que frecuencia Prometheus evalua las reglas de alertas
  • scrape_timeout: Tiempo maximo de espera para una respuesta de raspado antes de marcar el objetivo como caido
  • job_name: Una etiqueta aplicada a todas las metricas recopiladas de los objetivos en este grupo
  • static_configs: Una lista de endpoints de destino para raspar

Crea un archivo de servicio systemd para Prometheus:

sudo nano /etc/systemd/system/prometheus.service
[Unit]
Description=Prometheus Monitoring System
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.console.templates=/etc/prometheus/consoles \
  --web.console.libraries=/etc/prometheus/console_libraries \
  --storage.tsdb.retention.time=30d \
  --web.enable-lifecycle
ExecReload=/bin/kill -HUP $MAINPID
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target

Habilita e inicia Prometheus:

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

Prometheus deberia estar ejecutandose y accesible en http://ip-de-tu-servidor:9090.

Instalacion y Configuracion de node_exporter

node_exporter es el exportador estandar de Prometheus para metricas de hardware y nivel de sistema operativo. Expone estadisticas de CPU, memoria, disco, sistema de archivos y red en el puerto 9100.

Crea un usuario dedicado y descarga node_exporter:

sudo useradd --no-create-home --shell /bin/false node_exporter

cd /tmp
wget https://github.com/prometheus/node_exporter/releases/download/v1.8.1/node_exporter-1.8.1.linux-amd64.tar.gz
tar xvf node_exporter-1.8.1.linux-amd64.tar.gz
sudo cp node_exporter-1.8.1.linux-amd64/node_exporter /usr/local/bin/
sudo chown node_exporter:node_exporter /usr/local/bin/node_exporter

Crea el servicio systemd:

sudo nano /etc/systemd/system/node_exporter.service
[Unit]
Description=Prometheus Node Exporter
Wants=network-online.target
After=network-online.target

[Service]
User=node_exporter
Group=node_exporter
Type=simple
ExecStart=/usr/local/bin/node_exporter \
  --collector.systemd \
  --collector.processes
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target

Habilita e inicia node_exporter:

sudo systemctl daemon-reload
sudo systemctl enable node_exporter
sudo systemctl start node_exporter

Verifica que las metricas estan siendo expuestas:

curl -s http://localhost:9100/metrics | head -20

Deberias ver lineas que comienzan con # HELP y # TYPE seguidas de nombres de metricas y valores. Confirma que Prometheus esta raspando node_exporter navegando a http://ip-de-tu-servidor:9090/targets — el trabajo node deberia mostrar un estado de UP.

Instalacion de Grafana

Agrega el repositorio APT oficial de Grafana:

sudo apt-get install -y apt-transport-https software-properties-common 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

Instala e inicia Grafana:

sudo apt-get update
sudo apt-get install grafana -y
sudo systemctl daemon-reload
sudo systemctl enable grafana-server
sudo systemctl start grafana-server

Verifica que Grafana esta ejecutandose:

sudo systemctl status grafana-server

Grafana esta ahora accesible en http://ip-de-tu-servidor:3000. Las credenciales predeterminadas son admin / admin. Se te pedira cambiar la contrasena en el primer inicio de sesion.

Seguridad: Cambia la contrasena de administrador predeterminada inmediatamente. En produccion, configura Grafana detras de un proxy inverso con HTTPS.

Creacion de tu Primer Panel de Control

Despues de iniciar sesion en Grafana, agrega Prometheus como fuente de datos:

  1. Navega a Connections > Data Sources > Add data source
  2. Selecciona Prometheus
  3. Establece la URL a http://localhost:9090
  4. Haz clic en Save & Test — deberias ver “Successfully queried the Prometheus API”

Importa el ampliamente utilizado panel Node Exporter Full:

  1. Navega a Dashboards > New > Import
  2. Ingresa el ID del panel 1860 (Node Exporter Full por rfmoz)
  3. Selecciona tu fuente de datos Prometheus
  4. Haz clic en Import

Este panel proporciona paneles completos para uso de CPU, utilizacion de memoria, E/S de disco, trafico de red, uso del sistema de archivos y carga del sistema — todo sin escribir una sola consulta.

Para crear un panel personalizado:

  1. Haz clic en Add > Visualization en cualquier panel de control
  2. En el editor de consultas, ingresa una expresion PromQL como:
100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)
  1. Esto calcula el porcentaje de uso total de CPU
  2. Configura el titulo del panel, leyenda, umbrales y formato de unidad
  3. Haz clic en Apply para guardar el panel

Fundamentos de PromQL

PromQL (Prometheus Query Language) es un lenguaje de consulta funcional que te permite seleccionar, agregar y transformar datos de series temporales. Entender PromQL es esencial para construir paneles de control y reglas de alerta utiles.

Vectores instantaneos devuelven el valor mas reciente para cada serie temporal:

node_memory_MemAvailable_bytes

Vectores de rango devuelven valores sobre una ventana de tiempo:

node_cpu_seconds_total[5m]

rate() calcula la tasa promedio de incremento por segundo (esencial para contadores):

rate(node_cpu_seconds_total{mode="idle"}[5m])

Operadores de agregacion combinan multiples series temporales:

# Uso promedio de CPU en todos los nucleos
avg without(cpu) (rate(node_cpu_seconds_total{mode="idle"}[5m]))

# Memoria total en todas las instancias
sum by(instance) (node_memory_MemTotal_bytes)

# Top 5 instancias por uso de CPU
topk(5, 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100))

Operaciones matematicas permiten combinar metricas:

# Porcentaje de uso de memoria
(1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100

# Porcentaje de uso de disco
(1 - node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"}) * 100

Filtrado por etiquetas usa llaves:

# Filtrar por instancia especifica
node_cpu_seconds_total{instance="server1:9100", mode!="idle"}

# Coincidencia con regex
node_filesystem_avail_bytes{mountpoint=~"/|/home"}

Configuracion de Reglas de Alertas

Prometheus evalua las reglas de alertas al evaluation_interval definido en la configuracion global. Cuando se cumple una condicion de regla, Prometheus dispara una alerta a Alertmanager, que maneja la deduplicacion, agrupamiento y enrutamiento a canales de notificacion.

Crea un archivo de reglas de alerta:

sudo nano /etc/prometheus/alert_rules.yml
groups:
  - name: system_alerts
    rules:
      - alert: HighCPUUsage
        expr: 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Alto uso de CPU en {{ $labels.instance }}"
          description: "El uso de CPU esta por encima del 85% durante mas de 5 minutos (valor actual: {{ $value }}%)"

      - alert: HighMemoryUsage
        expr: (1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100 > 90
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Alto uso de memoria en {{ $labels.instance }}"
          description: "El uso de memoria esta por encima del 90% durante mas de 5 minutos (valor actual: {{ $value }}%)"

      - alert: DiskSpaceLow
        expr: (1 - node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"}) * 100 > 85
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "Poco espacio en disco en {{ $labels.instance }}"
          description: "El uso del sistema de archivos raiz esta por encima del 85% (valor actual: {{ $value }}%)"

      - alert: InstanceDown
        expr: up == 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "La instancia {{ $labels.instance }} esta caida"
          description: "{{ $labels.instance }} del trabajo {{ $labels.job }} ha estado caida durante mas de 2 minutos."

Valida el archivo de reglas:

promtool check rules /etc/prometheus/alert_rules.yml

Ahora instala Alertmanager:

cd /tmp
wget https://github.com/prometheus/alertmanager/releases/download/v0.27.0/alertmanager-0.27.0.linux-amd64.tar.gz
tar xvf alertmanager-0.27.0.linux-amd64.tar.gz

sudo useradd --no-create-home --shell /bin/false alertmanager
sudo mkdir -p /etc/alertmanager /var/lib/alertmanager
sudo cp alertmanager-0.27.0.linux-amd64/alertmanager /usr/local/bin/
sudo cp alertmanager-0.27.0.linux-amd64/amtool /usr/local/bin/
sudo chown alertmanager:alertmanager /usr/local/bin/alertmanager /usr/local/bin/amtool

Configura Alertmanager:

sudo nano /etc/alertmanager/alertmanager.yml
global:
  resolve_timeout: 5m

route:
  group_by: ['alertname', 'severity']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 4h
  receiver: 'email-notifications'

receivers:
  - name: 'email-notifications'
    email_configs:
      - to: 'admin@example.com'
        from: 'alertmanager@example.com'
        smarthost: 'smtp.example.com:587'
        auth_username: 'alertmanager@example.com'
        auth_password: 'your-app-password'
        require_tls: true

  - name: 'slack-notifications'
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/YOUR/WEBHOOK/URL'
        channel: '#alerts'
        send_resolved: true
        title: '{{ .GroupLabels.alertname }}'
        text: '{{ range .Alerts }}{{ .Annotations.description }}{{ end }}'

Crea el servicio systemd de Alertmanager:

sudo nano /etc/systemd/system/alertmanager.service
[Unit]
Description=Prometheus Alertmanager
Wants=network-online.target
After=network-online.target

[Service]
User=alertmanager
Group=alertmanager
Type=simple
ExecStart=/usr/local/bin/alertmanager \
  --config.file=/etc/alertmanager/alertmanager.yml \
  --storage.path=/var/lib/alertmanager/
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target
sudo systemctl daemon-reload
sudo systemctl enable alertmanager
sudo systemctl start alertmanager

Recarga Prometheus para que tome las nuevas reglas de alerta:

sudo systemctl restart prometheus

Verifica tus alertas en http://ip-de-tu-servidor:9090/alerts y revisa Alertmanager en http://ip-de-tu-servidor:9093.

Monitoreo de Contenedores Docker con cAdvisor

cAdvisor (Container Advisor) proporciona metricas de uso de recursos y rendimiento a nivel de contenedor. Se ejecuta como un contenedor Docker y expone metricas en formato Prometheus.

Inicia cAdvisor:

docker run -d \
  --name=cadvisor \
  --restart=always \
  --volume=/:/rootfs:ro \
  --volume=/var/run:/var/run:ro \
  --volume=/sys:/sys:ro \
  --volume=/var/lib/docker/:/var/lib/docker:ro \
  --volume=/dev/disk/:/dev/disk:ro \
  --publish=8080:8080 \
  --privileged \
  --device=/dev/kmsg \
  gcr.io/cadvisor/cadvisor:v0.49.1

Agrega cAdvisor como un objetivo de raspado de Prometheus en /etc/prometheus/prometheus.yml:

  - job_name: "cadvisor"
    static_configs:
      - targets: ["localhost:8080"]

Recarga Prometheus:

curl -X POST http://localhost:9090/-/reload

Consultas PromQL utiles para cAdvisor:

# Uso de CPU del contenedor
rate(container_cpu_usage_seconds_total{name!=""}[5m])

# Uso de memoria del contenedor
container_memory_usage_bytes{name!=""}

# Bytes recibidos por red del contenedor
rate(container_network_receive_bytes_total{name!=""}[5m])

# Uso de sistema de archivos del contenedor
container_fs_usage_bytes{name!=""}

Importa el panel de Grafana con ID 14282 (cAdvisor Exporter) para paneles de monitoreo de contenedores preconstruidos.

Referencia de Consultas PromQL Utiles

ConsultaDescripcion
upVerificar si los objetivos son alcanzables (1 = activo, 0 = caido)
rate(node_cpu_seconds_total{mode="idle"}[5m])Tasa de inactividad de CPU por nucleo
node_memory_MemAvailable_bytes / 1024 / 1024Memoria disponible en MB
(1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100Porcentaje de uso de memoria
rate(node_disk_read_bytes_total[5m])Rendimiento de lectura de disco
rate(node_disk_written_bytes_total[5m])Rendimiento de escritura de disco
rate(node_network_receive_bytes_total[5m])Trafico de red entrante
rate(node_network_transmit_bytes_total[5m])Trafico de red saliente
node_filesystem_avail_bytes{mountpoint="/"}Espacio de disco disponible en raiz
node_load1 / node_load5 / node_load15Promedios de carga del sistema
rate(node_cpu_seconds_total{mode="iowait"}[5m])Porcentaje de espera de E/S
node_time_seconds - node_boot_time_secondsTiempo de actividad del sistema en segundos
count(node_cpu_seconds_total{mode="idle"})Numero de nucleos de CPU
rate(container_cpu_usage_seconds_total{name!=""}[5m])Uso de CPU del contenedor

Solucion de Problemas

Prometheus no logra iniciar:

Verifica la sintaxis de la configuracion:

promtool check config /etc/prometheus/prometheus.yml

Revisa los logs del servicio:

sudo journalctl -u prometheus -f --no-pager

Los problemas comunes incluyen errores de indentacion YAML, intervalos de raspado invalidos y problemas de permisos de archivo en /var/lib/prometheus.

El objetivo aparece como DOWN en Prometheus:

Verifica que el exportador esta ejecutandose:

sudo systemctl status node_exporter
curl -v http://localhost:9100/metrics

Revisa el firewall:

sudo ufw status
sudo ufw allow 9100/tcp

Grafana no puede conectarse a Prometheus:

Asegurate de que Prometheus esta escuchando en la direccion correcta. Si Grafana y Prometheus estan en el mismo servidor, usa http://localhost:9090. Verifica la conectividad:

curl http://localhost:9090/api/v1/query?query=up

Sin datos en los paneles de Grafana:

Verifica el selector de rango de tiempo en el panel de control. El predeterminado puede estar fuera de tu ventana de retencion de datos. Tambien confirma que la fuente de datos Prometheus esta seleccionada en el editor de consultas del panel.

Alto uso de memoria por Prometheus:

Reduce el numero de series temporales limitando los exportadores o agregando reglas de reetiquetado de metricas. Verifica la memoria actual y el conteo de series:

curl http://localhost:9090/api/v1/status/tsdb

Considera reducir el tiempo de retencion:

--storage.tsdb.retention.time=15d

Alertmanager no envia notificaciones:

Prueba la configuracion de Alertmanager:

amtool check-config /etc/alertmanager/alertmanager.yml

Envia una alerta de prueba:

amtool alert add alertname=TestAlert severity=critical --alertmanager.url=http://localhost:9093

Resumen

Ahora tienes un stack de monitoreo completo ejecutandose en tu servidor: Prometheus recopilando metricas de node_exporter y cAdvisor, Grafana renderizando paneles de control en tiempo real, y Alertmanager entregando notificaciones cuando las cosas salen mal. Esta configuracion te da una visibilidad profunda sobre la salud del sistema, rendimiento de contenedores y utilizacion de recursos.

Puntos clave de esta guia:

  • Prometheus raspa metricas de los objetivos a intervalos regulares y las almacena en una base de datos de series temporales
  • node_exporter proporciona metricas a nivel de sistema (CPU, memoria, disco, red)
  • Grafana visualiza metricas con paneles de control y paneles personalizables
  • PromQL es el lenguaje de consulta para seleccionar, filtrar y agregar metricas
  • Alertmanager enruta alertas a correo electronico, Slack, PagerDuty u otros canales de notificacion
  • cAdvisor expone metricas de recursos a nivel de contenedor para entornos Docker

Para la base sobre la que se ejecuta este stack de monitoreo, asegurate de que tu servidor este correctamente asegurado siguiendo nuestra lista de verificacion de seguridad de servidores Linux. Si aun no has configurado Docker para la seccion de cAdvisor, sigue nuestra guia de instalacion de Docker en Ubuntu.

A medida que tu infraestructura crece, explora la federacion de Prometheus para configuraciones de multiples servidores, Grafana Loki para agregacion de logs, y Thanos o Cortex para almacenamiento a largo plazo y alta disponibilidad.