Guía práctica para configurar Prometheus y Grafana con Docker Compose en VPS

Por · Publicado el · Actualizado el · 10 min de lectura

Tablet sobre mesa mostrando gráficos y dashboards, junto a un móvil y una taza de café
Pantalla con gráficos y métricas, que representa monitorización de infraestructura y contenedores. Foto: AS Photography / Pexels

Guía práctica para configurar Prometheus y Grafana con Docker Compose en una VPS, incluyendo Node Exporter, cAdvisor, Alertmanager, reglas de alerta y provisión de datasource. Al final tendrás un stack de monitorización funcional para sistemas y contenedores, listo para métricas, dashboards y alertas confiables.

Antes de empezar: prerequisitos y arquitectura del stack

Necesitas una VPS Linux 64 bits con acceso root o sudo, Docker y Docker Compose instalados, puertos abiertos y un usuario para operar. Empieza con recursos modestos y escala según crezcan el volumen de métricas y la retención.

La arquitectura incluye Prometheus (recolección/almacenamiento), Node Exporter (métricas del host), cAdvisor (métricas de contenedores), Alertmanager (ruteo de alertas) y Grafana (dashboards y alertas).

Si aún no has instalado Docker y Compose, sigue este paso: instalar Docker y Docker Compose en Linux. ¿Dudas sobre el tamaño? Revisa cómo elegir el tamaño correcto de VPS.

Componentes y puertos por defecto del entorno interno:

Componente Puerto Función URL interna
Prometheus 9090 TSDB y scraping http://prometheus:9090
Alertmanager 9093 Agrupa y envía alertas http://alertmanager:9093
Node Exporter 9100 Métricas del host http://node-exporter:9100/metrics
cAdvisor 8080 Métricas de contenedores http://cadvisor:8080/metrics
Grafana 3000 Dashboards y alertas http://grafana:3000

Preparar directorios, variables y permisos en la VPS

Crea una carpeta de proyecto, separa configuraciones y datos persistentes y define variables sensibles fuera del versionado. Ejecuta los comandos con un usuario con sudo.

Usaremos un archivo .env para la contraseña inicial de Grafana. Ajusta nombres y rutas según la política de tu VPS.

  • La estructura separa configs versionables de los volúmenes persistentes.
  • Usa un gestor de contraseñas para guardar credenciales.
  • Evita contraseñas débiles; habilita MFA en Grafana tras el primer acceso.
# Crie a estrutura de diretórios
test -d monitoring || mkdir -p monitoring/{prometheus/rules,alertmanager,grafana/provisioning/{datasources,dashboards}}
cd monitoring

# Defina variáveis sensíveis (não comitar este arquivo)
cat > .env << 'EOF'
GF_SECURITY_ADMIN_USER=admin
GF_SECURITY_ADMIN_PASSWORD=altere-esta-senha
EOF

# Opcional: restrinja permissões do .env
chmod 600 .env

Docker Compose: Prometheus, Grafana, Alertmanager, Node Exporter y cAdvisor

Este docker-compose crea la red, define volúmenes persistentes y arranca todos los servicios. Habilita reload en Prometheus y provisionamiento en Grafana.

Cambia las etiquetas de imagen según tu política. Puedes gestionar contenedores por UI con Portainer si lo prefieres.

Siguiendo estos pasos conseguirás configurar Prometheus y Grafana con Docker Compose en una VPS de forma reproducible.

  • Los volúmenes persistentes evitan pérdida de datos al recrear contenedores.
  • Etiquetas de imagen fijas reducen sorpresas en actualizaciones.
  • La contraseña de Grafana sale del .env para no filtrarla en el repositorio.
version: "3.8"

networks:
  monitoring:
    driver: bridge

volumes:
  prometheus_data:
  grafana_data:
  alertmanager_data:

services:
  prometheus:
    image: prom/prometheus:v2.53.0
    container_name: prometheus
    restart: unless-stopped
    command:
      - --config.file=/etc/prometheus/prometheus.yml
      - --storage.tsdb.path=/prometheus
      - --web.enable-lifecycle
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - ./prometheus/rules:/etc/prometheus/rules:ro
      - prometheus_data:/prometheus
    networks: [monitoring]

  alertmanager:
    image: prom/alertmanager:v0.27.0
    container_name: alertmanager
    restart: unless-stopped
    command: ["--config.file=/etc/alertmanager/alertmanager.yml"]
    ports:
      - "9093:9093"
    volumes:
      - ./alertmanager/alertmanager.yml:/etc/alertmanager/alertmanager.yml:ro
      - alertmanager_data:/alertmanager
    networks: [monitoring]

  node-exporter:
    image: prom/node-exporter:v1.7.0
    container_name: node-exporter
    restart: unless-stopped
    pid: host
    command: ["--path.rootfs=/host"]
    volumes:
      - /:/host:ro,rslave
    ports:
      - "9100:9100"
    networks: [monitoring]

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:v0.47.2
    container_name: cadvisor
    restart: unless-stopped
    privileged: true
    ports:
      - "8080:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
    networks: [monitoring]

  grafana:
    image: grafana/grafana:10.4.3
    container_name: grafana
    restart: unless-stopped
    environment:
      - GF_SECURITY_ADMIN_USER=${GF_SECURITY_ADMIN_USER}
      - GF_SECURITY_ADMIN_PASSWORD=${GF_SECURITY_ADMIN_PASSWORD}
      - GF_USERS_ALLOW_SIGN_UP=false
    ports:
      - "3000:3000"
    volumes:
      - grafana_data:/var/lib/grafana
      - ./grafana/provisioning:/etc/grafana/provisioning
    depends_on: [prometheus]
    networks: [monitoring]

Configurar Prometheus: scrape_configs y reglas

Prometheus hará scrape de sí mismo, de Node Exporter y de cAdvisor. También apuntamos al Alertmanager y cargamos reglas de alerta desde el directorio rules.

Puedes ajustar scrape_interval según el volumen de métricas y el tamaño del disco. Intervalos menores aumentan el uso de CPU y almacenamiento.

  • Mantén nombres de job cortos y descriptivos.
  • Centraliza reglas en archivos separados para organizar mejor.
  • Habilitamos reload por HTTP para aplicar cambios sin reiniciar.
global:
  scrape_interval: 15s
  evaluation_interval: 15s

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

rule_files:
  - /etc/prometheus/rules/*.yml

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

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

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

Alertmanager: rutas y entrega de alertas

Define cómo se agruparán, ratearán y entregarán los alertas (e‑mail, webhook, chat). Empieza simple usando SMTP. Sustituye valores ficticios por credenciales válidas.

Prueba la entrega de alertas con una regla intencionalmente sensible y luego ajusta umbrales para reducir ruido.

  • Agrupa por alertname e instance para evitar tormentas de alertas.
  • Ajusta group_wait y repeat_interval según la criticidad.
  • Usa contraseñas de aplicación para SMTP cuando sea posible.
route:
  receiver: "email-default"
  group_by: ["alertname", "instance"]
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 3h

receivers:
  - name: "email-default"
    email_configs:
      - to: "[email protected]"
        from: "[email protected]"
        smarthost: "smtp.seu-dominio.com:587"
        auth_username: "[email protected]"
        auth_password: "SENHA-OU-TOKEN"
        require_tls: true

# Você pode adicionar outros receivers (webhook, chat) conforme necessidade.

Reglas de alerta útiles para empezar

Crea un archivo de reglas con condiciones de disponibilidad y saturación. Evita reglas ruidosas al inicio; refínalas tras observar tu entorno.

Los ejemplos cubren indisponibilidad, CPU alta, poca memoria y disco casi lleno. Ajusta umbrales a tu realidad.

  • Usa labels para severidad y equipo responsable.
  • Añade annotations con pasos siguientes claros.
  • Prueba las expresiones en el console de Prometheus.
groups:
  - name: infra-basics
    rules:
      - alert: InstanceDown
        expr: up == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Instância fora do ar"
          description: "{{ $labels.instance }} não responde a scrape."

      - alert: NodeHighCpu
        expr: (1 - avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m]))) > 0.8
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "CPU alta no host"
          description: "Uso de CPU acima de 80% por 5m em {{ $labels.instance }}."

      - alert: NodeLowMemory
        expr: (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) < 0.1
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Memória disponível baixa"
          description: "Menos de 10% de memória livre em {{ $labels.instance }}."

      - alert: NodeDiskAlmostFull
        expr: (node_filesystem_avail_bytes{fstype=~"ext4|xfs",mountpoint!~"/(run|var/lib/docker.*)"} / node_filesystem_size_bytes{fstype=~"ext4|xfs",mountpoint!~"/(run|var/lib/docker.*)"}) < 0.1
        for: 15m
        labels:
          severity: critical
        annotations:
          summary: "Disco quase cheio"
          description: "Menos de 10% livre em {{ $labels.instance }} filesystem."

Provisionar Grafana: datasource y primeros dashboards

Provisiona el datasource de Prometheus para evitar configuración manual. Luego, accede a Grafana, inicia sesión e importa dashboards desde el menú Import.

Para containers, crea paneles de CPU, memoria y reinicios por servicio. Para el host, añade gráficos de load, I/O y filesystem. Evita dashboards enormes al principio; itera gradualmente.

  • El datasource por defecto evita errores de URL.
  • Organiza dashboards por dominio: Infra, Docker, App.
  • Usa variables de dashboard para filtrar por instancia.
# grafana/provisioning/datasources/datasource.yml
apiVersion: 1

datasources:
  - name: Prometheus
    type: prometheus
    access: proxy
    url: http://prometheus:9090
    isDefault: true
    editable: false

Arrancar los servicios, verificar métricas y validar alertas

Es hora de arrancar y validar. Estos comandos alteran servicios en el host; ejecútalos con precaución.

Abre las UIs locales para comprobar: Prometheus en :9090, Alertmanager en :9093, Grafana en :3000. Prueba reload de config y verifica que las reglas se hayan cargado.

Con esto concluyes cómo configurar Prometheus y Grafana con Docker Compose en VPS y validar el flujo de monitorización end‑to‑end.

  • Usa docker compose logs para investigar errores de arranque.
  • En Prometheus, revisa Status > Targets y Status > Rules.
  • Genera una alerta temporal para validar la entrega (ej.: reducir umbral).
# Subir em background
docker compose up -d

# Verificar status
docker compose ps

# Listar alvos no Prometheus (espera-se 200 OK)
curl -sS http://localhost:9090/targets | head -n 20

# Checar Alertmanager
curl -sS http://localhost:9093 | head -n 5

# Recarregar configuração do Prometheus após editar arquivos
echo "Reload Prometheus" && curl -X POST http://localhost:9090/-/reload

# Logs de um serviço específico
docker compose logs -f prometheus

Hardening, backups y próximos pasos

Para exponer Grafana y bloquear accesos directos, usa un proxy inverso con TLS y autenticación. La guía de SSL con Let's Encrypt ayuda a emitir certificados válidos.

Restringe puertos externos con firewall; abre solo lo indispensable. Haz backups periódicos de los volúmenes y de los archivos de configuración versionados.

Cuando todo esté estable, considera separar métricas por entornos y ajustar la retención de series según el disco disponible.

  • Protege Grafana detrás de proxy y TLS: ver generar SSL gratis.
  • Aplica reglas en UFW: ver configurar firewall en Ubuntu con UFW.
  • Haz snapshot/backup de los volúmenes prometheus_data y grafana_data.
  • Define una ventana de retención coherente con tu disco.
  • Implementa Remote Write si necesitas centralizar métricas.

Preguntas frecuentes

¿Qué tamaño de VPS debo usar para Prometheus y Grafana?

Depende del scrape_interval, número de targets y de la retención de series. Para entornos pequeños —pocos hosts y scrape_interval típico como 15s— normalmente bastan VPS con CPU y memoria moderadas. Prioriza disco si crece la retención. Monitoriza uso de CPU, memoria e I/O y escala verticalmente según las necesidades reales antes de migrar a arquitecturas más complejas.

¿Cómo persisto datos entre recreaciones de los contenedores?

Usa volúmenes nombrados en Docker Compose para Prometheus, Grafana y Alertmanager; así los datos quedan fuera del ciclo de vida de los contenedores. Guarda también los archivos de configuración (.yml) en directorios versionados. Realiza backups periódicos de los volúmenes y, antes de cambios grandes, crea un snapshot del disco de la VPS para poder restaurar si algo falla.

¿Cómo proteger Grafana en producción?

Coloca Grafana detrás de un proxy inverso con TLS y limita accesos mediante firewall, abriendo solo los puertos indispensables. Activa MFA, usa contraseñas fuertes y certificados válidos si lo expones a Internet. Mantén Grafana actualizado, revisa permisos de ficheros y protege el .env y las credenciales fuera del repositorio. Considera desactivar funciones públicas según la política de seguridad.

¿Puedo monitorizar múltiples VPS con este setup?

Sí. Instala Node Exporter en cada VPS y añade sus IPs y puertos en scrape_configs de Prometheus. Para hosts expuestos, protege las comunicaciones con firewall, TLS o túneles seguros. También puedes ejecutar exportadores como contenedores en cada host remoto. Ajusta etiquetas y scrape_interval para organizar targets y agrupar alertas por instancia o servicio.

¿Qué canales de notificación puedo usar en Alertmanager?

El SMTP es una opción sencilla para empezar; Alertmanager también admite webhooks que permiten integrar chats, sistemas de ticketing o automatizaciones. Define rutas por severidad y servicio, agrupa alertas para reducir ruido y ajusta group_wait y repeat_interval según la criticidad. Sustituye valores de ejemplo por credenciales reales y prueba la entrega antes de producción.

¿Cómo actualizar las imágenes sin perder datos?

Actualiza las etiquetas en docker-compose.yml, haz backup de los volúmenes y ejecuta docker compose pull && docker compose up -d. Como los datos están en volúmenes persistentes, se conservan al recrear contenedores. Valida cambios en un entorno de staging si es posible y monitoriza logs, métricas y las UIs tras la actualización para detectar problemas.

¿Necesitas adaptar este stack a tu entorno?

Si quieres revisar reglas, dimensionar retención o integrar alertas en tu flujo, hablemos para desbloquear la próxima etapa de tu monitorización.

Hablar sobre monitorización

Ver también