Arhitektura za produkcijo: nadzor, opozarjanje, skaliranje
Na tej strani
Tvoja aplikacija v produkciji: trije stebri
Uvedba aplikacije z velikim jezikovnim modelom (LLM) v produkcijo ni zgolj stvar kode. Trije stebri zagotavljajo zanesljivost: nadzor za opazovanje, opozarjanje za reakcijo in skaliranje za prevzemanje obremenitve. Ti tvorijo verigo, veriga pa je močna toliko, kolikor je močan njen najšibkejši člen: metrike, ki jih nihče ne gleda, so neuporabne, opozorila brez postopka odzivanja so šum, skaliranje, ki se vklopi prepozno, pa je zgolj izpad storitve. Ta zadnja lekcija združuje vse koncepte tečaja v celovito produkcijsko arhitekturo.
Opazuj: kaj meriti
Štiri družine metrik pokrivajo bistvo: količina klicev, zakasnitev (latency), napake in stroški, razčlenjeni po modelu. Razčlenitev po modelu je tisto, zaradi česar je nadzorna plošča uporabna – globalna stopnja napak 3 % ti ne pove ničesar, medtem ko ista številka, skoncentrirana na enem samem modelu, takoj pokaže na krivca.
Spodnji razred zbira te metrike v pomnilniku z uporabo drsečega okna 10.000 zakasnitev, da se proces ne bi neskončno povečeval. Upoštevaj uporabo percentilov namesto povprečij: povprečna zakasnitev storitve LLM je skoraj vedno zavajajoča, ker peščica zelo počasnih klicev izgine v povprečju, čeprav so prav ti tisti, na katere se tvoji uporabniki pritožujejo.
import time
from dataclasses import dataclass, field
from collections import defaultdict
@dataclass
class ProductionMetrics:
"""Zbira ključne produkcijske metrike."""
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
# Ohrani le zadnjih 10.000 zakasnitev
if len(self.latencies[model]) > 10_000:
self.latencies[model] = self.latencies[model][-10_000:]
def percentile(self, model: str, p: float) -> float:
"""Izračuna percentil zakasnitve."""
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:
"""Generira celovito nadzorno ploščo."""
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
Seveda mora biti zbiranje sistematično. Ročno instrumentiranje vsakega klica zagotavlja, da boš enega pozabil – in verjetno prav tistega, ki povzroča težave. Spodnji dekorator premakne merjenje na raven funkcije klica: blok finally zabeleži zakasnitev in uspešnost ne glede na vse, tudi ko se izjema razširi naprej.
import openai
import functools
metrics = ProductionMetrics()
def monitor(func):
"""Dekorator, ki nadzira vsak klic API-ja."""
@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
Števci žetonov in stroški v tej različici ostanejo ničelni, ker objekt odgovora v času beleženja še ni na voljo. Dopolni jih z branjem polj uporabe (usage), ki jih vrne API: brez teh informacij bo tvoja nadzorna plošča zvesto prikazovala stolpec ničelnih stroškov.
Reagiraj: stopnjevana opozorila
Opozorilo je vredno le, če zahteva ukrepanje. Zato sistem razlikuje dva praga za vsako metriko: opozorilni prag, ki signalizira odmik, ki ga je treba pregledati čez dan, in kritični prag, ki upravičuje bujenje nekoga. Zamenjava teh dveh povzroči najslabši možni izid – ekipo, ki se je naučila ignorirati obvestila.
from enum import Enum
class AlertLevel(Enum):
INFO = "info"
WARNING = "warning"
CRITICAL = "critical"
class AlertSystem:
"""Sproži opozorila na podlagi metrik."""
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]:
"""Preveri metrike in generira opozorila."""
alerts = []
for model in metrics.counters:
# Stopnja napak
rate = metrics.error_rate(model)
if rate >= self.thresholds["error_rate"]["critical"]:
alerts.append({
"level": AlertLevel.CRITICAL,
"message": (
f"KRITIČNA stopnja napak za {model}: "
f"{rate:.1%}"
),
"model": model,
})
elif rate >= self.thresholds["error_rate"]["warning"]:
alerts.append({
"level": AlertLevel.WARNING,
"message": (
f"Visoka stopnja napak za {model}: "
f"{rate:.1%}"
),
"model": model,
})
# Zakasnitev
p99 = metrics.percentile(model, 99)
if p99 >= self.thresholds["latency_p99"]["critical"]:
alerts.append({
"level": AlertLevel.CRITICAL,
"message": (
f"KRITIČNA zakasnitev p99 za {model}: "
f"{p99:.1f}s"
),
"model": model,
})
self.sent_alerts.extend(alerts)
return alerts
async def notify(self, alerts: list[dict]):
"""Pošlje obvestila (webhook, e-pošta, Slack)."""
import httpx
for alert in alerts:
if alert["level"] == AlertLevel.CRITICAL:
# Takojšnje obvestilo
async with httpx.AsyncClient() as http:
await http.post(
"https://your-webhook.example.com/alerts",
json={
"level": alert["level"].value,
"message": alert["message"],
},
)
Opozorila o urnih stroških so tista, na katera najpogosteje pozabimo, kar je škoda: neomejena zanka za ponovne poskuse ali dvakrat zagnano serijsko opravilo (batch job) povzroči račun, ne napake. To je edina varnostna mreža, ki zazna tovrstne incidente, medtem ko se dogajajo.
Prevzemi: trije mehanizmi odpornosti
Ko API vrne napako, ponovni poskus stvari poslabša: dodaš obremenitev storitvi, ki je že v težavah, in prisiliš svoje uporabnike, da čakajo zaman. Odklopnik (circuit breaker) obrne to logiko. Po določenem številu zaporednih napak odklopi tokokrog in takoj zavrne naslednje klice, nato pa po zamiku za ponastavitev poskusi znova.
class CircuitBreaker:
"""Prekine klice, ko pride do preveč napak."""
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:
# Poskus zaprtja tokokroga
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):
"""Izvede funkcijo, če je tokokrog zaprt."""
if self.is_open:
raise RuntimeError(
"Tokokrog odprt — API ni na voljo. "
f"Poskusi znova čez {self.reset_delay}s."
)
try:
result = func(*args, **kwargs)
self.record_success()
return result
except Exception as e:
self.record_failure()
raise
Odklopnik ščiti tvojo aplikacijo, vendar je ne naredi delujoče. To je vloga nadomestnega modela (fallback), ki po vrsti preizkusi alternative in preskoči tiste, katerih tokokrogi so že odprti. Pomembna oblikovna točka: vrstni red seznama je produktna odločitev, ne tehnična. Najprej postavi model, ki zagotavlja pričakovano storitev, sledijo pa tisti, ki nudijo poslabšano, a sprejemljivo storitev – nekoliko manj oster odgovor je boljši od sporočila o nedostopnosti.
class ModelFallback:
"""V primeru napake preklopi na rezervni model."""
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:
"""Preizkusi vsak model, dokler ne dobi odgovora."""
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("Vsi modeli so nedostopni.")
Tretji mehanizem se nanaša na dimenzioniranje. Upravljanje števila delavcev na podlagi velikosti čakalne vrste namesto obremenitve procesorja je pravi refleks za storitev, ki večino časa čaka na omrežne odgovore: procesor miruje, medtem ko čakalna vrsta raste. Upoštevaj asimetrijo v uporabljenem pravilu – ob povečanju podvojimo, ob zmanjšanju pa prepolovimo, s široko ločenima pragovoma (100 proti 10). Ta razmik preprečuje nihanje: brez njega bi sistem neprestano ustvarjal in uničeval delavce okoli prelomne točke.
class AutoScaler:
"""Prilagodi število delavcev glede na obremenitev."""
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:
"""Vrne priporočeno število delavcev."""
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
Kontrolni seznam za uvedbo v produkcijo
Ta tečaj se zaključuje s kontrolnim seznamom, ki ga moraš preiti, preden svojo aplikacijo odpreš za javnost. Vsaka točka se nanaša na lekcijo, ki si jo obravnaval; če se katera zdi nejasna, ponovno preberi to lekcijo pred uvedbo.
- Nadzor zakasnitve (p50, p95, p99) in stopenj napak
- Opozorila, konfigurirana na kritičnih pragovih
- Odklopnik za zaščito pred napakami API-ja
- Konfiguriran nadomestni model (fallback)
- Omogočena moderacija vhodov in izhodov
- Implementirana omejitev hitrosti (rate limiting) na strani odjemalca
- Strukturirani dnevniki za odpravljanje napak
- Avtomatizirane evalvacije v CI/CD
- Proračun za stroške z opozorili
- Dokumentacija pozivov z verzioniranjem
Ključne ugotovitve
- Nadzor zajema zakasnitev, napake, stroške in kakovost odgovorov
- Sledi percentilom zakasnitve, nikoli le povprečju
- Opozorila morajo biti stopnjevana: najprej opozorilo, nato kritično
- Odklopnik ščiti pred kaskadnimi napakami; nadomestni model zagotavlja razpoložljivost
- Kontrolni seznam za produkcijo preprečuje kritične spreglede
Preveri svoje znanje
Zakasnitev, stroški, evalvacije: produkcijski refleksi v petih vprašanjih.
1. Kateri so glavni vzvodi za zmanjšanje zakasnitve?
Odgovor: Pretakanje (streaming) (zaznana zakasnitev), predpomnjenje pozivov (stabilne predpone), Predvideni izhodi (Predicted Outputs), ko je odgovor večinoma predvidljiv (Chat Completions, na modelih, umaknjenih 14. januarja 2027), in optimizacija samega poziva – merjeno od konca do konca.
2. Kdaj uporabiti Batch API?
Odgovor: Za obsežno obdelavo brez omejitev v realnem času: asinhroni sklopi po znižani ceni – razvrščanje, obogatitev ali generiranje velikih količin nimajo mesta na sinhroni poti.
3. Kaj naredi stiskanje pogovora?
Odgovor: Stisne dolgo zgodovino (povzetki, obrezovanje), da se prilega kontekstu in nadzoruje stroške – bistveno za agente in dolge seje.
4. Kakšen je namen ogrodja Evals v CI/CD?
Odgovor: Samodejno izvajanje tvojih evalvacij ob vsaki spremembi poziva ali modela: regresija je zaznana ob potrditvi (commit), ne v produkciji.
5. Kaj vključuje celovita produkcijska arhitektura?
Odgovor: Nadzor (zakasnitev, stroški, kakovost), opozarjanje, asinhrone čakalne vrste, moderacijo v obsegu in načrt skaliranja – AI v produkciji je sistem, ne klic API-ja.
Meri, predpomni, združi v serije, neprestano evalviraj: štiri navade, ki naredijo aplikacije hitre, vitke in zanesljive.