Concepto clave

Configurar un dashboard de monitoreo para una API de Machine Learning es como instalar el tablero de instrumentos de un avión. No solo ves si el motor funciona (la API responde), sino que monitoreas el consumo de combustible (uso de recursos), la altitud (latencia), y detectas turbulencias (errores) antes de que se conviertan en problemas graves. En producción, tu modelo ML no es solo un archivo .pkl; es un servicio que debe estar disponible, rápido y confiable 24/7.

Un dashboard efectivo te da visibilidad en tiempo real sobre métricas clave: latencia (tiempo de respuesta), throughput (peticiones por segundo), tasa de error, y uso de recursos (CPU, memoria). Sin esto, estás volando a ciegas. Imagina desplegar un modelo de recomendación para un e-commerce: si la latencia sube de 100ms a 2 segundos, las ventas caen. El monitoreo te alerta antes de que los usuarios se vayan.

Cómo funciona en la práctica

Vamos a construir un dashboard paso a paso para una API FastAPI que sirve un modelo de clasificación de texto. Usaremos Prometheus para recolectar métricas y Grafana para visualizarlas. Primero, instrumentamos la API con métricas personalizadas (ej., tiempo de inferencia). Luego, exponemos esas métricas en un endpoint que Prometheus raspa cada 15 segundos. Finalmente, conectamos Grafana a Prometheus y creamos paneles con gráficos de líneas, gauges y alertas.

Paso 1: Agregar dependencias a tu proyecto. Paso 2: Decorar tu endpoint con un medidor de tiempo. Paso 3: Configurar Prometheus para raspar tu API. Paso 4: Importar un dashboard predefinido en Grafana y personalizarlo. La clave es empezar con métricas básicas (latencia, conteo de requests) y luego agregar métricas de negocio (ej., confianza promedio de las predicciones).

Codigo en accion

Antes: Una API sin monitoreo.

from fastapi import FastAPI
from pydantic import BaseModel
import joblib

app = FastAPI()
model = joblib.load("model.pkl")

class TextRequest(BaseModel):
    text: str

@app.post("/predict")
async def predict(request: TextRequest):
    prediction = model.predict([request.text])
    return {"prediction": prediction[0]}

Después: La misma API instrumentada con Prometheus.

from fastapi import FastAPI, Request
from pydantic import BaseModel
import joblib
from prometheus_client import Counter, Histogram, generate_latest, CONTENT_TYPE_LATEST
import time

app = FastAPI()
model = joblib.load("model.pkl")

# Métricas personalizadas
REQUEST_COUNT = Counter('api_requests_total', 'Total de requests a la API')
REQUEST_LATENCY = Histogram('api_request_latency_seconds', 'Latencia de los requests en segundos')
PREDICTION_COUNT = Counter('model_predictions_total', 'Total de predicciones del modelo')

class TextRequest(BaseModel):
    text: str

@app.middleware("http")
async def monitor_requests(request: Request, call_next):
    start_time = time.time()
    response = await call_next(request)
    latency = time.time() - start_time
    REQUEST_LATENCY.observe(latency)
    REQUEST_COUNT.inc()
    return response

@app.post("/predict")
async def predict(request: TextRequest):
    prediction = model.predict([request.text])
    PREDICTION_COUNT.inc()
    return {"prediction": prediction[0]}

@app.get("/metrics")
async def metrics():
    return Response(generate_latest(), media_type=CONTENT_TYPE_LATEST)

Errores comunes

Monitorear solo disponibilidad: Muchos equipos solo verifican si la API responde (HTTP 200), pero ignoran la latencia o la exactitud del modelo. Solución: Agrega métricas de rendimiento (ej., percentil 95 de latencia) y métricas de modelo (ej., distribucion de scores).
Exponer demasiadas métricas: Instrumentar cada función puede generar ruido y sobrecargar Prometheus. Solución: Enfócate en métricas clave (SLOs) como latencia < 200ms y error rate < 0.1%.
No configurar alertas: Un dashboard sin alertas es solo un mural bonito. Solución: En Grafana, configura alertas cuando la latencia supere un umbral por más de 5 minutos, o la tasa de error suba al 1%.
Olvidar el contexto: Las métricas crudas (ej., 1000 requests) no dicen nada sin contexto (ej., comparado con ayer). Solución: Usa Grafana para mostrar tendencias y agregar anotaciones (ej., despliegue de nuevo modelo).
No probar el dashboard en carga: Un dashboard que funciona en local puede fallar en producción bajo alta carga. Solución: Haz pruebas de carga con herramientas como Locust y verifica que las métricas se actualicen correctamente.

Checklist de dominio

¿Tu API expone un endpoint /metrics con formato Prometheus?
¿Tienes al menos un panel en Grafana mostrando latencia y tasa de error en tiempo real?
¿Configuraste alertas para notificarte si la latencia supera tu SLO?
¿Incluiste métricas de negocio (ej., predicciones por clase del modelo)?
¿Documentaste cómo acceder al dashboard y qué hacer si salta una alerta?
¿Probaste el dashboard simulando una caída de la API o un pico de tráfico?
¿Revisas el dashboard diariamente para identificar tendencias o anomalías?

Configura un Dashboard de Monitoreo para tu API FastAPI

En este ejercicio, tomarás una API FastAPI existente (o crearás una simple) y la instrumentarás con un dashboard de monitoreo usando Prometheus y Grafana. Sigue estos pasos:

Prepara tu entorno: Asegúrate de tener Docker instalado. Crea un directorio para el proyecto con dos archivos: app.py (tu API) y docker-compose.yml.
Escribe la API: En app.py, crea una API FastAPI con un endpoint /predict que simule un modelo ML (ej., devuelva un número aleatorio como predicción). Instrumenta la API con las métricas del ejemplo anterior (REQUEST_COUNT, REQUEST_LATENCY).
Configura Docker Compose: En docker-compose.yml, define tres servicios:
- app: Tu API FastAPI (puerto 8000).
- prometheus: Imagen oficial de Prometheus con un archivo prometheus.yml que raspe app:8000/metrics cada 15s.
- grafana: Imagen oficial de Grafana (puerto 3000), con un volumen para persistir dashboards.
Despliega y prueba: Ejecuta docker-compose up. Accede a tu API en http://localhost:8000/docs y haz algunas peticiones a /predict. Verifica que las métricas estén en http://localhost:8000/metrics.
Configura Grafana: Accede a Grafana en http://localhost:3000 (usuario: admin, contraseña: admin). Agrega Prometheus como fuente de datos (URL: http://prometheus:9090). Importa el dashboard con ID 3662 (FastAPI Prometheus) y personaliza un panel para mostrar la latencia de tu API.
Documenta: Crea un README.md con instrucciones para reproducir el setup y una captura de pantalla de tu dashboard funcionando.

Pistas

Usa el código de ejemplo de la lección como base para tu app.py, pero simplifica el modelo a algo como return {"prediction": random.randint(0,1)}.
En docker-compose.yml, asegúrate de que los servicios estén en la misma red y que Prometheus apunte a app:8000 (no localhost).
En Grafana, al importar el dashboard, revisa que las métricas coincidan con las que expone tu API (ej., api_request_latency_seconds).

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Práctica: Configurar Dashboard de Monitoreo para una API