Concepto clave

El monitoreo de latencia y uso de recursos es el proceso de medir y analizar el tiempo que tarda tu API en responder a las solicitudes y los recursos computacionales que consume durante la ejecución. Imagina que tu API es un restaurante: la latencia es el tiempo que tarda en servir un plato desde que se toma el pedido, y el uso de recursos son los ingredientes, cocineros y equipos necesarios para prepararlo. En producción, monitorear estos aspectos es crucial porque te permite detectar cuellos de botella, optimizar el rendimiento y garantizar que tu modelo de machine learning pueda manejar la carga esperada sin degradar la experiencia del usuario.

La latencia se mide típicamente en milisegundos e incluye el tiempo de procesamiento del modelo, la serialización de datos y la comunicación de red. El uso de recursos abarca CPU, memoria RAM, GPU (si aplica) y almacenamiento. Un monitoreo efectivo no solo captura métricas en tiempo real, sino que también establece límites (thresholds) que alertan cuando algo va mal, similar a un termómetro que suena si la temperatura de un horno es demasiado alta. Esto es especialmente importante en APIs de ML, donde los modelos pueden ser computacionalmente intensivos y sensibles a cambios en los datos de entrada.

Cómo funciona en la práctica

Para implementar monitoreo en una API de FastAPI, sigues estos pasos: primero, integras herramientas de medición como middleware para capturar latencia por solicitud. Segundo, agregas endpoints de salud que reporten el estado de los recursos. Tercero, configuras un sistema de logging estructurado para registrar métricas clave. Cuarto, despliegas un dashboard visual (por ejemplo, con Prometheus y Grafana) para analizar tendencias. En un escenario real, esto podría aplicarse a un modelo de clasificación de imágenes: mides cuánto tarda en predecir una imagen y cuánta memoria usa, ajustando los parámetros del servidor si la latencia supera los 500 ms o la memoria se acerca al límite del contenedor.

Codigo en accion

Aquí hay un ejemplo básico de cómo agregar monitoreo de latencia con middleware en FastAPI:

from fastapi import FastAPI, Request
import time
import psutil
import logging

app = FastAPI()
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    start_time = time.time()
    response = await call_next(request)
    process_time = time.time() - start_time
    response.headers["X-Process-Time"] = str(process_time)
    # Log de latencia y uso de recursos
    cpu_percent = psutil.cpu_percent()
    memory_info = psutil.virtual_memory()
    logger.info(f"Latencia: {process_time:.4f}s, CPU: {cpu_percent}%, Memoria: {memory_info.percent}%")
    return response

@app.get("/predict")
async def predict(item: dict):
    # Simulación de un modelo de ML
    time.sleep(0.1)  # Latencia simulada
    return {"prediction": "clase_1", "confidence": 0.95}

@app.get("/health")
async def health_check():
    return {"status": "healthy", "cpu": psutil.cpu_percent(), "memory": psutil.virtual_memory().percent}

Refactorización para mejor escalabilidad, usando una biblioteca como prometheus-fastapi-instrumentator:

from fastapi import FastAPI
from prometheus_fastapi_instrumentator import Instrumentator
import psutil

app = FastAPI()
Instrumentator().instrument(app).expose(app)

@app.get("/predict")
async def predict(item: dict):
    time.sleep(0.1)
    return {"prediction": "clase_1", "confidence": 0.95}

@app.get("/metrics")
async def metrics():
    # Endpoint para Prometheus
    return {"cpu_usage": psutil.cpu_percent(), "memory_usage": psutil.virtual_memory().percent}

Errores comunes

No establecer límites de latencia: Dejar que la API responda lentamente sin alertas puede llevar a timeouts y pérdida de usuarios. Solución: Define thresholds (por ejemplo, 1 segundo) y configura alertas en herramientas como Grafana.
Monitorear solo en promedio: Usar solo la latencia promedio oculta picos que afectan a usuarios específicos. Solución: Incluye percentiles (p95, p99) en tus métricas para capturar casos extremos.
Ignorar el uso de recursos en GPU: En modelos de deep learning, no monitorear la GPU puede causar cuellos de botella. Solución: Usa bibliotecas como nvidia-smi o pynvml para trackear uso de GPU.
Logs no estructurados: Registrar métricas en texto plano dificulta el análisis. Solución: Usa JSON logging para facilitar la agregación y consulta en sistemas como ELK Stack.
Falta de endpoints de salud: No tener un endpoint /health impide que los orquestadores de contenedores (como Kubernetes) detecten fallos. Solución: Implementa checks que verifiquen dependencias y recursos críticos.

Checklist de dominio

He integrado middleware en FastAPI para medir latencia por solicitud.
He configurado logging estructurado para registrar métricas de CPU y memoria.
He implementado un endpoint de salud que reporta el estado de los recursos.
He definido thresholds de latencia y uso de recursos para alertas tempranas.
He desplegado un dashboard visual (por ejemplo, con Prometheus/Grafana) para monitoreo en tiempo real.
He probado el monitoreo bajo carga simulada para validar escalabilidad.
He documentado los procedimientos de respuesta a incidentes basados en métricas.

Implementa Monitoreo en una API de FastAPI con Modelo ML

En este ejercicio, mejorarás una API básica de FastAPI que sirve un modelo de machine learning, agregando monitoreo de latencia y uso de recursos. Sigue estos pasos:

Clona o crea un proyecto FastAPI con un endpoint /predict que simule un modelo ML (por ejemplo, devuelva una predicción aleatoria).
Agrega middleware para medir el tiempo de procesamiento de cada solicitud y registra la latencia en logs estructurados (usa JSON format).
Integra la biblioteca psutil para monitorear el uso de CPU y memoria en el endpoint /health.
Configura un endpoint /metrics que exponga métricas en formato compatible con Prometheus (puedes usar prometheus-fastapi-instrumentator).
Prueba la API con herramientas como locust o ab para simular carga y verifica que las métricas se capturen correctamente.
Documenta tus hallazgos, incluyendo latencia promedio y pico de uso de recursos bajo carga.

Pistas

Usa el decorador @app.middleware("http") en FastAPI para medir tiempo al inicio y fin de cada request.
Para logs estructurados, configura logging con formato JSON usando bibliotecas como python-json-logger.
Asegúrate de instalar dependencias como prometheus-fastapi-instrumentator con pip antes de usarlas.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Monitoreo de Latencia y Uso de Recursos