Monitorización de tu NAS y Homelab con Uptime Kuma + Grafana: Guía Práctica

Son las 3 de la mañana. Tu Plex deja de funcionar, Nextcloud no sincroniza y no te enteras hasta el día siguiente cuando tu familia se queja. ¿Te suena? La monitorización de tu NAS y homelab no es un lujo — es lo que separa un servidor doméstico fiable de uno que te da sustos cada semana. En esta guía práctica vas a montar un stack completo con Uptime Kuma y Grafana que te avise antes de que los problemas lleguen a tus usuarios.

Por qué necesitas monitorizar tu NAS y homelab

Si tienes un NAS con Docker corriendo servicios 24/7 — Plex, Nextcloud, Home Assistant, Vaultwarden — ya no tienes un «disco duro de red». Tienes un servidor. Y los servidores necesitan monitorización por tres razones fundamentales:

• Uptime: Saber al instante si un servicio se cae, antes de que alguien te lo diga
• Rendimiento: Detectar que tu NAS está al 95% de CPU o RAM antes de que todo se congele
• Alertas proactivas: Recibir un aviso en Telegram cuando un disco SMART reporta errores, no cuando ya has perdido datos

La buena noticia: no necesitas herramientas enterprise ni pagar licencias. Con Uptime Kuma + Grafana + Prometheus, todo open source y corriendo en Docker, tienes monitorización profesional en tu NAS por exactamente 0€.

El stack de monitorización recomendado

Antes de entrar en la instalación, veamos qué hace cada pieza y por qué las necesitas las dos:

¿Por qué dos herramientas y no una sola? Porque resuelven problemas distintos. Uptime Kuma te dice «Plex se ha caído hace 2 minutos». Grafana te dice «Plex lleva 3 días consumiendo un 20% más de RAM de lo normal». Juntas, tienes visibilidad completa.

Uptime Kuma vs alternativas: comparativa

Existen varias herramientas de monitorización, pero no todas son prácticas para un homelab en NAS. Esta comparativa te ayuda a elegir:

Veredicto: Para un homelab con NAS, Uptime Kuma gana por goleada. Consume poquísimos recursos, se instala en 2 minutos y tiene más integraciones de notificación que cualquier alternativa. Zabbix es más potente pero totalmente overkill para uso doméstico.

Requisitos previos

• Un NAS con soporte Docker (Synology con Container Manager, UGREEN con UGOS Pro, QNAP con Container Station, o cualquier NAS con TrueNAS/Unraid)
• Acceso SSH o terminal al NAS
• Docker y Docker Compose instalados — si no los tienes, consulta nuestra guía de Docker en NAS
• Mínimo 1 GB de RAM libre para todo el stack (Uptime Kuma + Grafana + Prometheus)
• Conocimientos básicos de Docker Compose (archivos YAML)

Paso 1: Instalar Uptime Kuma con Docker Compose

Uptime Kuma es la pieza más sencilla del stack. Un solo contenedor, sin dependencias, listo en minutos.

Docker Compose para Uptime Kuma

Crea un directorio para tu stack de monitorización y el archivo docker-compose.yml:

mkdir -p ~/monitoring && cd ~/monitoring

# docker-compose.yml - Uptime Kuma
version: "3.8"
services:
  uptime-kuma:
    image: louislam/uptime-kuma:1
    container_name: uptime-kuma
    restart: unless-stopped
    ports:
      - "3001:3001"
    volumes:
      - ./uptime-kuma-data:/app/data
      - /var/run/docker.sock:/var/run/docker.sock:ro
    environment:
      - TZ=Europe/Madrid

Nota importante: El montaje de /var/run/docker.sock es lo que permite a Uptime Kuma monitorizar contenedores Docker directamente. Sin esto, solo podrás usar monitores HTTP y Ping.

Levanta el servicio:

docker compose up -d

Accede a http://IP-DE-TU-NAS:3001, crea tu usuario administrador y ya tienes Uptime Kuma funcionando.

Configurar monitores en Uptime Kuma

Uptime Kuma soporta más de 15 tipos de monitores. Los más útiles para un NAS/homelab:

Monitor HTTP(s) — Para servicios web:

• Plex: http://IP-NAS:32400/web (comprueba que la interfaz responde)
• Nextcloud: http://IP-NAS:8080/status.php (devuelve JSON con estado)
• Vaultwarden: http://IP-NAS:8222
• Home Assistant: http://IP-NAS:8123

Monitor Ping — Para dispositivos de red:

• Router: 192.168.1.1
• Switch gestionable
• Access points WiFi
• Otros NAS o servidores de la red

Monitor Docker — Para contenedores (requiere docker.sock montado):

• Selecciona directamente el contenedor por nombre
• Detecta si el contenedor está running, stopped o en error
• No necesitas exponer puertos para monitorizarlo

Monitor TCP — Para servicios sin interfaz web:

• Base de datos MariaDB/PostgreSQL: puerto 3306 / 5432
• SSH: puerto 22
• MQTT (Home Assistant): puerto 1883

Paso 2: Instalar Grafana + Prometheus + Node Exporter

Aquí es donde la cosa se pone interesante. Grafana sin datos no sirve de nada — necesita una fuente de datos. Prometheus es la opción estándar: recopila métricas de tus servicios y las almacena como series temporales.

Docker Compose completo del stack de métricas

Añade estos servicios a tu docker-compose.yml (o crea uno nuevo en el mismo directorio):

# docker-compose.yml - Stack completo de monitorización
version: "3.8"

services:
  uptime-kuma:
    image: louislam/uptime-kuma:1
    container_name: uptime-kuma
    restart: unless-stopped
    ports:
      - "3001:3001"
    volumes:
      - ./uptime-kuma-data:/app/data
      - /var/run/docker.sock:/var/run/docker.sock:ro
    environment:
      - TZ=Europe/Madrid

  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    restart: unless-stopped
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus-data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.retention.time=30d'

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    restart: unless-stopped
    ports:
      - "3000:3000"
    volumes:
      - grafana-data:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=tu_password_seguro
      - TZ=Europe/Madrid

  node-exporter:
    image: prom/node-exporter:latest
    container_name: node-exporter
    restart: unless-stopped
    ports:
      - "9100:9100"
    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)($$|/)'

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

volumes:
  prometheus-data:
  grafana-data:

Configurar Prometheus

Antes de levantar el stack, crea el archivo de configuración de Prometheus:

mkdir -p prometheus

# 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: ['node-exporter:9100']

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

Ahora levanta todo el stack:

docker compose up -d

Consumo total aproximado del stack: ~400-500 MB de RAM. En un NAS con 4 GB o más, esto es perfectamente asumible junto con tus otros servicios.

Paso 3: Configurar Grafana con dashboards

Accede a Grafana en http://IP-NAS:3000 con usuario admin y la contraseña que configuraste.

Añadir Prometheus como fuente de datos

1. Ve a Connections → Data Sources → Add data source
2. Selecciona Prometheus
3. En URL: http://prometheus:9090 (usa el nombre del contenedor, no la IP)
4. Haz clic en Save & Test — debería mostrar «Data source is working»

Importar dashboards predefinidos

No hace falta crear dashboards desde cero. La comunidad tiene dashboards excelentes para homelab:

• Node Exporter Full (ID: 1860) — Métricas completas del sistema: CPU, RAM, disco, red, temperaturas
• Docker Container & Host Monitoring (ID: 893) — Uso de recursos por contenedor Docker
• cAdvisor (ID: 14282) — Vista detallada de contenedores con gráficos de CPU y memoria

Para importar: Dashboards → New → Import → introduce el ID y selecciona Prometheus como data source.

Con estos tres dashboards tienes visibilidad completa de tu NAS: desde el uso de CPU del sistema hasta cuánta RAM está consumiendo tu contenedor de Plex.

Cómo se complementan Uptime Kuma y Grafana

Uno de los errores más comunes es pensar que necesitas solo una u otra. La realidad es que cubren necesidades diferentes:

La combinación perfecta: Uptime Kuma como tu sistema de alertas de disponibilidad (up/down) + Grafana como tu panel de control de rendimiento (métricas, tendencias, capacidad). Si ya tienes los dos contenedores más de Docker en tu NAS, como comentamos en nuestra guía de alternativas self-hosted para tu NAS, añadir monitorización es el siguiente paso lógico.

Ejemplo práctico: monitorizar servicios comunes en NAS

Vamos a configurar la monitorización de un homelab típico con estos servicios:

Uptime Kuma: monitores para cada servicio

Tip: Para Nextcloud, usa el monitor tipo HTTP(s) Keyword y busca la palabra «installed» en la respuesta de /status.php. Así no solo verificas que responde, sino que la instalación está intacta.

Grafana: queries esenciales para NAS

Estas son las métricas más útiles que puedes visualizar en Grafana para tu NAS:

Uso de CPU por contenedor (query PromQL):

rate(container_cpu_usage_seconds_total{name!=""}[5m]) * 100

Memoria usada por contenedor:

container_memory_usage_bytes{name!=""} / 1024 / 1024

Espacio libre en disco (porcentaje):

100 - (node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"} * 100)

Tráfico de red (MB/s):

rate(node_network_receive_bytes_total{device="eth0"}[5m]) / 1024 / 1024

Temperatura CPU (si tu NAS expone sensores):

node_hwmon_temp_celsius

Paso 4: Configurar alertas y notificaciones

De nada sirve monitorizar si nadie se entera cuando algo falla. Aquí es donde Uptime Kuma brilla — tiene más de 90 integraciones de notificación out-of-the-box.

Configurar notificaciones en Uptime Kuma

Telegram (la más popular en homelab):

1. Habla con @BotFather en Telegram y crea un bot → obtén el Bot Token
2. Envía un mensaje al bot y visita https://api.telegram.org/bot<TOKEN>/getUpdates para obtener tu Chat ID
3. En Uptime Kuma: Settings → Notifications → Setup Notification
4. Tipo: Telegram, pega Bot Token y Chat ID
5. Haz clic en Test — deberías recibir un mensaje de prueba

Discord:

1. En tu servidor Discord: Ajustes del canal → Integraciones → Webhooks → Nuevo Webhook
2. Copia la URL del webhook
3. En Uptime Kuma: tipo Discord, pega la URL del webhook

Email (SMTP):

1. Configura con tu servidor SMTP (Gmail, ProtonMail, o tu propio mail server)
2. Ideal como backup: si Telegram falla, el email sigue funcionando

Recomendación: Configura al menos dos canales de notificación (ej: Telegram + Email). Si tu NAS pierde conexión a internet, el bot de Telegram no te avisará — pero si tienes un monitor externo apuntando a tu IP pública, ese sí.

Alertas en Grafana

Grafana también puede enviar alertas basadas en umbrales de métricas:

1. Alerting → Alert Rules → New alert rule
2. Define la condición: ej. node_filesystem_avail_bytes / node_filesystem_size_bytes * 100 < 10 (disco con menos del 10% libre)
3. Configura el Contact Point (Telegram, Discord, email, webhook)
4. Define la evaluación: cada 5 minutos, durante 10 minutos (evita falsos positivos)

Alertas de Grafana recomendadas para NAS:

• Disco <10% libre → Alerta crítica
• CPU >90% sostenido durante 15 min → Alerta de rendimiento
• RAM >90% sostenido durante 10 min → Alerta de rendimiento
• Temperatura CPU >80°C → Alerta de hardware
• Contenedor reiniciado >3 veces en 1 hora → Posible crash loop

Stack alternativo: InfluxDB en lugar de Prometheus

Si ya usas InfluxDB en tu homelab (por ejemplo, con Home Assistant o Telegraf), no necesitas añadir Prometheus. Grafana funciona igual de bien con InfluxDB como fuente de datos.

¿Cuál elegir? Si partes de cero → Prometheus (más ligero, más documentación para homelab). Si ya tienes InfluxDB corriendo → quédate con InfluxDB y ahórrate un contenedor más.

Qué NAS necesitas para correr este stack

El stack completo (Uptime Kuma + Grafana + Prometheus + Node Exporter + cAdvisor) consume aproximadamente 500-700 MB de RAM y muy poca CPU en reposo. Esto significa que cualquier NAS moderno con 4 GB de RAM o más lo gestiona sin problemas junto con tus otros servicios.

NAS recomendados para homelab con monitorización:

• UGREEN DXP4800 Plus: Intel N100, 8 GB DDR5 (ampliable a 16 GB), 4 bahías + 2 M.2 NVMe. Potencia de sobra para este stack y mucho más. Ver en Amazon
• Synology DS224+: Intel Celeron J4125, 2 GB DDR4 (ampliable a 6 GB). Funcional pero justo — amplía la RAM si vas a correr muchos contenedores. Ver en Amazon
• QNAP TS-464: Intel Celeron N5095, 8 GB DDR4. Muy buen equilibrio para homelab. Ver en Amazon

Si estás pensando en tu primer NAS para homelab, echa un vistazo a nuestra guía de Proxmox VE para principiantes — muchos homelabbers combinan un NAS para almacenamiento con Proxmox para virtualización, y la monitorización con este stack cubre ambos.

Problemas comunes y soluciones

Uptime Kuma no detecta contenedores Docker

Asegúrate de montar el socket de Docker en el docker-compose.yml:

volumes:
  - /var/run/docker.sock:/var/run/docker.sock:ro

En algunos NAS (Synology), el socket está en una ruta diferente. Verifica con ls -la /var/run/docker.sock.

Grafana muestra «No data» en los dashboards

Lo más habitual: la URL de Prometheus en Grafana es incorrecta. Usa http://prometheus:9090 (nombre del contenedor) si están en la misma red Docker, no http://localhost:9090.

Node Exporter no reporta temperaturas

No todos los NAS exponen sensores de temperatura al kernel. En Synology y QNAP suele funcionar. En NAS DIY con Linux, instala lm-sensors y ejecuta sensors-detect.

El stack consume demasiada RAM

Reduce la retención de Prometheus (de 30d a 7d):

command:
  - '--storage.tsdb.retention.time=7d'

También puedes prescindir de cAdvisor si no necesitas métricas detalladas por contenedor (ahorras ~100 MB).

Conclusión: tu NAS monitorizado es un NAS fiable

Montar Uptime Kuma + Grafana + Prometheus en tu NAS te lleva menos de 30 minutos y te ahorra horas de problemas futuros. Ya no dependes de «a ver si todo sigue funcionando» — lo sabes, en tiempo real, con alertas a tu móvil.

El stack recomendado:

• Uptime Kuma → ¿Mis servicios están vivos? Alertas instantáneas
• Grafana + Prometheus → ¿Cómo rinde mi NAS? Métricas, gráficos, tendencias
• Node Exporter + cAdvisor → Datos del sistema y de Docker para alimentar Grafana

Si quieres llevar tu homelab al siguiente nivel, combina esta monitorización con herramientas de automatización como n8n para automatizar flujos — por ejemplo, que cuando Uptime Kuma detecte una caída, n8n reinicie el contenedor automáticamente.

Precios y especificaciones sujetos a cambio. Verificar en web oficial del fabricante. Este artículo contiene enlaces de afiliado — si compras a través de ellos, nos ayudas a mantener el blog sin coste adicional para ti.