Despliega tu propia plataforma de monitorización y alertas con Grafana, Prometheus y Loki (Docker Compose)

¿Buscas monitorizar tus aplicaciones y servidores de forma profesional en tu propio VPS? Hoy te presento una plataforma de observabilidad al estilo “infra de empresa”: métricas, logs, panel de control y alertas automáticas, ¡todo ello orquestado fácilmente con Docker Compose!

Esta solución une tres gigantes del open source:

• Prometheus: recopila y almacena métricas (uso de CPU, memoria, estados de microservicios, etc.).
• Loki: gestiona y centraliza logs (registros de eventos, errores, trazas…).
• Grafana: el panel visual, donde configuras dashboards chulísimos y alertas para enterarte de todo.

Ideal tanto para proyectos personales como para pequeñas empresas, permite monitorizar el estado de los servicios, detectar anomalías y recibir notificaciones si algo va mal. Y todo con unos minutos de despliegue.

¿Por qué esta stack?

Hoy en día la observabilidad es esencial: saber no solo si los servicios viven, sino cómo funcionan realmente, qué fallos ocurren y tener datos históricos para diagnosticar problemas. Con Prometheus + Grafana + Loki cubres los tres pilares: métricas, logs y visualización.

• Prometheus puede extraer métricas de tus propios servicios, bases de datos, y hasta del sistema operativo.
• Loki recopila logs de todas las aplicaciones que tú decidas.
• Grafana los muestra (¡y te avisa si algo va mal!)

El Docker Compose definitivo

Copia y pega este docker-compose.yml en tu VPS (carpeta independiente) y ejecútalo. En minutos tendrás una stack completa de monitorización autoinstalada:

version: '3.8'
services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - --config.file=/etc/prometheus/prometheus.yml
    ports:
      - "9090:9090"
    restart: unless-stopped

  loki:
    image: grafana/loki:latest
    container_name: loki
    command: -config.file=/etc/loki/local-config.yaml
    ports:
      - "3100:3100"
    volumes:
      - ./loki-config.yaml:/etc/loki/local-config.yaml
      - loki_data:/loki
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
      - GF_INSTALL_PLUGINS=grafana-piechart-panel
    depends_on:
      - prometheus
      - loki
    volumes:
      - grafana_data:/var/lib/grafana
    restart: unless-stopped

  promtail:
    image: grafana/promtail:latest
    container_name: promtail
    volumes:
      - ./promtail-config.yaml:/etc/promtail/config.yaml
      - /var/log:/var/log:ro
    command: -config.file=/etc/promtail/config.yaml
    depends_on:
      - loki
    restart: unless-stopped

volumes:
  prometheus_data:
  grafana_data:
  loki_data:

Archivos de configuración extra necesarios

Crea los siguientes ficheros para completar el entorno:

1. prometheus/prometheus.yml

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['prometheus:9090']
  - job_name: 'node'
    static_configs:
      - targets: ['host.docker.internal:9100'] # O apunta a tus targets reales

2. loki-config.yaml (básico para tests)

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
  max_transfer_retries: 0

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: /loki/index
    cache_location: /loki/cache
    shared_store: filesystem
  filesystem:
    directory: /loki/chunks

limits_config:
  enforce_metric_name: false
  reject_old_samples: true
  reject_old_samples_max_age: 168h

chunk_store_config:
  max_look_back_period: 0s

table_manager:
  retention_deletes_enabled: true
  retention_period: 168h

3. promtail-config.yaml

server:
  http_listen_port: 9080
  grpc_listen_port: 0

positions:
  filename: /tmp/positions.yaml

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

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

¿Y ahora qué?

1. Levanta la stack: docker compose up -d
2. Accede a Grafana en http://TU_IP:3000 (usuario: admin, contraseña: admin).
3. Añade como fuentes de datos Prometheus (http://prometheus:9090) y Loki (http://loki:3100).
4. ¡Crea dashboards y alerta como quieras!

Consejos extra y troubleshooting

• Para monitorizar el propio host, instala node_exporter y apúntalo en el prometheus.yml.
• Edita los volumes para mantener datos y configuraciones persistentes al actualizar.
• ¿No se ven logs en Loki? Verifica los paths en promtail-config.yaml y permisos de lectura.
• Puedes integrar alertas por email, Telegram o Slack desde Grafana en pocos clics.
• Recuerda cambiar contraseñas de Grafana si lo expones a Internet.
• En 2025, Docker Compose soporta mejoras como healthchecks y redes separadas, aprovéchalas si continúas expandiendo la plataforma[1][2].

¿Por qué mola esta stack?

Con esta solución tienes el superpoder de saber en todo momento si tus proyectos están sanos. Detecta problemas antes de que el usuario se queje, optimiza tus recursos y gana tranquilidad. Y si lo quieres extender, soporta plugins, alertas automáticas y todo tipo de integraciones futuras (¿quién ha dicho IA? 😏).