Architektura produkce: monitorování, alerting, škálování
Na této stránce
Tvoje aplikace v produkci: tři pilíře
Nasazení aplikace s LLM do produkce není jen o kódu. Spolehlivost garantují tři pilíře: monitorování pro pozorování, alerting pro reakci a škálování pro zvládnutí zátěže. Tvoří řetěz a ten je jen tak silný, jak silný je jeho nejslabší článek: metriky, na které se nikdo nedívá, jsou k ničemu, alerty bez reakčního postupu jsou šum a škálování, které se spustí příliš pozdě, je prostě výpadek. Tato závěrečná lekce spojuje všechny koncepty z kurzu do kompletní produkční architektury.
Pozoruj: co měřit
Čtyři rodiny metrik pokrývají to podstatné: objem volání, latenci, chyby a náklady, rozdělené podle modelu. Právě rozdělení podle modelu dělá dashboard použitelným – globální míra chyb 3 % ti nic neřekne, zatímco stejná hodnota soustředěná na jediný model okamžitě ukáže viníka.
Níže uvedená třída akumuluje tyto metriky v paměti pomocí posuvného okna 10 000 latencí, aby proces nerostl do nekonečna. Všimni si použití percentilů místo průměrů: průměrná latence služby LLM je téměř vždy zavádějící, protože hrstka velmi pomalých volání zmizí v průměru, přestože právě na ty si uživatelé stěžují.
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
Sběr dat musí být samozřejmě systematický. Ruční instrumentace každého volání garantuje, že na jedno zapomeneš – a pravděpodobně na to, které způsobí problémy. Níže uvedený dekorátor přesouvá měření na úroveň funkce volání: blok finally zaznamená latenci a úspěšnost bez ohledu na okolnosti, i když se vyhodí výjimka.
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
Počítadla tokenů a náklady zůstávají v této verzi nulová, protože objekt odpovědi není v době záznamu k dispozici. Doplň je čtením polí usage vrácených API: bez těchto informací bude tvůj dashboard věrně zobrazovat sloupec s nulovými náklady.
Reaguj: stupňované alerty
Alert má hodnotu jen tehdy, pokud vyžaduje akci. Proto systém rozlišuje dvě prahové hodnoty pro každou metriku: varovný práh signalizující drift, který je třeba během dne prozkoumat, a kritický práh ospravedlňující probuzení člověka. Záměna těchto dvou vede k nejhoršímu možnému výsledku – tým, který se naučil ignorovat upozornění.
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"],
},
)
Alerty na hodinové náklady jsou těmi nejčastěji zapomínanými, což je škoda: neomezená smyčka opakování nebo dvakrát spuštěná dávková úloha výsledkem není chyba, ale účet. Je to jediná bezpečnostní síť, která detekuje tento typ incidentu přímo v průběhu jeho vzniku.
Absorbuj: tři mechanismy odolnosti
Když API vrátí chybu, opakování věci zhoršuje: přidáváš zátěž službě, která už má problémy, a nutíš své uživatele čekat nadarmo. Jistič (circuit breaker) tuto logiku obrací. Po definovaném počtu po sobě jdoucích selhání otevře obvod a okamžitě odmítne následná volání, poté se po prodlevě resetu pokusí znovu.
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
Jistič chrání tvoji aplikaci, ale nezajišťuje její funkčnost. To je role záložního modelu (model fallback), který zkouší alternativy v pořadí a přeskočí ty, jejichž obvody jsou již otevřené. Jedna důležitá poznámka k návrhu: pořadí seznamu je produktové rozhodnutí, nikoliv technické. Na první místo dej model, který poskytuje očekávanou službu, následovaný těmi, které poskytují degradovanou, ale přijatelnou službu – mírně méně přesná odpověď je lepší než nedostupná zpráva.
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.")
Třetí mechanismus se týká dimenzování. Řízení počtu workerů na základě velikosti fronty, nikoliv využití CPU, je správným reflexem pro službu, která většinu času čeká na síťové odpovědi: CPU zahálí, zatímco fronta roste. Všimni si asymetrie v aplikovaném pravidle – při škálování nahoru zdvojnásobujeme a při škálování dolů polovíme, přičemž používáme široce oddělené prahy (100 vs. 10). Tato mezera zabraňuje oscilaci: bez ní by systém neustále vytvářel a ničil workery kolem bodu zlomu.
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
Kontrolní seznam pro nasazení do produkce
Tento kurz končí kontrolním seznamem, který je třeba projít před otevřením aplikace pro veřejnost. Každá položka odkazuje na lekci, kterou jsi prošel; pokud se ti některá zdá nejasná, přečti si tuto lekci znovu před nasazením.
- Monitorování latence (p50, p95, p99) a míry chyb
- Alerty nakonfigurované na kritické prahy
- Jistič (circuit breaker) na ochranu před selháním API
- Nakonfigurovaný záložní model (model fallback)
- Povolena moderace vstupů a výstupů
- Implementováno omezování sazby na straně klienta (rate limiting)
- Strukturované logy pro ladění
- Automatizované evals v CI/CD
- Rozpočet na náklady s alerty
- Verzionovaná dokumentace promptů
Klíčové poznatky
- Monitorování pokrývá latenci, chyby, náklady a kvalitu odpovědí
- Sleduj percentily latence, nikdy jen průměr
- Alerty musí být stupňované: nejprve varování, pak kritické
- Jistič chrání před kaskádovým selháním; záložní model zajišťuje dostupnost
- Kontrolní seznam pro produkci předchází kritickým opomenutím
Ověř si své znalosti
Latence, náklady, evals: produkční reflexy v pěti otázkách.
1. Jaké jsou hlavní páky pro snížení latence?
Odpověď: Streamování (vnímaná latence), cacheování promptů (stabilní prefixy), Predicted Outputs, když je odpověď z velké části předvídatelná (Chat Completions, na modelech vyřazených 14. ledna 2027), a optimalizace samotného promptu – měřeno end-to-end.
2. Kdy byste měli použít Batch API?
Odpověď: Pro masivní zpracování bez požadavků na reálný čas: asynchronní dávky za snížené náklady – řazení, obohacování nebo generování velkého objemu dat nemá místo na synchronní cestě.
3. Co dělá komprese konverzace?
Odpověď: Komprimuje dlouhou historii (souhrny, prořezávání), aby se vešla do kontextu a kontrolovala náklady – zásadní pro agenty a dlouhé relace.
4. Jaký je účel frameworku Evals v CI/CD?
Odpověď: Automaticky spouštět vaše evaluace při každé změně promptu nebo modelu: regrese je detekována při commitu, nikoliv v produkci.
5. Co zahrnuje kompletní produkční architektura?
Odpověď: Monitorování (latence, náklady, kvalita), alerting, asynchronní fronty, moderaci ve velkém měřítku a plán škálování – AI v produkci je systém, nikoliv volání API.
Měř, cacheuj, dávkuj, neustále evaluuj: čtyři návyky, které dělají aplikace rychlými, úspornými a spolehlivými.