Monitorización de VPS con Uptime Kuma y Grafana

No puedes resolver lo que no puedes ver. Esta guía cubre la configuración de una monitorización integral para tu VPS—desde simples comprobaciones de uptime hasta dashboards completos de métricas.

Por Qué Esto Importa

Sin monitorización, solo te enteras de los problemas cuando los usuarios se quejan—o cuando ya todo está roto. Una buena monitorización significa:

• Detectar problemas antes de que los usuarios los noten - Alertas de picos de CPU antes de que ocurran caídas
• Entender las tendencias de rendimiento - Saber cuándo actualizar
• Depurar más rápido - Los datos históricos muestran qué cambió
• Dormir mejor - Las alertas automatizadas significan que no tienes que estar comprobando constantemente
• Demostrar el uptime - Muestra a los clientes que su SLA se cumple

Prerrequisitos

• Un VPS con Docker instalado (recomendamos Hostinger VPS por sus métricas de rendimiento fiables)
• Conocimientos básicos de Docker Compose
• Un nombre de dominio (opcional, pero recomendado)

Inicio Rápido: Elige Tu Stack

Herramienta	Ideal Para	Complejidad
Uptime Kuma	Monitorización de uptime, páginas de estado	Fácil
Grafana + Prometheus	Métricas completas, dashboards	Media
Netdata	Monitorización del sistema en tiempo real	Fácil
Stack completo	Entornos de producción	Avanzado

Parte 1: Uptime Kuma (Simple y Efectivo)

Uptime Kuma es una herramienta de monitorización autoalojada que es elegante y fácil de usar.

Paso 1: Desplegar Uptime Kuma

# docker-compose.yml
services:
  uptime-kuma:
    image: louislam/uptime-kuma:1
    container_name: uptime-kuma
    volumes:
      - uptime-kuma-data:/app/data
    ports:
      - "3001:3001"
    restart: unless-stopped

volumes:
  uptime-kuma-data:

docker compose up -d

Accede en http://your-server:3001

Paso 2: Configurar Monitores

Después de la configuración, añade monitores para:

Monitorización HTTP(S):

• Las URLs de tu sitio web
• Endpoints de API
• Paneles de administración

Monitorización de Puertos TCP:

• Puertos de base de datos (internos)
• Redis, servicios de caché

Monitorización de Contenedores Docker:

• Monitoriza el estado de los contenedores directamente

Monitorización DNS:

• Asegura que el DNS resuelve correctamente

Paso 3: Configurar Notificaciones

Uptime Kuma admite más de 90 servicios de notificación:

• Telegram - Alertas móviles instantáneas
• Discord/Slack - Canales de equipo
• Email - Tradicional pero fiable
• Pushover - Notificaciones push premium
• Webhook - Integraciones personalizadas

Configúralas en: Settings → Notifications

Paso 4: Crear una Página de Estado

1. Ve a Status Pages
2. Crea una nueva página
3. Añade tus monitores
4. Comparte la URL pública con los usuarios

Parte 2: Stack Completo de Métricas (Prometheus + Grafana)

Para la recopilación y visualización integral de métricas.

Paso 1: Crear el Stack

# docker-compose.monitoring.yml
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'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention.time=30d'
    ports:
      - "9090:9090"
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    volumes:
      - grafana_data:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD}
      - GF_USERS_ALLOW_SIGN_UP=false
    ports:
      - "3000:3000"
    restart: unless-stopped

  node-exporter:
    image: prom/node-exporter:latest
    container_name: node-exporter
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.sysfs=/host/sys'
      - '--path.rootfs=/rootfs'
      - '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)'
    ports:
      - "9100:9100"
    restart: unless-stopped

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
    ports:
      - "8080:8080"
    restart: unless-stopped

volumes:
  prometheus_data:
  grafana_data:

Paso 2: Configurar Prometheus

# prometheus/prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s

alerting:
  alertmanagers:
    - static_configs:
        - targets: []

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

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

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

  # Add your applications
  - job_name: 'myapp'
    static_configs:
      - targets: ['myapp:3000']
    metrics_path: '/metrics'

Paso 3: Iniciar el Stack

mkdir -p prometheus
# Create prometheus.yml as above
docker compose -f docker-compose.monitoring.yml up -d

Paso 4: Configurar Dashboards de Grafana

1. Accede a Grafana en http://your-server:3000

2. Inicia sesión con admin / tu-contraseña

3. Añade la fuente de datos de Prometheus:

   • Configuration → Data Sources → Add
   • Selecciona Prometheus
   • URL: http://prometheus:9090
   • Save & Test

4. Importa dashboards prediseñados:

   • Dashboards → Import
   • IDs de dashboards populares:
     • 1860 - Node Exporter Full
     • 893 - Docker and System Monitoring
     • 14282 - cAdvisor Dashboard

Paso 5: Crear Alertas Personalizadas

En Grafana:

1. Alerting → Alert Rules → New
2. Crea condiciones basadas en métricas
3. Configura los canales de notificación

Ejemplo de alerta: CPU > 80% durante 5 minutos

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

Parte 3: Netdata (Monitorización en Tiempo Real)

Para monitorización instantánea sin configuración:

services:
  netdata:
    image: netdata/netdata
    container_name: netdata
    ports:
      - "19999:19999"
    cap_add:
      - SYS_PTRACE
    security_opt:
      - apparmor:unconfined
    volumes:
      - netdataconfig:/etc/netdata
      - netdatalib:/var/lib/netdata
      - netdatacache:/var/cache/netdata
      - /etc/passwd:/host/etc/passwd:ro
      - /etc/group:/host/etc/group:ro
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /etc/os-release:/host/etc/os-release:ro
    restart: unless-stopped

volumes:
  netdataconfig:
  netdatalib:
  netdatacache:

Accede en http://your-server:19999 - ¡dashboards hermosos al instante!

Parte 4: Monitorización a Nivel de Aplicación

Añadir Métricas a Tus Aplicaciones

Node.js con prom-client:

const client = require('prom-client');
const express = require('express');

// Collect default metrics
client.collectDefaultMetrics();

// Custom metrics
const httpRequestsTotal = new client.Counter({
  name: 'http_requests_total',
  help: 'Total HTTP requests',
  labelNames: ['method', 'path', 'status']
});

app.use((req, res, next) => {
  res.on('finish', () => {
    httpRequestsTotal.inc({
      method: req.method,
      path: req.route?.path || req.path,
      status: res.statusCode
    });
  });
  next();
});

// Expose metrics endpoint
app.get('/metrics', async (req, res) => {
  res.set('Content-Type', client.register.contentType);
  res.end(await client.register.metrics());
});

Python con prometheus-client:

from prometheus_client import Counter, Histogram, generate_latest
from flask import Flask, Response

app = Flask(__name__)

REQUEST_COUNT = Counter('requests_total', 'Total requests', ['method', 'endpoint'])
REQUEST_LATENCY = Histogram('request_latency_seconds', 'Request latency')

@app.route('/metrics')
def metrics():
    return Response(generate_latest(), mimetype='text/plain')

Parte 5: Monitorización de Logs con Loki

Añade registro centralizado:

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

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

volumes:
  loki_data:

Configuración de Promtail:

# promtail-config.yml
server:
  http_listen_port: 9080

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

  - job_name: docker
    static_configs:
      - targets:
          - localhost
        labels:
          job: docker
          __path__: /var/lib/docker/containers/*/*log

¡Añade Loki como fuente de datos en Grafana y consulta logs junto a las métricas!

Configuración de Monitorización Recomendada

Para la mayoría de los despliegues de VPS:

# docker-compose.monitoring.yml - Complete recommended stack
services:
  uptime-kuma:
    image: louislam/uptime-kuma:1
    volumes:
      - uptime-kuma-data:/app/data
    ports:
      - "3001:3001"
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    volumes:
      - grafana_data:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD}
    ports:
      - "3000:3000"
    restart: unless-stopped

  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.retention.time=15d'
    restart: unless-stopped

  node-exporter:
    image: prom/node-exporter:latest
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.sysfs=/host/sys'
      - '--path.rootfs=/rootfs'
    restart: unless-stopped

volumes:
  uptime-kuma-data:
  grafana_data:
  prometheus_data:

Buenas Prácticas

1. Monitoriza desde el exterior - Las comprobaciones externas detectan problemas de red
2. Establece umbrales razonables - Evita la fatiga por alertas
3. Estructura tu monitorización en capas - Uptime + métricas + logs
4. Retén los datos de forma adecuada - 15-30 días para métricas, más tiempo para agregados
5. Documenta los runbooks - Qué hacer cuando se dispare la alerta X
6. Prueba tus alertas - Asegúrate de que realmente te llegan
7. Monitoriza los monitores - Usa un servicio externo para vigilar tu monitorización
8. Protege tus dashboards - Las métricas pueden revelar información sensible (consulta nuestra guía de seguridad VPS)

Errores Comunes a Evitar

❌ Demasiadas alertas - La fatiga por alertas lleva a ignorar problemas reales

❌ Sin monitorización externa - Si tu servidor cae, también cae tu monitorización

❌ Exponer métricas públicamente - Usa autenticación o redes internas

❌ No configurar la retención - El disco se llena con datos antiguos

❌ Monitorizar sin actuar - Los dashboards no resuelven los problemas

❌ Canal de notificación único - ¿El email está caído? Sin alertas

❌ Sin línea base - Necesitas saber cómo es lo “normal”

❌ Monitorización excesiva - Empieza simple, añade complejidad según sea necesario

Métricas Clave a Vigilar

Métricas del Sistema

• Uso de CPU - Alerta al 80%+ sostenido
• Uso de memoria - Alerta al 85%+
• Uso de disco - Alerta al 80%+ (los discos se llenan rápido)
• E/S de disco - Una espera alta indica un cuello de botella en el almacenamiento
• Rendimiento de red - Línea base y detección de anomalías

Métricas de Aplicación

• Tiempo de respuesta - Latencias p50, p95, p99
• Tasa de errores - Porcentaje de respuestas 5xx
• Tasa de solicitudes - Patrones de tráfico
• Conexiones activas - Uso del pool de base de datos
• Profundidad de cola - Trabajos en segundo plano pendientes

Métricas de Negocio

• Registros/compras - Una caída indica problemas
• Usuarios activos - Salud del engagement
• Ingresos - La métrica definitiva

Preguntas Frecuentes

¿Cuántos recursos consume la monitorización?

Mínimos. Uptime Kuma: ~100 MB de RAM. Stack completo de Prometheus/Grafana: ~500 MB-1 GB. Vale la pena por la visibilidad que ofrece.

¿Debería usar monitorización en la nube o autoalojada?

Autoalojada para controlar costes y ser propietario de los datos. En la nube (Datadog, New Relic) si tienes presupuesto y quieres una solución gestionada. Hostinger VPS tiene recursos suficientes para la monitorización autoalojada.

¿Cómo monitorizo desde fuera de mi red?

Usa servicios externos como:

• Uptime Robot (nivel gratuito)
• Pingdom
• Better Uptime
• StatusCake

Estos detectan problemas que tu monitorización autoalojada no puede ver.

¿Qué umbrales de alerta debo configurar?

Empieza de forma conservadora y ajusta según la experiencia:

• CPU: 80% durante 5 minutos
• Memoria: 85%
• Disco: 80%
• Tiempo de respuesta: 2x tu p95 de referencia

¿Cuánto tiempo debo retener las métricas?

• Alta resolución (15 s): 7-15 días
• Agregadas (5 min): 30-90 días
• Más agregadas: 1-2 años

Equilibra el detalle frente a los costes de almacenamiento.

¿Puedo monitorizar múltiples servidores?

¡Sí! Prometheus + Node Exporter escalan bien. Solo añade nuevos targets a tu configuración de scrape y podrás monitorizar más de 100 servidores desde un único dashboard.

---

¡Tu stack de monitorización está listo! Combínalo con nuestra guía de copias de seguridad y la guía de seguridad para un VPS listo para producción.