Concepto clave

El monitoreo de rendimiento en APIs de Machine Learning es como tener un tablero de control en un coche de carreras. No solo te muestra la velocidad actual, sino que tambien alerta sobre problemas antes de que causen un accidente. En produccion, las APIs ML deben manejar peticiones concurrentes, procesar datos en tiempo real y mantener latencias predecibles.

El rendimiento se mide mediante metricas clave como latencia (tiempo de respuesta), throughput (peticiones por segundo), uso de recursos (CPU, memoria) y tasa de errores. Un sistema bien monitorizado permite detectar cuellos de botella, optimizar modelos y garantizar SLA (Service Level Agreements) con los usuarios.

Como funciona en la practica

Imagina que tienes un modelo de clasificacion de imagenes desplegado. Primero, instrumentas el codigo para registrar metricas en cada peticion. Luego, configuras un sistema como Prometheus para recolectar datos y Grafana para visualizarlos. Finalmente, estableces alertas cuando las metricas superan umbrales criticos.

Paso a paso: 1) Agrega middleware de logging en FastAPI, 2) Expone endpoints de metricas, 3) Configura exportadores para herramientas de monitoring, 4) Define dashboards con las metricas mas importantes, 5) Establece politicas de escalado automatico basadas en el rendimiento.

Codigo en accion

Implementacion basica de metricas con Prometheus en FastAPI:

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

app = FastAPI()

# Metricas
REQUEST_COUNT = Counter('http_requests_total', 'Total HTTP requests', ['method', 'endpoint', 'status'])
REQUEST_LATENCY = Histogram('http_request_duration_seconds', 'HTTP request latency', ['endpoint'])

@app.middleware("http")
async def monitor_requests(request: Request, call_next):
    start_time = time.time()
    response = await call_next(request)
    process_time = time.time() - start_time
    
    REQUEST_COUNT.labels(method=request.method, endpoint=request.url.path, status=response.status_code).inc()
    REQUEST_LATENCY.labels(endpoint=request.url.path).observe(process_time)
    
    return response

@app.get("/predict")
async def predict(data: dict):
    # Simulacion de inferencia ML
    import random
    result = {"class": random.choice(["cat", "dog"]), "confidence": random.random()}
    return result

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

Mejora con cache para reducir latencia:

from functools import lru_cache
from fastapi import FastAPI
import time

app = FastAPI()

# Antes: Sin cache
@app.get("/predict_slow")
async def predict_slow(features: str):
    # Procesamiento pesado cada vez
    time.sleep(0.5)
    return {"result": "prediction"}

# Despues: Con cache
@lru_cache(maxsize=100)
def heavy_processing(features: str):
    time.sleep(0.5)
    return {"result": "prediction"}

@app.get("/predict_fast")
async def predict_fast(features: str):
    return heavy_processing(features)

Errores comunes

No monitorizar metricas de negocio: Solo medir latencia tecnica, ignorando precision del modelo o satisfaccion del usuario.
Subestimar el costo del logging: Registrar demasiados datos puede saturar el sistema y aumentar costos de almacenamiento.
Ignorar el contexto de las metricas: Una latencia alta puede ser normal durante picos de trafico, no siempre indica un problema.
No probar el sistema de alertas: Configurar alertas que nunca se activan o, peor, que generan falsos positivos constantemente.
Optimizar prematuramente: Enfocarse en micro-optimizaciones sin identificar los cuellos de botella reales mediante profiling.

Checklist de dominio

¿Has implementado al menos tres metricas clave (ej. latencia, throughput, tasa de errores) en tu API?
¿Puedes identificar el percentil 95 de latencia en tus endpoints mas criticos?
¿Tienes dashboards que muestren el rendimiento en tiempo real y historico?
¿Has configurado alertas automaticas para degradacion de rendimiento?
¿Realizas pruebas de carga regularmente para validar la escalabilidad?
¿Optimizas el codigo basandote en datos de profiling, no en suposiciones?
¿Documentas los SLAs y monitorizas su cumplimiento?

Implementa un sistema de monitoreo para una API de ML

En este ejercicio, crearás un sistema completo de monitoreo para una API FastAPI que sirve un modelo de ML. Sigue estos pasos:

Crea una API FastAPI con un endpoint /predict que simule un modelo de clasificacion (puede devolver valores aleatorios).
Agrega middleware para registrar: tiempo de respuesta, codigo de estado HTTP y metodo de cada peticion.
Implementa un endpoint /metrics que exponga metricas en formato compatible con Prometheus.
Configura un dashboard en Grafana (o herramienta similar) que visualice: latencia promedio, peticiones por minuto y tasa de errores.
Genera trafico de prueba con una herramienta como Locust o Apache Bench y observa como se comportan las metricas.

Entrega el codigo de la API y capturas de pantalla del dashboard con metricas en funcionamiento.

Pistas

Usa la libreria prometheus-client para instrumentar facilmente las metricas.
Considera usar variables de entorno para configurar umbrales de alerta sin modificar el codigo.
Prueba con diferentes cargas de trabajo para ver como escalan las metricas.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Quiz: Monitoreo y Rendimiento

Quiz Interactivo