Architektūra gamybai: stebėjimas, įspėjimai, mastelio keitimas
Šiame puslapyje
Tavo programa gamyboje: trys ramstai
LLM programos diegimas į gamybą nėra tik kodas. Tris ramstus užtikrina patikimumą: stebėjimas (kad matytum), įspėjimai (kad reaguotum) ir mastelio keitimas (kad atlaikytum apkrovą). Jie sudaro grandinę, o grandinė yra tokia stipri, koks yra silpniausias jos grandis: metrikos, į kurias niekas nežiūri, yra nenaudingos; įspėjimai be reagavimo procedūros yra triukšmas; o mastelio keitimas, kuris įsijungia per vėlai, tiesiog reiškia sutrikimą. Ši paskutinė pamoka sujungia visus kurso konceptus į vientisą gamybos architektūrą.
Stebėk: ką matuoti
Keturių šeimos metrikos apima esmę: kvietimų skaičių, delsą, klaidas ir kainą, suskirstytą pagal modelius. Būtent skirstymas pagal modelius daro prietaisų skydelį veiksmingu – bendras 3 % klaidų rodiklis tau nieko nepasako, tačiau tas pats skaičius, sutelktas viename modelyje, iškart nurodo kaltininką.
Toliau pateikta klasė kaupia šias metrikas atmintyje, naudodama 10 000 delsos reikšmių slankųjį langą, kad procesas neaugtų be galo. Atkreipk dėmesį, kad naudojami percentiliai, o ne vidurkiai: LLM paslaugos vidutinė delsa beveik visada klaidina, nes keletas labai lėtų kvietimų „paslepiami“ vidurkyje, nors būtent dėl jų skundžiasi naudotojai.
import time
from dataclasses import dataclass, field
from collections import defaultdict
@dataclass
class ProductionMetrics:
"""Renka pagrindines gamybos metrikas."""
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
# Paliekame tik paskutines 10 000 delsos reikšmių
if len(self.latencies[model]) > 10_000:
self.latencies[model] = self.latencies[model][-10_000:]
def percentile(self, model: str, p: float) -> float:
"""Apskaičiuoja delsos percentilį."""
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:
"""Generuoja išsamų prietaisų skydelį."""
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
Žinoma, rinkimas turi būti sistemingas. Rankinis kiekvieno kvietimo instrumentavimas garantuoja, kad vieną pamirši – ir greičiausiai būtent tą, kuris sukels problemų. Toliau pateiktas dekoratorius perkelia matavimą į kvietimo funkcijos lygmenį: blokas finally fiksuoja delsą ir sėkmę nepaisant nieko, net jei išimtis plinta toliau.
import openai
import functools
metrics = ProductionMetrics()
def monitor(func):
"""Dekoratorius, stebintis kiekvieną API kvietimą."""
@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
Šioje versijoje žetonų skaitikliai ir kaina lieka nuliniai, nes atsakymo objektas įrašymo metu nėra prieinamas. Užpildyk juos nuskaitydami API grąžinamus naudojimo laukus: be šios informacijos tavo prietaisų skydelis sąžiningai rodys nulinių kainų stulpelį.
Reaguok: laipsniški įspėjimai
Įspėjimas yra vertingas tik tada, kai ragina veikti. Štai kodėl sistema kiekvienai metrikai išskiria dvi slenkstines reikšmes: įspėjimo slenkstį, signalizuojantį apie nukrypimą, kurį reikia išnagrinėti darbo metu, ir kritinį slenkstį, pateisinantį žmogaus pažadinimą. Šių dviejų supainiojimas sukelia blogiausią įmanomą rezultatą – komandą, kuri išmoko ignoruoti pranešimus.
from enum import Enum
class AlertLevel(Enum):
INFO = "info"
WARNING = "warning"
CRITICAL = "critical"
class AlertSystem:
"""Generuoja įspėjimus pagal metrikas."""
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]:
"""Tikrina metrikas ir generuoja įspėjimus."""
alerts = []
for model in metrics.counters:
# Klaidų rodiklis
rate = metrics.error_rate(model)
if rate >= self.thresholds["error_rate"]["critical"]:
alerts.append({
"level": AlertLevel.CRITICAL,
"message": (
f"KRITINIS klaidų rodiklis modeliui {model}: "
f"{rate:.1%}"
),
"model": model,
})
elif rate >= self.thresholds["error_rate"]["warning"]:
alerts.append({
"level": AlertLevel.WARNING,
"message": (
f"Didelis klaidų rodiklis modeliui {model}: "
f"{rate:.1%}"
),
"model": model,
})
# Delsa
p99 = metrics.percentile(model, 99)
if p99 >= self.thresholds["latency_p99"]["critical"]:
alerts.append({
"level": AlertLevel.CRITICAL,
"message": (
f"KRITINIS p99 delsa modeliui {model}: "
f"{p99:.1f}s"
),
"model": model,
})
self.sent_alerts.extend(alerts)
return alerts
async def notify(self, alerts: list[dict]):
"""Siunčia pranešimus (webhook, el. paštas, Slack)."""
import httpx
for alert in alerts:
if alert["level"] == AlertLevel.CRITICAL:
# Nedelsiant siunčiamas pranešimas
async with httpx.AsyncClient() as http:
await http.post(
"https://your-webhook.example.com/alerts",
json={
"level": alert["level"].value,
"message": alert["message"],
},
)
Valandiniai kainų įspėjimai yra tie, kuriuos dažniausiai pamiršta, ir tai gaila: neribotas kartojimų ciklas arba du kartus paleistas grupinis darbas sukelia sąskaitą, o ne klaidą. Tai vienintelis saugos tinklas, aptinkantis tokio tipo incidentus jiems vykstant.
Sugerk: trys atsparumo mechanizmai
Kai API grąžina klaidą, kartojimas tik pablogina situaciją: tu didini apkrovą jau sutrikusiai paslaugai ir verči savo naudotojus laukti veltui. Grandinės pertraukiklis (circuit breaker) apverčia šią logiką. Po nustatyto skaičiaus nuoseklių nesėkmių jis „atidaro“ grandinę ir iškart atmeta vėlesnius kvietimus, o tada bando iš naujo po nustatyto atstatymo delsos laiko.
class CircuitBreaker:
"""Nutraukia kvietimus, kai įvyksta per daug klaidų."""
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:
# Bandoma uždaryti grandinę
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):
"""Vykdo funkciją, jei grandinė uždara."""
if self.is_open:
raise RuntimeError(
"Grandinė atidaryta – API nepasiekiamas. "
f"Bandykite po {self.reset_delay}s."
)
try:
result = func(*args, **kwargs)
self.record_success()
return result
except Exception as e:
self.record_failure()
raise
Grandinės pertraukiklis saugo tavo programą, tačiau jos nepriverčia veikti. Tai yra modelio atsarginio varianto (fallback) užduotis, kuris bando alternatyvas eilės tvarka, praleisdamas tas, kurių grandinės jau atidarytos. Vienas svarbus dizaino aspektas: sąrašo tvarka yra produkto sprendimas, o ne techninis. Pirmiausia dėk modelį, teikiantį pageidaujamą paslaugą, o po jo – tuos, kurie teikia suprastintą, bet priimtiną paslaugą – šiek tiek mažiau aštrus atsakymas yra geriau nei neprieinamas pranešimas.
class ModelFallback:
"""Nesėkmės atveju perjungia į atsarginį 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:
"""Bando kiekvieną modelį, kol gaunamas atsakymas."""
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("Visi modeliai nepasiekiami.")
Trečiasis mechanizmas susijęs su pajėgumų planavimu. Darbuotojų skaičiaus valdymas pagal eilės dydį, o ne CPU apkrovą, yra teisingas refleksas paslaugai, kuri daugumą laiko praleidžia laukdama tinklo atsakymų: CPU lieka neveiklus, o eilė auga. Atkreipk dėmesį į taikomos taisyklės asimetriją – didinant mastelį dvigubiname, o mažinant – perpus, naudojant labai nutolusius slenkstinius rodiklius (100 prieš 10). Šis tarpas neleidžia svyruoti: be jo sistema nuolat kurtų ir naikintų darbuotojus ties lūžio tašku.
class AutoScaler:
"""Koreguoja darbuotojų skaičių pagal apkrovą."""
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:
"""Grąžina rekomenduojamą darbuotojų skaičių."""
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
Gamybos diegimo kontrolinis sąrašas
Šis kursas baigiamas kontroliniu sąrašu, kurį reikia peržiūrėti prieš atveriant programą viešai. Kiekvienas punktas nurodo į pamoką, kurią jau išėjai; jei kuris nors atrodo neaiškus, perskaityk tą pamoką prieš diegdamas.
- Delsos stebėjimas (p50, p95, p99) ir klaidų rodikliai
- Įspėjimai sukonfigūruoti kritiniams slenkstiams
- Grandinės pertraukiklis apsaugai nuo API gedimų
- Sukonfigūruotas modelio atsarginis variantas
- Įjungta įvesties ir išvesties moderacija
- Įgyvendintas kliento pusės dažnio ribojimas
- Struktūruoti žurnalai derinimui
- Automatizuoti vertinimai CI/CD grandinėje
- Kainos biudžetas su įspėjimais
- Versijuota promptų dokumentacija
Svarbiausi punktai
- Stebėjimas apima delsą, klaidas, kainas ir atsakymų kokybę
- Sekite delsos percentilius, niekada tik vidurkį
- Įspėjimai turi būti laipsniški: pirmiausia įspėjimas, paskui kritinis
- Grandinės pertraukiklis saugo nuo gedimų kaskados; atsarginis variantas užtikrina prieinamumą
- Gamybos kontrolinis sąrašas neleidžia praleisti kritinių dalykų
Patikrink savo žinias
Delsa, kainos, vertinimai: gamybos refleksai penkiuose klausimuose.
1. Kokie yra pagrindiniai svertai delsumui mažinti?
Atsakymas: Srautinis perdavimas (suvokiama delsa), promptų talpyklojimas (stabilūs priešdėliai), numatytos išvestys, kai atsakymas didžiąja dalimi nuspėjamas (Chat Completions, modeliuose, pašalintuose 2027 m. sausio 14 d.), ir paties prompto optimizavimas – matuojama nuo galo iki galo.
2. Kada reikėtų naudoti Batch API?
Atsakymas: Masiniam apdorojimui be realaus laiko reikalavimų: asinchroninės grupės sumažinta kaina – reitingavimas, praturtinimas arba didelės apimties generavimas neturi vietos sinchroniniame kelyje.
3. Ką daro pokalbio glaustinimas?
Atsakymas: Jis suspaudžia ilgą istoriją (santraukos, genėjimas), kad tilptų į kontekstą ir kontroliuotų kainas – tai būtina agentams ir ilgoms sesijoms.
4. Kokia yra Evals sistemos paskirtis CI/CD?
Atsakymas: Automatiškai vykdyti tavo vertinimus kiekvieną kartą pakeitus promptą ar modelį: regresija aptinkama įvykdžius commit, o ne gamyboje.
5. Ką apima pilna gamybos architektūra?
Atsakymas: Stebėjimą (delsa, kainos, kokybė), įspėjimus, asinchronines eiles, mastelio moderaciją ir mastelio keitimo planą – AI gamyboje yra sistema, o ne API kvietimas.
Matuok, talpykluok, grupuok, nuolat vertink: keturi įpročiai, darantys programas greitas, lengvas ir patikimas.