Ir al contenido principal
Español— Elegir un idioma
Menú

Arquitectura de producción: monitorización, alertas y escalado

Lección 20 de 20 Actualizado el 3 de noviembre de 2026 Avanzado
En esta página
  1. Tu aplicación en producción: los tres pilares
  2. Observar: qué medir
  3. Reaccionar: alertas graduadas
  4. Absorber: tres mecanismos de resiliencia
  5. Lista de comprobación para el despliegue en producción
  6. Puntos clave
  7. Pon a prueba tus conocimientos

Tu aplicación en producción: los tres pilares

Desplegar una aplicación de LLM en producción no se reduce solo al código. Tres pilares garantizan la fiabilidad: la monitorización para observar, las alertas para reaccionar y el escalado para absorber la carga. Forman una cadena, y una cadena es tan fuerte como su eslabón más débil: las métricas que nadie consulta son inútiles, las alertas sin un procedimiento de respuesta son ruido, y un escalado que se activa demasiado tarde es simplemente una interrupción del servicio. Esta última lección reúne todos los conceptos del curso en una arquitectura de producción completa.

Observar: qué medir

Cuatro familias de métricas cubren lo esencial: volumen de llamadas, latencia, errores y coste, desglosadas por modelo. El desglose por modelo es lo que hace que el panel de control sea útil: una tasa de error global del 3 % no te dice nada, mientras que esa misma cifra concentrada en un único modelo señala inmediatamente al culpable.

La clase siguiente acumula estas métricas en memoria, utilizando una ventana deslizante de 10 000 latencias para evitar que el proceso crezca indefinidamente. Observa el uso de percentiles en lugar de promedios: la latencia media de un servicio de LLM casi siempre engaña, porque un puñado de llamadas muy lentas se diluye en el promedio, aunque sean precisamente esas las que provocan las quejas de tus usuarios.

import time
from dataclasses import dataclass, field
from collections import defaultdict

@dataclass
class ProductionMetrics:
    """Recopila las métricas esenciales de producción."""

    counters: dict = field(default_factory=lambda: defaultdict(int))
    latencies: dict = field(default_factory=lambda: defaultdict(list))
    errors: dict = field(default_factory=lambda: defaultdict(int))
    costs: dict = field(default_factory=lambda: defaultdict(float))

    def record_call(
        self,
        model: str,
        latency: float,
        input_tokens: int,
        output_tokens: int,
        cost: float,
        success: bool,
    ):
        self.counters[model] += 1
        self.latencies[model].append(latency)
        self.costs[model] += cost

        if not success:
            self.errors[model] += 1

        # Mantener solo las últimas 10 000 latencias
        if len(self.latencies[model]) > 10_000:
            self.latencies[model] = self.latencies[model][-10_000:]

    def percentile(self, model: str, p: float) -> float:
        """Calcula un percentil de latencia."""
        values = sorted(self.latencies.get(model, []))
        if not values:
            return 0.0
        idx = int(len(values) * p / 100)
        return values[min(idx, len(values) - 1)]

    def error_rate(self, model: str) -> float:
        total = self.counters.get(model, 0)
        if total == 0:
            return 0.0
        return self.errors.get(model, 0) / total

    def dashboard(self) -> dict:
        """Genera un panel de control completo."""
        dashboard = {}
        for model in self.counters:
            dashboard[model] = {
                "calls": self.counters[model],
                "latency_p50": f"{self.percentile(model, 50):.2f}s",
                "latency_p99": f"{self.percentile(model, 99):.2f}s",
                "error_rate": f"{self.error_rate(model):.2%}",
                "total_cost": f"${self.costs[model]:.2f}",
            }
        return dashboard

Por supuesto, la recopilación debe ser sistemática. Instrumentar manualmente cada llamada garantiza que olvidarás alguna, y probablemente será justo la que cause problemas. El decorador siguiente traslada la medición al nivel de la función de llamada: el bloque finally registra la latencia y el éxito pase lo que pase, incluso cuando se propaga una excepción.

import openai
import functools

metrics = ProductionMetrics()

def monitor(func):
    """Decorador que monitoriza cada llamada a la API."""
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        model = kwargs.get("model", args[0] if args else "unknown")
        start = time.perf_counter()
        success = True

        try:
            result = func(*args, **kwargs)
            return result
        except Exception as e:
            success = False
            raise
        finally:
            latency = time.perf_counter() - start
            metrics.record_call(
                model=model,
                latency=latency,
                input_tokens=0,
                output_tokens=0,
                cost=0,
                success=success,
            )

    return wrapper

Los contadores de tokens y el coste permanecen en cero en esta versión porque el objeto de respuesta no está disponible en el momento del registro. Complétalos leyendo los campos usage devueltos por la API: sin esta información, tu panel de control mostrará fielmente una columna de costes nulos.

Reaccionar: alertas graduadas

Una alerta solo tiene valor si exige una acción. Por eso el sistema distingue dos umbrales por métrica: un umbral de advertencia, que señala una desviación que debe examinarse durante el día, y un umbral crítico, que justifica despertar a alguien. Confundir ambos produce el peor resultado posible: un equipo que ha aprendido a ignorar las notificaciones.

from enum import Enum

class AlertLevel(Enum):
    INFO = "info"
    WARNING = "warning"
    CRITICAL = "critical"

class AlertSystem:
    """Dispara alertas basadas en métricas."""

    def __init__(self):
        self.thresholds = {
            "error_rate": {"warning": 0.05, "critical": 0.15},
            "latency_p99": {"warning": 10.0, "critical": 30.0},
            "hourly_cost": {"warning": 50.0, "critical": 200.0},
        }
        self.sent_alerts: list[dict] = []

    def check(self, metrics: ProductionMetrics) -> list[dict]:
        """Comprueba las métricas y genera alertas."""
        alerts = []

        for model in metrics.counters:
            # Tasa de error
            rate = metrics.error_rate(model)
            if rate >= self.thresholds["error_rate"]["critical"]:
                alerts.append({
                    "level": AlertLevel.CRITICAL,
                    "message": (
                        f"Tasa de error CRÍTICA para {model}: "
                        f"{rate:.1%}"
                    ),
                    "model": model,
                })
            elif rate >= self.thresholds["error_rate"]["warning"]:
                alerts.append({
                    "level": AlertLevel.WARNING,
                    "message": (
                        f"Tasa de error elevada para {model}: "
                        f"{rate:.1%}"
                    ),
                    "model": model,
                })

            # Latencia
            p99 = metrics.percentile(model, 99)
            if p99 >= self.thresholds["latency_p99"]["critical"]:
                alerts.append({
                    "level": AlertLevel.CRITICAL,
                    "message": (
                        f"Latencia p99 CRÍTICA para {model}: "
                        f"{p99:.1f}s"
                    ),
                    "model": model,
                })

        self.sent_alerts.extend(alerts)
        return alerts

    async def notify(self, alerts: list[dict]):
        """Envía notificaciones (webhook, correo, Slack)."""
        import httpx

        for alert in alerts:
            if alert["level"] == AlertLevel.CRITICAL:
                # Notificación inmediata
                async with httpx.AsyncClient() as http:
                    await http.post(
                        "https://your-webhook.example.com/alerts",
                        json={
                            "level": alert["level"].value,
                            "message": alert["message"],
                        },
                    )

Las alertas de coste horario son las que se olvidan con más frecuencia, y es una lástima: un bucle de reintentos sin límite o un trabajo por lotes lanzado dos veces generan una factura, no un error. Es la única red de seguridad que detecta este tipo de incidentes mientras ocurren.

Absorber: tres mecanismos de resiliencia

Cuando la API devuelve un error, reintentar empeora las cosas: añades carga a un servicio que ya tiene problemas y haces esperar a tus usuarios para nada. El cortacircuitos invierte esta lógica. Tras un número definido de fallos consecutivos, abre el circuito y rechaza inmediatamente las llamadas posteriores, volviendo a intentarlo tras un retraso de reinicio.

class CircuitBreaker:
    """Corta las llamadas cuando hay demasiados errores."""

    def __init__(
        self,
        open_threshold: int = 5,
        reset_delay: float = 60.0,
    ):
        self.threshold = open_threshold
        self.reset_delay = reset_delay
        self.consecutive_failures = 0
        self.opened_at: float | None = None

    @property
    def is_open(self) -> bool:
        if self.opened_at is None:
            return False
        if time.time() - self.opened_at > self.reset_delay:
            # Intentar cerrar el circuito
            self.opened_at = None
            self.consecutive_failures = 0
            return False
        return True

    def record_success(self):
        self.consecutive_failures = 0
        self.opened_at = None

    def record_failure(self):
        self.consecutive_failures += 1
        if self.consecutive_failures >= self.threshold:
            self.opened_at = time.time()

    def call(self, func, *args, **kwargs):
        """Ejecuta la función si el circuito está cerrado."""
        if self.is_open:
            raise RuntimeError(
                "Circuito abierto — API no disponible. "
                f"Reintenta en {self.reset_delay}s."
            )
        try:
            result = func(*args, **kwargs)
            self.record_success()
            return result
        except Exception as e:
            self.record_failure()
            raise

El cortacircuitos protege tu aplicación, pero no hace que funcione. Ese es el papel del fallback de modelo, que prueba alternativas en orden, saltando aquellas cuyos circuitos ya están abiertos. Un punto de diseño que debes recordar: el orden de la lista es una decisión de producto, no técnica. Coloca primero el modelo que ofrece el servicio esperado, seguido de aquellos que ofrecen un servicio degradado pero aceptable: una respuesta ligeramente menos precisa es mejor que un mensaje de no disponibilidad.

class ModelFallback:
    """Cambia a un modelo de respaldo en caso de fallo."""

    def __init__(self):
        self.models = ["gpt-5.6-terra", "gpt-5.6-sol", "gpt-5.6-luna"]
        self.circuits = {
            m: CircuitBreaker() for m in self.models
        }

    def call(self, prompt: str) -> str:
        """Prueba cada modelo hasta obtener una respuesta."""
        client = openai.OpenAI()

        for model in self.models:
            circuit = self.circuits[model]
            if circuit.is_open:
                continue

            try:
                response = circuit.call(
                    client.responses.create,
                    model=model,
                    input=prompt,
                )
                return response.output_text
            except Exception:
                continue

        raise RuntimeError("Todos los modelos no están disponibles.")

El tercer mecanismo concerne al dimensionamiento. Ajustar el número de trabajadores basándose en el tamaño de la cola en lugar de en la carga de la CPU es el reflejo correcto para un servicio que pasa la mayor parte del tiempo esperando respuestas de red: la CPU permanece inactiva mientras la cola crece. Observa la asimetría en la regla aplicada: duplicamos al escalar hacia arriba y dividimos por dos al escalar hacia abajo, con umbrales muy separados (100 frente a 10). Esta brecha evita la oscilación: sin ella, el sistema pasaría el tiempo creando y destruyendo trabajadores alrededor del punto de inflexión.

class AutoScaler:
    """Ajusta el número de trabajadores según la carga."""

    def __init__(
        self,
        min_workers: int = 2,
        max_workers: int = 50,
        scale_up_threshold: int = 100,
        scale_down_threshold: int = 10,
    ):
        self.min_workers = min_workers
        self.max_workers = max_workers
        self.up_threshold = scale_up_threshold
        self.down_threshold = scale_down_threshold
        self.active_workers = min_workers

    def adjust(self, queue_size: int) -> int:
        """Devuelve el número recomendado de trabajadores."""
        if queue_size > self.up_threshold:
            self.active_workers = min(
                self.active_workers * 2,
                self.max_workers,
            )
        elif queue_size < self.down_threshold:
            self.active_workers = max(
                self.active_workers // 2,
                self.min_workers,
            )

        return self.active_workers

Lista de comprobación para el despliegue en producción

Este curso termina con la lista de comprobación que debes repasar antes de abrir tu aplicación al público. Cada elemento hace referencia a una lección que ya has cubierto; si alguno no te queda claro, vuelve a leer esa lección antes de desplegar.

  • Monitorización de latencia (p50, p95, p99) y tasas de error
  • Alertas configuradas en umbrales críticos
  • Cortacircuitos para protegerse de fallos de la API
  • Fallback de modelo configurado
  • Moderación de entrada y salida activada
  • Limitación de tasa (rate limiting) implementada en el cliente
  • Registros estructurados para la depuración
  • Evaluaciones automatizadas en CI/CD
  • Presupuesto de costes con alertas
  • Documentación de prompts versionada

Puntos clave

  • La monitorización abarca latencia, errores, costes y calidad de la respuesta
  • Rastrea percentiles de latencia, nunca solo el promedio
  • Las alertas deben ser graduadas: advertencia y luego crítica
  • El cortacircuitos protege contra cascadas de fallos; el fallback garantiza la disponibilidad
  • Una lista de comprobación de producción evita omisiones críticas

Pon a prueba tus conocimientos

Latencia, costes, evaluaciones: reflejos de producción en cinco preguntas.

1. ¿Cuáles son las principales palancas para reducir la latencia?

Respuesta: Streaming (latencia percibida), caché de prompts (prefijos estables), salidas predichas (Predicted Outputs) cuando la respuesta es en gran medida predecible (Chat Completions, en modelos retirados el 14 de enero de 2027) y la optimización del propio prompt, medida de extremo a extremo.

2. ¿Cuándo debes usar la Batch API?

Respuesta: Para procesamiento masivo sin restricciones de tiempo real: lotes asíncronos a coste reducido. La clasificación, el enriquecimiento o la generación de volumen no tienen cabida en la ruta síncrona.

3. ¿Qué hace la compactación de conversación?

Respuesta: Comprime el historial largo (resúmenes, poda) para ajustarse al contexto y controlar los costes; es esencial para agentes y sesiones largas.

4. ¿Cuál es el propósito del marco de Evals en CI/CD?

Respuesta: Ejecutar automáticamente tus evaluaciones en cada cambio de prompt o modelo: la regresión se detecta en el commit, no en producción.

5. ¿Qué incluye una arquitectura de producción completa?

Respuesta: Monitorización (latencia, costes, calidad), alertas, colas asíncronas, moderación a escala y un plan de escalado. La IA en producción es un sistema, no una llamada a la API.

Mide, almacena en caché, procesa por lotes y evalúa continuamente: cuatro hábitos que hacen que las aplicaciones sean rápidas, ligeras y fiables.