Al terminar este artículo tendrás Uptime Kuma comprobando cada servicio de IA de tu máquina y Prometheus avisando de la memoria, con los comandos que usamos nosotros. Funciona en cualquier equipo con Docker; para la monitorización en sí basta un mini PC usado.
También te enseñamos nuestro propio mes de historial, incluida la parte que nos deja mal. Esa es la más útil.
Qué necesitas
- Una máquina con tus modelos (Ollama, vLLM o similar) y Docker
- 30 minutos
- Una app o un chat que ya leas (Telegram, ntfy, correo) para los avisos
Qué tenemos y qué hemos medido en un mes
Nuestra máquina de referencia es una DGX Spark (GB10, 128 GB de memoria unificada) con una segunda Spark conectada por cable directo. En ella corren Uptime Kuma 1.23.17 (louislam/uptime-kuma:1, en el puerto 3003) y Prometheus 3.5.4 (puerto 9092) con node-exporter, cAdvisor y utkuozdemir/nvidia_gpu_exporter.
El 8 de octubre de 2026 sacamos 30 días de historial con scripts/bench/monitoring_history.py, que lee la serie ALERTS de Prometheus mediante /api/v1/query_range y una copia de la base de datos de Uptime Kuma. La salida en bruto está en monitoring-history-2026-10-08.json.
| Alerta (Prometheus, DGX Spark, del 8-9 al 8-10-2026) | Episodios | Horas activa |
|---|---|---|
| Segunda Spark inalcanzable | 17 | 100,0 |
| Exportador de GPU de la segunda Spark caído | 12 | 102,6 |
| Segunda Spark con menos de 15 GB libres | 3 | 1,8 |
| Spark principal con menos de 8 GB libres | 4 | 0,3 |
| Pasarela LiteLLM caída | 0 | 0 |
Las alertas de memoria fueron breves: la más larga duró 1,5 horas. No anotamos la causa de cada episodio «inalcanzable» cuando ocurrió, y un mes después no sabemos cuáles fueron reinicios planificados. Escribe una línea por alerta cuando salte; es el hábito más barato de este artículo.
Uptime Kuma, en la misma ventana, mostró la mitad menos favorecedora:
- Ningún monitor enlazado a una notificación. Existía un canal de avisos. Ningún monitor lo usaba. Cada caída de arriba solo la veía quien abriera el panel.
- Tres monitores en rojo todo el mes. Dos comprobaban una ruta que respondió 404 en cada latido. El tercero, Uptime Kuma comprobándose a sí mismo, agotó el tiempo en cada latido.
- Las comprobaciones de las webs públicas fallaban sobre todo por DNS dentro del contenedor (
getaddrinfo ENOTFOUND), no porque las webs estuvieran caídas. - Un servicio movido rompió su monitor. Cuando nuestro vLLM pasó a la segunda Spark el 5 de octubre, el reenviador local escuchaba solo en 127.0.0.1, así que el contenedor vio «connection refused» y después tiempos agotados. La comprobación estuvo en rojo los tres últimos días de la ventana.
Prometheus tiene el mismo hueco: /api/v1/alertmanagers devuelve una lista vacía, así que sus alertas saltan en su propia página web y en ningún otro sitio. Un monitor que nadie oye es un archivo de registro.
Paso 1: arranca Uptime Kuma
docker run -d --name uptime-kuma --restart=unless-stopped \
-p 3003:3001 -v uptime_kuma_data:/app/data \
--add-host host.docker.internal:host-gateway \
louislam/uptime-kuma:1Abre http://localhost:3003 y crea la cuenta de administración. La línea --add-host deja que el contenedor llegue a los servicios del host como host.docker.internal. Usamos el 3003 porque el 3001 estaba ocupado; vale cualquier puerto libre.
Paso 2: añade monitores que comprueben lo correcto
Antes de añadir un monitor, prueba la URL exacta desde dentro del contenedor. Este comando nos habría ahorrado los tres monitores en rojo:
docker exec uptime-kuma curl -s -o /dev/null -w "%{http_code}\n" \
http://host.docker.internal:11434/api/tagsEspera un 200. Un 404 significa que la ruta está mal; «connection refused» significa que el servicio escucha solo en 127.0.0.1 y el contenedor no llega.
Rutas de salud que responden 200 en nuestro stack:
| Servicio | URL que comprobar | Intervalo |
|---|---|---|
| Ollama | http://host.docker.internal:11434/api/tags | 30 s |
| LiteLLM | http://host.docker.internal:4000/health/readiness | 30 s |
| vLLM | http://<host-de-vllm>:8200/health | 30 s |
| Open WebUI | http://host.docker.internal:3000 | 60 s |
| Qdrant | http://host.docker.internal:6333/healthz | 60 s |
| El propio Uptime Kuma | http://localhost:3001/ (dentro del contenedor) | 60 s |
Pon 2 o 3 reintentos en los servidores de modelos. Cargar un modelo grande puede bloquear una comprobación unos segundos, y un latido perdido no es una caída.
Paso 3: enlaza una notificación a cada monitor
Este es el paso que nos saltamos. En Ajustes, Notificaciones, añade un canal que leas de verdad. Después abre cada monitor, marca esa notificación y guarda. Marca «Activado por defecto» en el canal para que los monitores nuevos la reciban solos.
Pruébalo: para un servicio a propósito y espera el mensaje. Espera más que el intervalo por (reintentos + 1): con 60 s y 3 reintentos, cuatro minutos.
docker stop open-webui && sleep 300 && docker start open-webuiSi tu móvil no suena, tu monitorización no está terminada.
Paso 4: que Prometheus vigile la memoria y la pasarela
Uptime Kuma ve HTTP. Prometheus ve la máquina. Nuestro prometheus.yml recoge node-exporter, cAdvisor y el exportador de GPU cada 15 segundos y carga un archivo de reglas. Estas son tres de nuestras seis reglas, acortadas (sin etiquetas ni anotaciones):
groups:
- name: gateway
rules:
- alert: LiteLLMGatewayDown
expr: up{job="litellm"} == 0
for: 3m
- name: machines
rules:
- alert: PrimeMemoryCritical
expr: node_memory_MemAvailable_bytes{job="node"} < 8e9
for: 10m
- alert: AssistantSparkDown
expr: up{job="spark2-node"} == 0
for: 5m¿Por qué la memoria del node-exporter y no la del exportador de GPU? En la GB10, el exportador de GPU da temperatura, consumo y uso, pero no «memoria usada»: la memoria se comparte con la CPU. En una tarjeta con VRAM propia alertarías sobre la métrica de memoria de la GPU.
Comprueba que todos los objetivos están levantados:
curl -s localhost:9092/api/v1/targets | python3 -c \
"import sys,json;[print(t['labels']['job'],t['health']) for t in json.load(sys.stdin)['data']['activeTargets']]"Paso 5: conecta Alertmanager (nuestro siguiente paso, aún sin hacer)
Prometheus solo evalúa reglas; Alertmanager las entrega. Todavía no lo hemos desplegado, así que no vamos a fingir una configuración probada. La documentación de configuración de Prometheus muestra el bloque alerting: que se añade a prometheus.yml. Mientras tanto, Uptime Kuma con notificaciones cubre «está caído», que es el aviso que más importa.
Una rutina semanal de 10 minutos
curl -s localhost:9092/api/v1/alerts # ¿hay algo saltando ahora?
docker ps --filter health=unhealthy # contenedores que fallan su propia comprobación
ollama ps # qué hay cargado y cuánto ocupaDespués abre Uptime Kuma y busca cualquier monitor que lleve más de un día en rojo. Arréglalo o bórralo. Un monitor siempre en rojo te enseña a ignorar el rojo.
Cuándo no merece la pena
- Un modelo en un portátil que solo usas tú. Te darás cuenta cuando se pare. Sáltate todo esto.
- Un equipo depende de él. Entonces necesitas al menos el paso 3, hoy.
Próximos pasos
- Lee IA local: qué es, qué necesitas y cuándo compensa para dimensionar la máquina que vigilas.
- Mantén el servidor al día con nuestra lista de seguridad de Ollama.
- Planifica el uso compartido en Open WebUI para una oficina de 10.
Si prefieres que otra persona vigile el servidor de tu empresa, es el tipo de trabajo que hacemos: reserva una llamada de 15 minutos o mira cómo trabajamos en consultoría.