🎨 Sysprovider Code
Sysprovider LogoWiki
🇪🇸Hosting español para ecommerce

Monitorización Avanzada con Prometheus y Grafana en Entornos Linux

Actualizado el 3 de septiembre de 2025

Introducción a la Monitorización Avanzada

En el mundo del SysAdmin, la monitorización reactiva ya no es suficiente. Cuando gestionas decenas o cientos de servidores Linux, necesitas una visión proactiva que te permita anticipar cuellos de botella, detectar anomalías y escalar infraestructuras de forma inteligente. Aquí es donde entran en juego Prometheus y Grafana, un dúo que se ha convertido en el estándar de facto para la monitorización avanzada en entornos Linux.

Prometheus, con su modelo de recolección pull y su potente lenguaje de consulta (PromQL), se encarga de capturar y almacenar métricas de rendimiento en series temporales. Grafana, por su parte, transforma esos datos en paneles visuales interactivos y alertas accionables. Juntos, forman una plataforma robusta, escalable y de código abierto que todo administrador de sistemas debería dominar.

¿Por qué Prometheus y Grafana para Linux?

Aunque existen soluciones como Nagios, Zabbix o Datadog, Prometheus y Grafana destacan por varias razones clave:

  • Modelo Pull: Prometheus extrae métricas de los endpoints expuestos por los servicios, lo que simplifica la gestión de firewalls y reduce la carga en los nodos monitorizados.
  • Almacenamiento eficiente: Utiliza un formato de series temporales optimizado para consultas rápidas y retención de datos a largo plazo.
  • Lenguaje PromQL: Permite realizar cálculos complejos, agregaciones y predicciones sobre las métricas.
  • Integración nativa con Linux: Existen exporters para prácticamente cualquier componente del sistema: CPU, memoria, disco, red, procesos, logs, etc.
  • Alertas inteligentes: Con Alertmanager, puedes enrutar notificaciones a Slack, PagerDuty, correo electrónico y más, con reglas de supresión y silenciamiento.

[TIP] Si vienes de herramientas tradicionales como Nagios, piensa en Prometheus como un recolector de métricas en tiempo real, no como un sistema de chequeo de servicios. Para eso último, combínalo con Blackbox Exporter.

Arquitectura Básica de Monitorización

Antes de instalar nada, es crucial entender los componentes y cómo se relacionan:

  1. Prometheus Server: El corazón del sistema. Almacena las métricas, las consulta mediante PromQL y evalúa reglas de alerta.
  2. Exporters: Agentes ligeros que exponen métricas en formato /metrics. Los más comunes en Linux:
    • Node Exporter: Métricas del sistema (CPU, RAM, disco, red).
    • cAdvisor: Métricas de contenedores Docker.
    • Blackbox Exporter: Chequeo de endpoints HTTP, TCP, ICMP.
    • JMX Exporter: Para aplicaciones Java.
  3. Grafana: Visualización y dashboards. Se conecta a Prometheus como fuente de datos.
  4. Alertmanager: Gestiona las alertas generadas por Prometheus, aplica deduplicación y enrutamiento.

Instalación y Configuración en Linux

Paso 1: Instalar Prometheus

En una distribución basada en Debian/Ubuntu, puedes descargar el binario oficial o usar el repositorio de la comunidad. Recomendamos la instalación manual para tener control total:

# Crear usuario y directorios
sudo useradd --no-create-home --shell /bin/false prometheus
sudo mkdir /etc/prometheus /var/lib/prometheus

# Descargar la última versión (verificar en https://prometheus.io/download/)
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
sudo cp prometheus-2.53.0.linux-amd64/prometheus /usr/local/bin/
sudo cp prometheus-2.53.0.linux-amd64/promtool /usr/local/bin/
sudo cp -r prometheus-2.53.0.linux-amd64/consoles /etc/prometheus
sudo cp -r prometheus-2.53.0.linux-amd64/console_libraries /etc/prometheus

# Limpiar
rm -rf prometheus-2.53.0.linux-amd64*

Ahora crea el archivo de configuración /etc/prometheus/prometheus.yml:

global:
  scrape_interval: 15s
  evaluation_interval: 15s

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

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

[INFO] El scrape_interval define cada cuánto Prometheus recolecta métricas. Para entornos de producción, 15s es un buen equilibrio entre granularidad y carga.

Finalmente, crea un servicio systemd para que arranque automáticamente:

sudo tee /etc/systemd/system/prometheus.service > /dev/null <<EOF
[Unit]
Description=Prometheus
After=network.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

[Install]
WantedBy=multi-user.target
EOF

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

Paso 2: Instalar Node Exporter

Node Exporter es el exporter más importante para monitorizar Linux. Repite el proceso:

# Descargar e instalar
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/
rm -rf node_exporter-1.8.1.linux-amd64*

# Crear servicio systemd
sudo tee /etc/systemd/system/node_exporter.service > /dev/null <<EOF
[Unit]
Description=Node Exporter
After=network.target

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

[Install]
WantedBy=multi-user.target
EOF

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

Verifica que las métricas se están exponiendo:

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

Paso 3: Instalar Grafana

Grafana se instala desde el 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 daemon-reload
sudo systemctl enable grafana-server
sudo systemctl start grafana-server

Accede a http://tu-servidor:3000 con usuario admin y contraseña admin (cámbiala en el primer inicio).

Configuración de Dashboards y Métricas de Rendimiento

Crear fuente de datos

  1. En Grafana, ve a Configuration > Data Sources > Add data source.
  2. Selecciona Prometheus.
  3. En URL, escribe http://localhost:9090.
  4. Haz clic en Save & Test. Deberías ver un mensaje verde de éxito.

Importar un dashboard predefinido

Grafana tiene una comunidad enorme que comparte dashboards. Para monitorización básica de Linux, el Node Exporter Full (ID 1860) es perfecto:

  1. Ve a Dashboards > Import.
  2. Introduce el ID 1860 y haz clic en Load.
  3. Selecciona la fuente de datos Prometheus y haz clic en Import.

Ahora verás paneles con:

  • CPU: Uso por núcleo, promedio, temperatura.
  • Memoria: RAM usada, buffers, caché, swap.
  • Disco: IOPS, latencia, espacio usado.
  • Red: Tráfico entrante/saliente, errores, paquetes descartados.

Crear métricas personalizadas con PromQL

Supongamos que quieres monitorizar el porcentaje de uso de CPU en los últimos 5 minutos. En el panel de edición de Grafana, usa esta consulta:

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

Para memoria RAM disponible:

(node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100

[WARNING] Cuidado con las agregaciones. Si tienes múltiples servidores, usa avg by(instance) para no mezclar métricas. PromQL distingue mayúsculas y minúsculas.

Alertas Inteligentes con Alertmanager

La monitorización sin alertas es como un coche sin frenos. Prometheus evalúa reglas de alerta y envía notificaciones a través de Alertmanager.

Configurar reglas de alerta

Crea un archivo /etc/prometheus/alert-rules.yml:

groups:
  - name: linux_alerts
    rules:
      - alert: HighCPUUsage
        expr: 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "CPU alta en {{ $labels.instance }}"
          description: "El uso de CPU ha superado el 80% durante más de 5 minutos."

      - alert: DiskSpaceLow
        expr: (node_filesystem_avail_bytes{mountpoint="/",fstype!="tmpfs"} / node_filesystem_size_bytes{mountpoint="/",fstype!="tmpfs"}) * 100 < 10
        for: 2m
        labels:
          severity: warning
        annotations:
          summary: "Disco raíz bajo en {{ $labels.instance }}"
          description: "Queda menos del 10% de espacio en el disco raíz."

Luego, incluye este archivo en prometheus.yml:

rule_files:
  - "alert-rules.yml"

Reinicia Prometheus:

sudo systemctl restart prometheus

Configurar Alertmanager

Instala Alertmanager:

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 cp alertmanager-0.27.0.linux-amd64/alertmanager /usr/local/bin/
sudo cp alertmanager-0.27.0.linux-amd64/amtool /usr/local/bin/
sudo mkdir /etc/alertmanager
sudo cp alertmanager-0.27.0.linux-amd64/alertmanager.yml /etc/alertmanager/
rm -rf alertmanager-0.27.0.linux-amd64*

Edita /etc/alertmanager/alertmanager.yml para enviar alertas a Slack (ejemplo):

route:
  receiver: 'slack'

receivers:
  - name: 'slack'
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/TU/WEBHOOK/URL'
        channel: '#alerts'
        send_resolved: true

Crea el servicio systemd y arráncalo. Luego, en prometheus.yml, añade:

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

[TIP] Para probar alertas sin esperar, puedes forzar una condición (por ejemplo, llenar un archivo temporal) y verificar en la interfaz de Prometheus en http://localhost:9090/alerts.

Buenas Prácticas y Escalabilidad

Retención de datos

Por defecto, Prometheus almacena 15 días de métricas. Para entornos de producción, ajusta la retención:

--storage.tsdb.retention.time=30d
--storage.tsdb.retention.size=50GB

Federación y alta disponibilidad

Para monitorizar múltiples centros de datos, usa federación: un Prometheus central recolecta métricas de Prometheus periféricos. Configura en el central:

scrape_configs:
  - job_name: 'federate'
    scrape_interval: 15s
    honor_labels: true
    metrics_path: '/federate'
    params:
      'match[]':
        - '{job="node_exporter"}'
    static_configs:
      - targets:
        - 'prometheus-dc1:9090'
        - 'prometheus-dc2:9090'

Seguridad

  • Protege los endpoints de Prometheus y Grafana con autenticación básica o proxy inverso (Nginx).
  • Usa HTTPS en producción.
  • No expongas Node Exporter directamente a Internet; usa autenticación o redes internas.

Conclusión

La combinación de Prometheus y Grafana transforma la monitorización de servidores Linux de una tarea reactiva a una estrategia proactiva basada en datos. Con métricas de rendimiento en tiempo real, dashboards personalizables y alertas inteligentes, puedes garantizar la disponibilidad y el rendimiento de tu infraestructura.

Empieza con Node Exporter para métricas básicas, añade exporters específicos según tus necesidades (base de datos, colas, balanceadores) y escala con federación cuando tu entorno crezca. La comunidad de Prometheus es enorme, y los dashboards de Grafana te ahorrarán horas de trabajo.

[INFO] ¿Quieres profundizar? Explora PromQL con el simulador interactivo en https://promlabs.com/promql-cheat-sheet/. Y recuerda: la mejor alerta es la que nunca necesitas porque ya preveniste el problema.

¿Necesitas ayuda?Son dos de nuestros técnicos, Agustín y Mikel, y están disponibles para resolver cualquier problema.

Hablar con ellos ahora
Agustín y Mikel