Ver todos los artículos
MonitorizaciónUptime KumaPrometheusAutoalojadoIA local

Tu servidor de IA local, vigilado: Uptime Kuma y Prometheus

JG
Jacobo González Jaspe
|
Ilustración abstracta: planos geométricos claros y azul marino que encajan, con un brillo ámbar en las juntas. Desde la spark
Ilustración generada con IA en nuestra máquina.
Este artículo también está en inglés:Keep a Local AI Server Running: Uptime Kuma and Prometheus

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)EpisodiosHoras activa
Segunda Spark inalcanzable17100,0
Exportador de GPU de la segunda Spark caído12102,6
Segunda Spark con menos de 15 GB libres31,8
Spark principal con menos de 8 GB libres40,3
Pasarela LiteLLM caída00

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

bash
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:1

Abre 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:

bash
docker exec uptime-kuma curl -s -o /dev/null -w "%{http_code}\n" \
  http://host.docker.internal:11434/api/tags

Espera 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:

ServicioURL que comprobarIntervalo
Ollamahttp://host.docker.internal:11434/api/tags30 s
LiteLLMhttp://host.docker.internal:4000/health/readiness30 s
vLLMhttp://<host-de-vllm>:8200/health30 s
Open WebUIhttp://host.docker.internal:300060 s
Qdranthttp://host.docker.internal:6333/healthz60 s
El propio Uptime Kumahttp://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.

bash
docker stop open-webui && sleep 300 && docker start open-webui

Si 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):

YAML
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:

bash
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

bash
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 ocupa

Despué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

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.

Diagrama
Compartir: LinkedIn X
Veredicto semanal

Recibe las guías nuevas antes que nadie

Suscríbete y te avisamos cuando publiquemos guías, plantillas y workflows nuevos. Un correo a la semana, sin spam.

Ya publicados: 101 guías y 25 plantillas. Todo gratis y sin registro.

Bonus: el kit de inicio de IA local en PDF al suscribirte
1x por semana Sin spam Cancela cuando quieras

Ver qué recibes