Salt la conținutul principal
Română— Alege o limbă
Meniu

Arhitectură de producție: monitorizare, alertare, scalare

Lecția 20 din 20 Actualizată 3 noiembrie 2026 Avansat
Pe această pagină
  1. Aplicația dumneavoastră în producție: cei trei piloni
  2. Observați: ce să măsurați
  3. Reacționați: alerte graduale
  4. Absorbiți: trei mecanisme de reziliență
  5. Lista de verificare pentru lansarea în producție
  6. Puncte cheie
  7. Testați-vă cunoștințele

Aplicația dumneavoastră în producție: cei trei piloni

Lansarea unei aplicații LLM în producție nu se rezumă doar la cod. Trei piloni garantează fiabilitatea: monitorizarea pentru a observa, alertarea pentru a reacționa și scalarea pentru a absorbi sarcina. Aceștia formează un lanț, iar un lanț este la fel de puternic precum veriga sa cea mai slabă: metricile pe care nimeni nu le consultă sunt inutile, alertele fără o procedură de răspuns sunt zgomot, iar scalarea care intervine prea târziu devine doar o întrerupere de serviciu. Această lecție finală reunește toate conceptele din curs într-o arhitectură completă de producție.

Observați: ce să măsurați

Patru familii de metrici acoperă esențialul: volumul apelurilor, latența, erorile și costurile, defalcate pe model. Defalcarea pe model este ceea ce face tabloul de bord acționabil—o rată globală de eroare de 3% nu vă spune nimic, în timp ce aceeași cifră concentrată pe un singur model indică imediat vinovatul.

Clasa de mai jos acumulează aceste metrici în memorie, folosind o fereastră glisantă de 10.000 de valori de latență pentru a preveni creșterea indefinită a procesului. Rețineți utilizarea percentilelor în locul mediilor: latența medie a unui serviciu LLM este aproape întotdeauna înșelătoare, deoarece o mână de apeluri foarte lente dispar în medie, deși acelea sunt exact cele despre care se plâng utilizatorii dumneavoastră.

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

@dataclass
class ProductionMetrics:
    """Collects essential production metrics."""

    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

        # Keep only the last 10,000 latencies
        if len(self.latencies[model]) > 10_000:
            self.latencies[model] = self.latencies[model][-10_000:]

    def percentile(self, model: str, p: float) -> float:
        """Calculates a latency percentile."""
        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:
        """Generates a complete dashboard."""
        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

Desigur, colectarea trebuie să fie sistematică. Instrumentarea manuală a fiecărui apel garantează că veți uita unul—și probabil chiar pe cel care cauzează probleme. Decoratorul de mai jos mută măsurarea la nivelul funcției de apel: blocul finally înregistrează latența și succesul indiferent de ce se întâmplă, chiar și atunci când o excepție se propagă.

import openai
import functools

metrics = ProductionMetrics()

def monitor(func):
    """Decorator that monitors every API call."""
    @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

Contoarele de tokeni și costurile rămân zero în această versiune deoarece obiectul de răspuns nu este disponibil la momentul înregistrării. Completați-le citind câmpurile de utilizare returnate de API: fără aceste informații, tabloul dumneavoastră de bord va afișa fidel o coloană de costuri zero.

Reacționați: alerte graduale

O alertă are valoare doar dacă solicită o acțiune. De aceea, sistemul distinge două praguri per metrică: un prag de avertizare, care semnalează o deviere de examinat în timpul zilei, și un prag critic, care justifică trezirea cuiva. Confundarea celor două produce cel mai nefast rezultat—o echipă care a învățat să ignore notificările.

from enum import Enum

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

class AlertSystem:
    """Triggers alerts based on metrics."""

    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]:
        """Checks metrics and generates alerts."""
        alerts = []

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

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

        self.sent_alerts.extend(alerts)
        return alerts

    async def notify(self, alerts: list[dict]):
        """Sends notifications (webhook, email, Slack)."""
        import httpx

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

Alertele privind costurile orare sunt cele mai des uitate, ceea ce este păcat: o buclă de reîncercare necontrolată sau un job batch lansat de două ori rezultă într-o factură, nu într-o eroare. Este singura plasă de siguranță care detectează acest tip de incident în timp ce se produce.

Absorbiți: trei mecanisme de reziliență

Când API-ul returnează o eroare, reîncercarea agravează situația: adăugați sarcină unui serviciu deja în dificultate și îi faceți pe utilizatorii dumneavoastră să aștepte degeaba. Întrerupătorul de circuit (circuit breaker) inversează această logică. După un număr definit de eșecuri consecutive, acesta deschide circuitul și respinge imediat apelurile ulterioare, încercând din nou după o întârziere de resetare.

class CircuitBreaker:
    """Cuts off calls when too many errors occur."""

    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:
            # Attempt to close the circuit
            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):
        """Executes the function if the circuit is closed."""
        if self.is_open:
            raise RuntimeError(
                "Circuit open — API unavailable. "
                f"Retry in {self.reset_delay}s."
            )
        try:
            result = func(*args, **kwargs)
            self.record_success()
            return result
        except Exception as e:
            self.record_failure()
            raise

Întrerupătorul de circuit vă protejează aplicația; totuși, nu o face să funcționeze. Acesta este rolul fallback-ului de model, care încearcă alternative în ordine, sărindu-le pe cele ale căror circuite sunt deja deschise. Un punct de design de reținut: ordinea listei este o decizie de produs, nu una tehnică. Puneți pe primul loc modelul care livrează serviciul așteptat, urmat de cele care livrează un serviciu degradat, dar acceptabil—un răspuns puțin mai puțin precis este mai bun decât un mesaj de indisponibilitate.

class ModelFallback:
    """Switches to a backup model in case of failure."""

    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:
        """Tries each model until a response is obtained."""
        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("All models are unavailable.")

Al treilea mecanism privește dimensionarea. Conducerea numărului de lucrători (workers) pe baza dimensiunii cozii, nu a încărcării CPU, este reflexul corect pentru un serviciu care își petrece majoritatea timpului așteptând răspunsuri de rețea: CPU-ul stă inactiv în timp ce coada crește. Rețineți asimetria din regula aplicată—dublăm la scalare în sus și înjumătățim la scalare în jos, cu praguri larg separate (100 față de 10). Acest decalaj previne oscilația: fără el, sistemul și-ar petrece timpul creând și distrugând lucrători în jurul punctului de basculare.

class AutoScaler:
    """Adjusts the number of workers based on load."""

    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:
        """Returns the recommended number of workers."""
        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 verificare pentru lansarea în producție

Acest curs se încheie cu lista de verificare de parcurs înainte de a deschide aplicația dumneavoastră publicului. Fiecare element face referire la o lecție pe care ați parcurs-o; dacă vreunul pare neclar, recitiți acea lecție înainte de lansare.

  • Monitorizarea latenței (p50, p95, p99) și a ratelor de eroare
  • Alerte configurate pe praguri critice
  • Întrerupător de circuit pentru protecție împotriva eșecurilor API
  • Fallback de model configurat
  • Moderare a intrărilor și ieșirilor activată
  • Limitare a ratei (rate limiting) implementată lato-client
  • Jurnale structurate pentru depanare
  • Evaluări automate în CI/CD
  • Buget de costuri cu alerte
  • Documentație versionată a prompturilor

Puncte cheie

  • Monitorizarea acoperă latența, erorile, costurile și calitatea răspunsului
  • Urmăriți percentilele de latență, niciodată doar media
  • Alertele trebuie să fie graduale: avertizare, apoi critic
  • Întrerupătorul de circuit protejează împotriva cascadelor de eșecuri; fallback-ul asigură disponibilitatea
  • O listă de verificare pentru producție previne omisiunile critice

Testați-vă cunoștințele

Latență, costuri, evaluări: reflexe de producție în cinci întrebări.

1. Care sunt principalele pârghii pentru reducerea latenței?

Răspuns: Streaming (latență percepută), cache-ul de prompt (prefixuri stabile), Predicted Outputs atunci când răspunsul este în mare parte predictibil (Chat Completions, pe modelele retrase la 14 ianuarie 2027) și optimizarea promptului însuși—măsurată cap-la-cap.

2. Când ar trebui să utilizați Batch API?

Răspuns: Pentru procesare masivă fără constrângeri de timp real: loturi asincrone la cost redus—clasarea, îmbogățirea sau generarea de volume nu își au locul pe calea sincronă.

3. Ce face compactarea conversației?

Răspuns: Comprimă istoricul lung (rezumate, eliminări) pentru a se încadra în context și a controla costurile—esențial pentru agenți și sesiuni lungi.

4. Care este scopul framework-ului Evals în CI/CD?

Răspuns: Pentru a rula automat evaluările dumneavoastră la fiecare modificare de prompt sau model: regresia este detectată la commit, nu în producție.

5. Ce include o arhitectură completă de producție?

Răspuns: Monitorizare (latență, costuri, calitate), alertare, cozi asincrone, moderare la scară și un plan de scalare—AI-ul în producție este un sistem, nu un apel API.

Măsurați, stocați în cache, procesați în loturi, evaluați continuu: patru obiceiuri care fac aplicațiile rapide, eficiente și fiabile.