Architektúra produkcie: monitorovanie, alerting, škálovanie
Na tejto strane
Tvoja aplikácia v produkcii: tri piliere
Nasadenie LLM aplikácie do produkcie nie je len o kóde. Tri piliere zaručujú spoľahlivosť: monitorovanie na pozorovanie, alerting na reakciu a škálovanie na zvládnutie záťaže. Tvoria reťaz a reťaz je taký silný, ako jeho najslabší článok: metriky, na ktoré sa nikto nepozerá, sú zbytočné, alerty bez postupu reakcie sú šum a škálovanie, ktoré sa spustí príliš neskoro, je výpadok. Táto záverečná lekcia spája všetky koncepty kurzu do kompletnej produkčnej architektúry.
Pozoruj: čo merať
Štyri rodiny metrík pokrývajú to podstatné: objem volaní, latencia, chyby a náklady, členené podľa modelu. Členenie podľa modelu je to, čo robí dashboard použiteľným – globálna miera chýb 3 % ti nič nepovie, zatiaľ čo tá istá hodnota sústredená na jeden model okamžite ukáže vinníka.
Nižšie uvedená trieda akumuluje tieto metriky v pamäti pomocou posuvného okna 10 000 latencií, aby sa proces neustále nezväčšoval. Všimni si použitie percentilov namiesto priemerov: priemerná latencia služby LLM je takmer vždy zavádzajúca, pretože handful veľmi pomalých volaní sa stratí v priemere, no práve tie sú dôvodom sťažností tvojich používateľov.
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
Zber musí byť samozrejme systematický. Ručné inštrumentovanie každého volania garantuje, že na jedno zabudneš – a pravdepodobne na to, ktoré spôsobí problémy. Nižšie uvedený dekorátor presúva meranie na úroveň funkcie volania: blok finally zaznamená latenciu a úspešnosť bez ohľadu na okolnosti, aj keď sa vyhodí výnimka.
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čítadlá tokenov a náklady zostávajú v tejto verzii nulové, pretože objekt odpovede nie je v čase záznamu k dispozícii. Doplň ich čítaním polí usage vrátených API: bez týchto informácií bude tvoj dashboard verne zobrazovať stĺpec nulových nákladov.
Reaguj: gradované alerty
Alert má hodnotu len vtedy, ak si vyžaduje akciu. Preto systém rozlišuje dva prahy pre každú metriku: varovný prah, ktorý signalizuje posun hodný preskúmania počas dňa, a kritický prah, ktorý ospravedlňuje prebudenie niekoho zo spánku. Zmiešanie týchto dvoch vedie k najhoršiemu možnému výsledku – tím, ktorý sa naučil ignorovať notifikácie.
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 sú tie, na ktoré sa najčastejšie zabúda, a to je škoda: neobmedzená slučka opakovaných pokusov alebo dávková úloha spustená dvakrát výsledkom nie je chyba, ale faktúra. Je to jediná bezpečnostná sieť, ktorá deteguje tento typ incidentu priamo v momente jeho vzniku.
Absorbuj: tri mechanizmy odolnosti
Keď API vráti chybu, opakovanie veci zhoršuje: pridávaš záťaž službe, ktorá už má problémy, a nútiš svojich používateľov čakať nazdarmo. Istič (circuit breaker) obracia túto logiku. Po definovanom počte po sebe idúcich zlyhaní otvorí obvod a okamžite odmietne následné volania, potom sa po oneskorení resetu pokúsi znova.
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
Istič chráni tvoju aplikáciu, ale nezabezpečuje jej funkčnosť. To je úlohou záložného modelu (model fallback), ktorý skúša alternatívy v poradí a preskakuje tie, ktorých obvody sú už otvorené. Jeden dizajnový bod, na ktorý treba pamätať: poradie zoznamu je produktové rozhodnutie, nie technické. Na prvé miesto daj model, ktorý poskytuje očakávanú službu, nasledovaný tými, ktoré poskytujú degradovanú, ale prijateľnú službu – trochu menej ostrá odpoveď je lepšia ako nedostupná sprá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.")
Tretí mechanizmus sa týka dimenzovania. Riadenie počtu workerov na základe veľkosti frontu namiesto zaťaženia CPU je správny reflex pre službu, ktorá trávi väčšinu času čakáním na odpovede siete: CPU sedí nečinne, zatiaľ čo front rastie. Všimni si asymetriu v aplikovanom pravidle – pri škálovaní nahor zdvojnásobujeme a pri škálovaní nadol polovičíme, pričom prahy sú široko oddelené (100 oproti 10). Táto medzera zabraňuje oscilácii: bez nej by systém trávil čas vytváraním a ničením workerov okolo bodu zvratu.
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ý zoznam nasadenia do produkcie
Tento kurz končí kontrolným zoznamom, ktorý si musíš prejsť pred otvorením aplikácie pre verejnosť. Každá položka odkazuje na lekciu, ktorú si prešiel; ak sa ti niečo zdá nejasné, prečítaj si túto lekciu znova pred nasadením.
- Monitorovanie latencie (p50, p95, p99) a mier chýb
- Alerty nakonfigurované na kritické prahy
- Istič na ochranu pred zlyhaniami API
- Nakonfigurovaný záložný model
- Povolená moderácia vstupov a výstupov
- Implementované obmedzenie rýchlosti na strane klienta
- Štruktúrované logy na ladenie
- Automatizované evals v CI/CD
- Rozpočet na náklady s alertmi
- Verzionovaná dokumentácia promptov
Kľúčové poznatky
- Monitorovanie pokrýva latenciu, chyby, náklady a kvalitu odpovedí
- Sleduj percentily latencie, nikdy len priemer
- Alerty musia byť gradované: najprv varovanie, potom kritické
- Istič chráni pred kaskádovým zlyhaním; záložný model zabezpečuje dostupnosť
- Kontrolný zoznam produkcie zabraňuje kritickým prehliadnutiam
Otestuj si svoje vedomosti
Latencia, náklady, evals: produkčné reflexy v piatich otázkach.
1. Aké sú hlavné páky na zníženie latencie?
Odpoveď: Streamovanie (vnímaná latencia), ukladanie promptov do cache (stabilné prefixy), Predpovedané výstupy, keď je odpoveď z veľkej časti predvídateľná (Chat Completions, na modeloch vyradených 14. januára 2027) a optimalizácia samotného promptu – merané end-to-end.
2. Kedy by si mal použiť Batch API?
Odpoveď: Pre masívne spracovanie bez požiadaviek na reálny čas: asynchrónne dávky za znížené náklady – hodnotenie, obohatenie alebo generovanie objemu nemajú miesto na synchrónnej ceste.
3. Čo robí kompresia konverzácie?
Odpoveď: Kompresuje dlhú históriu (súhrny, orezávanie), aby sa zmestila do kontextu a kontrolovali náklady – nevyhnutné pre agentov a dlhé relácie.
4. Aký je účel frameworku Evals v CI/CD?
Odpoveď: Automaticky spustiť tvoje evaluácie pri každej zmene promptu alebo modelu: regresia sa deteguje pri commite, nie v produkcii.
5. Čo zahŕňa kompletná produkčná architektúra?
Odpoveď: Monitorovanie (latencia, náklady, kvalita), alerting, asynchrónne fronty, moderácia vo veľkom mierke a plán škálovania – AI v produkcii je systém, nie volanie API.
Meraj, ukladaj do cache, dávkuje, neustále evaluuj: štyri návyky, ktoré robia aplikácie rýchlymi, štíhlymi a spoľahlivými.