Gyártási architektúra: monitorozás, riasztás, méretezés
Ezen az oldalon
Alkalmazásod éles környezetben: a három pillér
Egy LLM-alkalmazás éles környezetbe helyezése nem csupán a kódról szól. Három pillér garantálja a megbízhatóságot: a monitorozás a megfigyeléshez, a riasztás a reagáláshoz és a méretezés a terhelés elnyeléséhez. Ezek egy láncot alkotnak, és egy lánc csak annyira erős, mint a leggyengébb láncszeme: a senki által nem figyelt metrikák haszontalanok, a válaszadási eljárás nélküli riasztások csak zajt keltenek, a túl későn bekapcsoló méretezés pedig egyszerűen kiesést jelent. Ez az utolsó lecke a tanfolyam összes koncepcióját egy teljes gyártási architektúrába foglalja össze.
Megfigyelés: mit mérjünk?
Négy metrikacsalád fedi le a lényeget: hívásszám, késleltetés, hibák és költség, modellenként lebontva. A modellenkénti lebontás teszi cselekvőképessé a műszerfalat – a globális 3%-os hibaarány semmit sem mond, míg ugyanez az érték egyetlen modellre koncentrálva azonnal rámutat a bűnösre.
Az alábbi osztály ezeket a metrikákat gyűjti össze a memóriában, egy 10 000 késleltetési értékből álló csúszó ablakot használva, hogy megakadályozza a folyamat végtelen növekedését. Figyeld meg a percentilisek használatát az átlagok helyett: egy LLM-szolgáltatás átlagos késleltetése szinte mindig félrevezető, mert néhány nagyon lassú hívás elvész az átlagban, pedig éppen ezek miatt panaszkodnak a felhasználóid.
import time
from dataclasses import dataclass, field
from collections import defaultdict
@dataclass
class ProductionMetrics:
"""Összegyűjti a lényeges gyártási metrikákat."""
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
# Csak az utolsó 10 000 késleltetést tartsuk meg
if len(self.latencies[model]) > 10_000:
self.latencies[model] = self.latencies[model][-10_000:]
def percentile(self, model: str, p: float) -> float:
"""Kiszámít egy késleltetési percentilist."""
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:
"""Teljes műszerfalat generál."""
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
Természetesen a gyűjtésnek szisztematikusnak kell lennie. Ha minden hívást manuálisan instrumentálsz, garantált, hogy elfelejtesz egyet – és valószínűleg éppen azt, amelyik gondot okoz. Az alábbi dekorátor a mérést a hívási függvény szintjére helyezi: a finally blokk rögzíti a késleltetést és a sikert függetlenül attól, mi történik, még akkor is, ha kivétel propagálódik.
import openai
import functools
metrics = ProductionMetrics()
def monitor(func):
"""Dekorátor, amely minden API-hívást monitoroz."""
@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
A tokenszámlálók és a költség ebben a verzióban nullák maradnak, mert a válaszobjektum a rögzítés pillanatában még nem áll rendelkezésre. Egészítsd ki őket az API által visszaadott használati (usage) mezők olvasásával: ezen információk nélkül a műszerfalad hűségesen nullák oszlopát fogja megjeleníteni.
Reagálás: fokozatos riasztások
Egy riasztás csak akkor értékes, ha cselekvésre szólít fel. Ezért a rendszer metrikánként két küszöbértéket különböztet meg: egy figyelmeztető küszöböt, amely napközbeni vizsgálatot igénylő elcsúszást jelez, és egy kritikus küszöböt, amely indokolttá teszi valaki felébresztését. A kettő összekeverése a lehető legrosszabb kimenetelt eredményezi: egy csapatot, amely megtanulta figyelmen kívül hagyni az értesítéseket.
from enum import Enum
class AlertLevel(Enum):
INFO = "info"
WARNING = "warning"
CRITICAL = "critical"
class AlertSystem:
"""Riasztásokat indít a metrikák alapján."""
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]:
"""Ellenőrzi a metrikákat és riasztásokat generál."""
alerts = []
for model in metrics.counters:
# Hibaarány
rate = metrics.error_rate(model)
if rate >= self.thresholds["error_rate"]["critical"]:
alerts.append({
"level": AlertLevel.CRITICAL,
"message": (
f"KRITIKUS hibaarány ennél a modellnél: {model}: "
f"{rate:.1%}"
),
"model": model,
})
elif rate >= self.thresholds["error_rate"]["warning"]:
alerts.append({
"level": AlertLevel.WARNING,
"message": (
f"Magas hibaarány ennél a modellnél: {model}: "
f"{rate:.1%}"
),
"model": model,
})
# Késleltetés
p99 = metrics.percentile(model, 99)
if p99 >= self.thresholds["latency_p99"]["critical"]:
alerts.append({
"level": AlertLevel.CRITICAL,
"message": (
f"KRITIKUS p99 késleltetés ennél a modellnél: {model}: "
f"{p99:.1f}s"
),
"model": model,
})
self.sent_alerts.extend(alerts)
return alerts
async def notify(self, alerts: list[dict]):
"""Értesítéseket küld (webhook, e-mail, Slack)."""
import httpx
for alert in alerts:
if alert["level"] == AlertLevel.CRITICAL:
# Azonnali értesítés
async with httpx.AsyncClient() as http:
await http.post(
"https://your-webhook.example.com/alerts",
json={
"level": alert["level"].value,
"message": alert["message"],
},
)
Az óránkénti költségriasztásokat felejtik el leggyakrabban, és ez kár: egy korlátlan újrapróbálkozási ciklus vagy egy kétszer elindított kötegelt feladat számlát eredményez, nem hibát. Ez az egyetlen biztonsági háló, amely észleli ezt a típusú incidienst még közben.
Elnyelés: három rugalmassági mechanizmus
Amikor az API hibát ad vissza, az újrapróbálkozás csak ront a helyzeten: terhelést adsz egy már bajban lévő szolgáltatásra, és hiába várakoztatod a saját felhasználóidat. A megszakító áramkör (circuit breaker) megfordítja ezt a logikát. A meghatározott számú egymást követő hiba után megnyitja az áramkört, és azonnal elutasítja a subsequent hívásokat, majd egy visszaállítási késleltetés után újra próbálkozik.
class CircuitBreaker:
"""Levágja a hívásokat túl sok hiba esetén."""
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:
# Kísérlet az áramkör zárására
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):
"""Végrehajtja a függvényt, ha az áramkör zárva van."""
if self.is_open:
raise RuntimeError(
"Áramkör nyitva — az API nem elérhető. "
f"Próbáld újra {self.reset_delay}s múlva."
)
try:
result = func(*args, **kwargs)
self.record_success()
return result
except Exception as e:
self.record_failure()
raise
A megszakító áramkör megvédi az alkalmazásodat, de nem teszi működőképessé. Ez a modell-tartalék (fallback) feladata, amely sorrendben próbálkozik alternatívákkal, kihagyva azokat, amelyeknek az áramköre már nyitva van. Egy tervezési pontra érdemes emlékezni: a lista sorrendje termékdöntés, nem technikai. Előre tedd azt a modellt, amelyik a várt szolgáltatást nyújtja, utána azokat, amelyek degradált, de elfogadható szolgáltatást biztosítanak – egy kicsit kevésbé éles válasz jobb, mint egy elérhetetlen üzenet.
class ModelFallback:
"""Hiba esetén tartalék modellre vált."""
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:
"""Minden modellt megpróbál, amíg választ nem kap."""
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("Minden modell elérhetetlen.")
A harmadik mechanizmus a méretezéssel foglalkozik. A munkafolyamatok számának a sorhossz alapján történő vezérlése, nem pedig a CPU-terhelés alapján, a helyes reflex egy olyan szolgáltatásnál, amely ideje nagy részét hálózati válaszokra várva tölti: a CPU tétlenül áll, miközben a sor nő. Figyeld meg az alkalmazott szabály aszimmetriáját – duplázunk felfelé méretezéskor és felezünk lefelé, szélesen elválasztott küszöbökkel (100 vs. 10). Ez a rés megakadályozza az oszcillációt: enélkül a rendszer folyamatosan munkafolyamatokat hozna létre és semmisítene meg a billenési pont körül.
class AutoScaler:
"""A munkafolyamatok számát a terhelés alapján igazítja."""
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:
"""Visszaadja az ajánlott munkafolyamatok számát."""
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
Gyártási telepítési ellenőrzőlista
Ez a tanfolyam azzal az ellenőrzőlistával zárul, amelyet végig kell futtatnod, mielőtt alkalmazásodat megnyitnád a nyilvánosság előtt. Minden tétel egy általad tárgyalt leckére utal; ha valamelyik nem világos, olvasd újra azt a leckét telepítés előtt.
- Késleltetés-monitorozás (p50, p95, p99) és hibaarányok
- Kritikus küszöbökön beállított riasztások
- Megszakító áramkör az API-hibák elleni védelemhez
- Konfigurált modell-tartalék
- Bemeneti és kimeneti moderálás engedélyezve
- Kliens oldali sebességkorlátozás implementálva
- Strukturált naplók a hibakereséshez
- Automatizált értékelések a CI/CD-ben
- Költségkeret riasztásokkal
- Verzionált prompt dokumentáció
Főbb megállapítások
- A monitorozás kiterjed a késleltetésre, hibákra, költségekre és a válasz minőségére
- Kövesd nyomon a késleltetés percentiliseit, soha ne csak az átlagot
- A riasztásoknak fokozatosaknak kell lenniük: először figyelmeztetés, majd kritikus
- A megszakító áramkör megvéd a hibaláncolatoktól; a tartalék biztosítja a rendelkezésre állást
- Egy gyártási ellenőrzőlista megelőzi a kritikus mulasztásokat
Teszteld a tudásod
Késleltetés, költségek, értékelések: gyártási reflexek öt kérdésben.
1. Mik a késleltetés csökkentésének fő eszközei?
Válasz: Streaming (észlelt késleltetés), prompt gyorsítótárazás (stabil prefixek), Előre jelzett kimenetek (Predicted Outputs), amikor a válasz nagyban előre jelezhető (Chat Completions, a 2027. január 14-én nyugdíjazott modelleken), és maga a prompt optimalizálása – végpontok között mérve.
2. Mikor kell használni a Batch API-t?
Válasz: Hatalmas feldolgozáshoz valós idejű követelmények nélkül: aszinkron kötegek csökkentett költséggel – a rangsorolás, dúsítás vagy nagy volumenű generálás nem való a szinkron útvonalra.
3. Mit csinál a beszélgetés-tömörítés?
Válasz: Összenyomja a hosszú előzményeket (összefoglalók, metszés), hogy illeszkedjen a kontextusba és kontrollálja a költségeket – elengedhetetlen ügynököknél és hosszú munkameneteknél.
4. Mi az Evals keretrendszer célja a CI/CD-ben?
Válasz: Az értékelések automatikus futtatása minden prompt- vagy modellváltoztatáskor: a regressziót a commitnál észleljük, nem éles környezetben.
5. Mit tartalmaz egy teljes gyártási architektúra?
Válasz: Monitorozást (késleltetés, költségek, minőség), riasztást, aszinkron sorokat, nagy léptékű moderálást és egy méretezési tervet – az AI éles környezetben egy rendszer, nem egy API-hívás.
Mérj, gyorsítótárazz, kötegeld, értékelj folyamatosan: négy szokás, amely gyors, karcsú és megbízható alkalmazásokat eredményez.