Arhitektura za produkciju: nadzor, upozorenja, skaliranje
Na ovoj stranici
Tvoja aplikacija u produkciji: tri stupa
Postavljanje LLM aplikacije u produkciju nije samo pitanje koda. Tri stupa jamče pouzdanost: nadzor za promatranje, upozorenja za reakciju i skaliranje za apsorpciju opterećenja. Oni čine lanac, a lanac je onoliko jak koliko i njegova najslabija karika: metrike koje nitko ne gleda su beskorisne, upozorenja bez postupka odgovora su šum, a skaliranje koje se uključi prekasno je jednostavno kvar. Ova završna lekcija povezuje sve koncepte iz tečaja u cjelovitu produkcijsku arhitekturu.
Promatraj: što mjeriti
Četiri obitelji metrika pokrivaju bitno: volumen poziva, latencija, pogreške i troškovi, raščlanjeno po modelu. Raščlamba po modelu je ono što nadzornu ploču čini djelotvornom—globalna stopa pogrešaka od 3% ti ne govori ništa, dok ta ista brojka koncentrirana na jedan model odmah ukazuje na krivca.
Donja klasa akumulira ove metrike u memoriji, koristeći klizni prozor od 10.000 latencija kako bi spriječila beskonačan rast procesa. Obrati pažnju na korištenje percentila umjesto prosjeka: prosječna latencija LLM servisa gotovo je uvijek zavaravajuća jer šačica vrlo sporih poziva nestaje u prosjeku, a upravo su to one na koje se tvoji korisnici žale.
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
Naravno, prikupljanje mora biti sustavno. Ručno instrumentiranje svakog poziva jamči da ćeš jedan zaboraviti—i vjerojatno baš onaj koji uzrokuje probleme. Donji dekorator pomiče mjerenje na razinu funkcije poziva: blok finally bilježi latenciju i uspjeh bez obzira na sve, čak i kada se iznimka propagira.
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
Brojači tokena i troškovi u ovoj verziji ostaju na nuli jer objekt odgovora nije dostupan u trenutku bilježenja. Dopuni ih čitanjem polja usage koja vraća API: bez ovih informacija, tvoja nadzorna ploča će vjerno prikazivati stupac nultih troškova.
Reagiraj: stupnjevita upozorenja
Upozorenje ima vrijednost samo ako poziva na akciju. Zato sustav razlikuje dva praga po metrici: prag upozorenja, koji signalizira odstupanje koje treba ispitati tijekom dana, i kritični prag, koji opravdava buđenje nekoga. Miješanje ta dva proizvodi najgori mogući ishod—tim koji je naučio ignorirati obavijesti.
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"],
},
)
Upozorenja o satnim troškovima su ona koja se najčešće zaboravljaju, a to je šteta: neograničena petlja ponovnog pokušaja ili batch posao pokrenut dva puta rezultiraju računom, a ne pogreškom. To je jedina sigurnosna mreža koja detektira ovu vrstu incidenta dok se događa.
Apsorbiraj: tri mehanizma otpornosti
Kada API vrati pogrešku, ponovni pokušaj pogoršava stvari: dodaješ opterećenje servisu koji je već u problemu i tjeraš svoje korisnike da čekaju uzalud. Prekidač kruga (circuit breaker) okreće ovu logiku. Nakon definiranog broja uzastopnih neuspjeha, otvara krug i odmah odbija naredne pozive, zatim pokušava ponovno nakon kašnjenja resetiranja.
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
Prekidač kruga štiti tvoju aplikaciju; no, ne osigurava njezin rad. To je uloga rezervnog modela (fallback), koji isprobava alternative redom, preskačući one čiji su krugovi već otvoreni. Jedna dizajnerska točka koju treba zapamtiti: redoslijed popisa je produktna odluka, a ne tehnička. Prvo stavi model koji isporučuje očekivanu uslugu, a zatim one koji isporučuju degradiranu, ali prihvatljivu uslugu—nešto manje oštar odgovor bolji je od nedostupne poruke.
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.")
Treći mehanizam tiče se dimenzioniranja. Upravljanje brojem radnika (workers) na temelju veličine reda, a ne opterećenja CPU-a, ispravan je refleks za servis koji većinu vremena provodi čekajući mrežne odgovore: CPU miruje dok red raste. Obrati pažnju na asimetriju u primijenjenom pravilu—udvostručujemo pri povećanju i prepolovimo pri smanjenju, s широко razdvojenim pragovima (100 naspram 10). Ovaj jaz sprječava oscilacije: bez njega, sustav bi provodio vrijeme stvarajući i uništavajući radnike oko točke prevrata.
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
Kontrolni popis za produkcijsko objavljivanje
Ovaj tečaj završava kontrolnim popisom koji trebaš proći prije otvaranja svoje aplikacije javnosti. Svaka stavka odnosi se na lekciju koju si pokrio/la; ako se bilo koja čini nejasnom, ponovno pročitaj tu lekciju prije objavljivanja.
- Nadzor latencije (p50, p95, p99) i stopa pogrešaka
- Upozorenja konfigurirana na kritičnim pragovima
- Prekidač kruga za zaštitu od kvarova API-ja
- Konfiguriran rezervni model (fallback)
- Omogućena moderacija ulaza i izlaza
- Implementirano ograničavanje stope (rate limiting) na strani klijenta
- Strukturirani zapisi (logovi) za otklanjanje grešaka
- Automatizirane evaluacije u CI/CD
- Proračun troškova s upozorenjima
- Dokumentacija promptova s verzioniranjem
Ključne točke
- Nadzor pokriva latenciju, pogreške, troškove i kvalitetu odgovora
- Prati percentile latencije, nikada samo prosjek
- Upozorenja moraju biti stupnjevita: prvo upozorenje, zatim kritično
- Prekidač kruga štiti od kaskadnih kvarova; fallback osigurava dostupnost
- Produkcijski kontrolni popis sprječava kritične propuste
Provjeri svoje znanje
Latencija, troškovi, evaluacije: produkcijski refleksi u pet pitanja.
1. Koje su glavne poluge za smanjenje latencije?
Odgovor: Streaming (percipirana latencija), keširanje prompta (stabilni prefiksi), Predviđeni izlazi (Predicted Outputs) kada je odgovor uglavnom predvidiv (Chat Completions, na modelima povučenim 14. siječnja 2027.) i optimizacija samog prompta—mjereno od kraja do kraja.
2. Kada trebaš koristiti Batch API?
Odgovor: Za masovnu obradu bez ograničenja u stvarnom vremenu: asinkrone serije po smanjenom trošku—rangiranje, obogaćivanje ili generiranje velikih volumena nemaju mjesta na sinkronom putu.
3. Što radi kompresija razgovora?
Odgovor: Kompresira dugu povijest (sažeci, uklanjanje) kako bi stala unutar konteksta i kontrolirala troškove—ključno za agente i duge sesije.
4. Koja je svrha okvira Evals u CI/CD-u?
Odgovor: Za automatsko pokretanje tvojih evaluacija pri svakoj promjeni prompta ili modela: regresija se detektira pri commitu, a ne u produkciji.
5. Što uključuje cjelovita produkcijska arhitektura?
Odgovor: Nadzor (latencija, troškovi, kvaliteta), upozorenja, asinkrone redove, moderaciju u mjerilu i plan skaliranja—AI u produkciji je sustav, a ne API poziv.
Mjeri, keširaj, grupiraj u serije, neprestano evaluiraj: četiri navike koje čine aplikacije brzim, vitkim i pouzdanim.