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

Monitorización con Prometheus, Grafana y Loki

Actualizado el 28 de diciembre de 2025

Imagina gestionar un clúster de servidores Linux sin visibilidad alguna sobre su estado. Los servicios se degradan lentamente, el disco se llena y nadie se entera hasta que el sistema colapsa. Este es el escenario que todo sysadmin quiere evitar. Para ello, el stack moderno de observabilidad se ha consolidado en torno a tres herramientas: Prometheus para la recolección de métricas, Grafana para la visualización y Loki para la agregación de logs. En este artículo, exploraremos cómo implementar y configurar este trío para lograr una monitorización con Prometheus, Grafana y Loki que te permita dormir tranquilo.

La combinación de estas herramientas no solo te da visibilidad en tiempo real, sino que establece la base para un sistema de alertas proactivo. A lo largo de este texto, veremos desde la instalación en un entorno Linux hasta la creación de dashboards y reglas de alerta avanzadas. Prepárate para transformar tu infraestructura en un sistema autogestionado y resiliente.

¿Por qué este stack es la opción ganadora para SysAdmins?

Antes de sumergirnos en la configuración, es crucial entender por qué Prometheus, Grafana y Loki forman el trío más potente para la monitorización Linux. No se trata solo de moda; cada herramienta resuelve un problema específico de manera eficiente.

Prometheus se ha convertido en el estándar de facto para la recolección de métricas. Su modelo de datos multidimensional (basado en etiquetas) y su potente lenguaje de consulta (PromQL) permiten a los sysadmins analizar el rendimiento del sistema con una granularidad asombrosa. A diferencia de soluciones como Nagios o Zabbix, Prometheus está diseñado para entornos dinámicos y contenerizados, aunque funciona de maravilla en servidores bare metal.

Grafana, por su parte, es el lienzo donde pintamos esos datos. Su capacidad para conectar múltiples fuentes (Prometheus, Loki, bases de datos SQL, etc.) la convierte en la interfaz única de observabilidad. La comunidad de Grafana ofrece miles de dashboards preconstruidos para Linux, NGINX, PostgreSQL y más, lo que acelera drásticamente la implementación.

Loki completa el círculo al centralizar los logs. A diferencia de Elasticsearch, Loki está optimizado para trabajar con Prometheus: no indexa el contenido completo del log, sino las etiquetas. Esto lo hace increíblemente eficiente en almacenamiento y permite correlacionar métricas y logs con un simple clic desde Grafana.

[INFO] Este stack es especialmente potente porque Prometheus y Loki comparten el mismo modelo de etiquetas. Puedes saltar de una métrica de alta CPU (Prometheus) al log del proceso culpable (Loki) sin cambiar de contexto.

Instalación y configuración inicial en un servidor Linux

Vamos a asumir que trabajamos sobre un servidor Ubuntu 22.04 LTS o similar. La instalación puede hacerse desde paquetes, binarios o Docker. Para un entorno de producción, recomiendo usar los binarios oficiales o los repositorios de Grafana.

Instalando Prometheus

Primero, creamos un usuario dedicado 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.50.1/prometheus-2.50.1.linux-amd64.tar.gz
tar xvf prometheus-*.tar.gz
sudo cp prometheus-2.50.1.linux-amd64/{prometheus,promtool} /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/prometheus

Creamos los directorios de configuración y datos:

sudo mkdir -p /etc/prometheus /var/lib/prometheus
sudo cp -r prometheus-2.50.1.linux-amd64/{consoles,console_libraries} /etc/prometheus/
sudo chown -R prometheus:prometheus /etc/prometheus /var/lib/prometheus

El archivo de configuración principal (/etc/prometheus/prometheus.yml) debe incluir al menos un job para monitorizar el propio servidor:

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']

Para monitorizar el sistema Linux en profundidad, necesitamos Node Exporter. Lo instalamos de forma similar:

wget https://github.com/prometheus/node_exporter/releases/download/v1.7.0/node_exporter-1.7.0.linux-amd64.tar.gz
tar xvf node_exporter-*.tar.gz
sudo cp node_exporter-1.7.0.linux-amd64/node_exporter /usr/local/bin/
sudo useradd --no-create-home --shell /bin/false node_exporter
sudo chown node_exporter:node_exporter /usr/local/bin/node_exporter

Configuramos ambos como servicios systemd para que inicien automáticamente. Crea los archivos en /etc/systemd/system/:

[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.console.templates=/etc/prometheus/consoles \
  --web.console.libraries=/etc/prometheus/console_libraries

[Install]
WantedBy=multi-user.target

Recarga systemd y habilita los servicios:

sudo systemctl daemon-reload
sudo systemctl enable --now prometheus node_exporter

Verifica que Prometheus responde en http://localhost:9090.

Instalando Grafana

Grafana se instala fácilmente desde su repositorio oficial:

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

Accede a http://localhost:3000 con usuario admin y contraseña admin. Lo primero que debes hacer es añadir una fuente de datos Prometheus apuntando a http://localhost:9090.

[TIP] Para entornos productivos, cambia la contraseña por defecto de Grafana inmediatamente y configura HTTPS con un proxy inverso como Nginx.

Instalando Loki y Promtail

Loki necesita un backend de almacenamiento (puede ser local o S3). Para pruebas, usaremos almacenamiento local en el sistema de archivos.

Descargamos Loki y Promtail (el agente recolector de logs):

wget https://github.com/grafana/loki/releases/download/v2.9.4/loki-linux-amd64.zip
unzip loki-linux-amd64.zip
sudo mv loki-linux-amd64 /usr/local/bin/loki
sudo chmod +x /usr/local/bin/loki

Creamos un archivo de configuración para Loki (/etc/loki/loki-config.yaml):

auth_enabled: false

server:
  http_listen_port: 3100

ingester:
  lifecycler:
    address: 127.0.0.1
    ring:
      kvstore:
        store: inmemory
    final_sleep: 0s
  chunk_idle_period: 5m
  chunk_retain_period: 30s

schema_config:
  configs:
    - from: 2020-10-24
      store: boltdb-shipper
      object_store: filesystem
      schema: v11
      index:
        prefix: index_
        period: 24h

storage_config:
  boltdb_shipper:
    active_index_directory: /var/lib/loki/index
    cache_location: /var/lib/loki/cache
    shared_store: filesystem
  filesystem:
    directory: /var/lib/loki/chunks

compactor:
  working_directory: /var/lib/loki/compactor

Creamos el usuario y directorios, y configuramos el servicio systemd de forma análoga a Prometheus.

Para Promtail, la configuración es similar. El archivo /etc/promtail/promtail-config.yaml debe especificar qué logs leer y enviar a Loki:

server:
  http_listen_port: 9080

positions:
  filename: /var/lib/promtail/positions.yaml

clients:
  - url: http://localhost:3100/loki/api/v1/push

scrape_configs:
  - job_name: system
    static_configs:
      - targets:
          - localhost
        labels:
          job: varlogs
          __path__: /var/log/*.log

[WARNING] Asegúrate de que los permisos de los archivos de log permitan la lectura a Promtail. Si usas logs rotados (logrotate), configura Promtail para que maneje correctamente la rotación usando inotify o polling.

Creando dashboards y alertas efectivas

Una vez que las métricas y logs fluyen, es hora de construir dashboards que realmente aporten valor. No se trata de llenar pantallas de gráficos, sino de crear vistas accionables.

Dashboard básico de monitorización Linux

En Grafana, importa el dashboard oficial Node Exporter Full (ID 1860) desde la comunidad. Este dashboard te dará una visión completa de CPU, memoria, disco, red y procesos. Sin embargo, recomiendo personalizarlo para tu entorno:

  • Métrica clave: node_cpu_seconds_total para CPU.
  • Alerta visual: Usa medidores de gauge para la memoria RAM y swap.
  • Tendencias: Gráficos de área apilada para el uso de disco por partición.

Añade una fila específica para logs en vivo usando Loki. Crea un panel con la consulta {job="varlogs"} |= "error" para ver en tiempo real los errores del sistema.

Configuración de alertas en Prometheus

Las alertas se definen en Prometheus mediante reglas. Crea un archivo /etc/prometheus/alert-rules.yml:

groups:
  - name: linux_alerts
    rules:
      - alert: HighCPULoad
        expr: 100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "CPU alta en {{ $labels.instance }}"
          description: "La CPU ha estado por encima del 80% durante más de 5 minutos."

      - alert: DiskSpaceLow
        expr: (node_filesystem_avail_bytes{mountpoint="/",fstype!="tmpfs"} / node_filesystem_size_bytes{mountpoint="/"}) * 100 < 10
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Espacio en disco crítico en {{ $labels.instance }}"

Integra este archivo en el prometheus.yml principal:

rule_files:
  - 'alert-rules.yml'

Para recibir notificaciones, configura Alertmanager. Es un componente separado que se encarga de deduplicar, agrupar y enrutar alertas a canales como Slack, PagerDuty o correo electrónico.

Correlación de métricas y logs con Grafana

La verdadera potencia del stack aparece cuando enlazas métricas y logs. Desde un panel de Grafana, puedes hacer clic en un punto de datos (por ejemplo, un pico de CPU) y abrir los logs correspondientes en ese instante.

Para ello, en la configuración de la fuente de datos Loki, activa la opción Derived fields. Añade un campo derivado que extraiga un identificador (como el PID) del log y lo convierta en un enlace a una consulta de Prometheus. Esto permite un flujo de trabajo de debugging sin fricciones: ves una anomalía en la métrica, haces clic y ves los logs del proceso en ese momento.

[INFO] La correlación se vuelve especialmente útil en incidentes de rendimiento. Por ejemplo, si node_load1 se dispara, puedes filtrar los logs de /var/log/syslog por la misma marca de tiempo y encontrar mensajes de OOM (Out Of Memory) o errores de aplicación.

Buenas prácticas y optimización para SysAdmins

Para que este sistema sea sostenible en el tiempo, sigue estas recomendaciones:

Retención de datos y recursos

Prometheus no está diseñado para almacenar datos a largo plazo (más de 30 días). Configura la retención según tu capacidad:

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

Para Loki, el almacenamiento de chunks puede crecer rápido. Implementa políticas de retención en la configuración:

table_manager:
  retention_deletes_enabled: true
  retention_period: 720h  # 30 días

Seguridad

  • No expongas Prometheus o Loki directamente a Internet. Usa un proxy inverso con autenticación básica o OAuth.
  • Implementa autenticación en Grafana mediante LDAP o GitHub OAuth.
  • Usa certificados TLS para todas las comunicaciones internas.

Escalado

Si tu infraestructura crece, considera:

  • Prometheus en modo federado: Un Prometheus principal que recolecta de otros Prometheus por departamento.
  • Loki en modo microservicios: Separa los componentes (ingester, querier, compactor) para escalar horizontalmente.
  • Grafana con alta disponibilidad: Usa una base de datos compartida (PostgreSQL) y un balanceador de carga.

Conclusión: El futuro de la observabilidad

La monitorización con Prometheus, Grafana y Loki no es solo una moda técnica; es un cambio de paradigma en cómo los sysadmins gestionan sistemas Linux. Al unificar métricas y logs en una sola plataforma, reduces el tiempo de resolución de incidentes de horas a minutos. La clave está en la automatización de alertas sysadmin y en la capacidad de correlacionar eventos de forma visual.

Implementa este stack paso a paso, comienza con un servidor de pruebas y luego escala. La inversión inicial en configuración se amortiza rápidamente cuando evitas una caída de servicio o identificas un cuello de botella antes de que afecte a los usuarios.

[TIP] No olvides monitorizar el propio stack. Configura alertas para cuando Prometheus o Loki dejen de recibir datos. Un sistema de monitoreo caído es peor que no tener ninguno, porque te da una falsa sensación de seguridad.

Ahora tienes las herramientas y el conocimiento. Es hora de ponerlas en práctica y llevar tu monitorización Linux al siguiente nivel.

¿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