Tootmisarhitektuur: jälgimine, hoiatused, skaleerimine
Sellel lehel
Sinu rakendus tootmises: kolm sammast
LLM-rakenduse tootmisse viimine ei seisne ainult koodis. Kolm sammast tagavad töökindluse: jälgimine vaatlemiseks, hoiatused reageerimiseks ja skaleerimine koormuse talumiseks. Need moodustavad ahela ning ahel on nii tugev kui selle nõrgim lüli: mõõdikud, mida keegi ei vaata, on kasutud; hoiatused ilma reageerimisprotseduurita on müra; ja liiga hilja käivituv skaleerimine tähendab lihtsalt seisakut. See viimane tund koondab kõik kursuse mõisted terviklikuks tootmisarhitektuuriks.
Vaatle: mida mõõta
Neli mõõdikute perekonda katavad põhiosa: päringute maht, latentsus, vead ja kulud, jaotatuna mudelite kaupa. Just mudelite kaupa jaotamine teeb armatuurlaua tegutsemisvõimeliseks – globaalne veamäär 3% ei ütle sulle midagi, samas kui sama näitaja, mis koondub ühele konkreetsele mudelile, osutab koheselt süüdlasele.
Allpool olev klass kogub need mõõdikud mällu, kasutades 10 000 latentsusväärtuse libisevat akent, et vältida protsessi lõpmatut kasvu. Pane tähele protsentiilide kasutamist keskmiste asemel: LLM-teenuse keskmine latentsus on peaaegu alati eksitav, sest käputäis väga aeglaseid päringuid kaob keskmisesse ära, ometi on need just need, mille üle kasutajad kaebavad.
import time
from dataclasses import dataclass, field
from collections import defaultdict
@dataclass
class ProductionMetrics:
"""Kogub olulisi tootmismõõdikuid."""
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
# Hoia alles ainult viimased 10 000 latentsust
if len(self.latencies[model]) > 10_000:
self.latencies[model] = self.latencies[model][-10_000:]
def percentile(self, model: str, p: float) -> float:
"""Arvutab latentsuse protsentiili."""
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:
"""Genereerib tervikliku armatuurlaua."""
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
Muidugi peab kogumine olema süstemaatiline. Iga päringu käsitsi instrumendimine garanteerib, et unustad ühe – ja tõenäoliselt just selle, mis probleeme tekitab. Allpool olev dekoratoor viib mõõtmise päringufunktsiooni tasemele: plokk finally salvestab latentsuse ja edu olenemata olukorrast, isegi kui erand levib edasi.
import openai
import functools
metrics = ProductionMetrics()
def monitor(func):
"""Dekoraator, mis jälgib iga API päringut."""
@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
Tokenite loendurid ja kulud jäävad selles versioonis nulliks, kuna vastuseobjekt pole salvestamise hetkel kättesaadav. Täida need, lugedes API tagastatud kasutusvälju: ilma selle informatsioonita kuvab sinu armatuurlaud ustavalt veergu nullkulusid.
Reageeri: astmelised hoiatused
Hoiatus on väärtuslik ainult siis, kui see nõuab tegutsemist. Seetõttu eristab süsteem iga mõdiku jaoks kahte lävendit: hoiatuslävend, mis annab märku kõrvalekaldest, mida tuleb päeva jooksul uurida, ja kriitiline lävend, mis õigustab kellegi ülesajamist. Nende kahe segamine toodab halvimat võimalikku tulemust – meeskonna, kes on õppinud teavitusi ignoreerima.
from enum import Enum
class AlertLevel(Enum):
INFO = "info"
WARNING = "warning"
CRITICAL = "critical"
class AlertSystem:
"""Käivitab hoiatusi mõõdikute põhjal."""
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]:
"""Kontrollib mõõdikuid ja genereerib hoiatusi."""
alerts = []
for model in metrics.counters:
# Veamäär
rate = metrics.error_rate(model)
if rate >= self.thresholds["error_rate"]["critical"]:
alerts.append({
"level": AlertLevel.CRITICAL,
"message": (
f"KRITILINE veamäär mudelil {model}: "
f"{rate:.1%}"
),
"model": model,
})
elif rate >= self.thresholds["error_rate"]["warning"]:
alerts.append({
"level": AlertLevel.WARNING,
"message": (
f"Kõrge veamäär mudelil {model}: "
f"{rate:.1%}"
),
"model": model,
})
# Latentsus
p99 = metrics.percentile(model, 99)
if p99 >= self.thresholds["latency_p99"]["critical"]:
alerts.append({
"level": AlertLevel.CRITICAL,
"message": (
f"KRITILINE p99 latentsus mudelil {model}: "
f"{p99:.1f}s"
),
"model": model,
})
self.sent_alerts.extend(alerts)
return alerts
async def notify(self, alerts: list[dict]):
"""Saadab teavitused (webhook, e-post, Slack)."""
import httpx
for alert in alerts:
if alert["level"] == AlertLevel.CRITICAL:
# Kohene teavitus
async with httpx.AsyncClient() as http:
await http.post(
"https://your-webhook.example.com/alerts",
json={
"level": alert["level"].value,
"message": alert["message"],
},
)
Tunnipõhised kuluhoiatused on need, mida kõige sagedamini unustatakse, ja see on kahju: piiramatu kordusproovide tsükkel või kaks korda käivitatud batch-töö tulemuseks on arve, mitte viga. See on ainus ohutusvõrk, mis tuvastab seda tüüpi intsidente nende toimumise hetkel.
Neela: kolm vastupidavusmehhanismi
Kui API tagastab vea, muudab uuesti proovimine asja hullemaks: lisad koormust teenusele, mis on juba hädas, ja paned oma kasutajad ootama tulemusteta. Vooluahela katkestaja (circuit breaker) pöörab selle loogika ümber. Pärast määratud arv järjestikuseid tõrkeid avab see vooluahela ja lükkab järgnevad päringud koheselt tagasi, proovides seejärel uuesti pärast lähtestusviivitust.
class CircuitBreaker:
"""Katkestab päringud, kui vigu tekib liiga palju."""
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:
# Püüa vooluahel sulgeda
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):
"""Käivitab funktsiooni, kui vooluahel on suletud."""
if self.is_open:
raise RuntimeError(
"Vooluahel avatud — API pole saadaval. "
f"Proovi uuesti {self.reset_delay}s pärast."
)
try:
result = func(*args, **kwargs)
self.record_success()
return result
except Exception as e:
self.record_failure()
raise
Vooluahela katkestaja kaitseb sinu rakendust; see ei pane seda siiski tööle. Selle eest hoolitseb mudeli varukoopia (fallback), mis proovib alternatiive järjekorras, jättes vahele need, mille vooluahelad on juba avatud. Üks disainipunkt, mida meeles pidada: nimekirja järjekord on tooteotsus, mitte tehniline. Pane esimesena mudel, mis pakub oodatud teenust, sellele järgnevad need, mis pakuvad degradeerunud, kuid vastuvõetavat teenust – veidi vähem terav vastus on parem kui kättesaamatu teade.
class ModelFallback:
"""Lülitab tõrke korral üle varumudelile."""
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:
"""Proovib iga mudelit, kuni vastus saadakse."""
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("Kõik mudelid on kättesaamatud.")
Kolmas mehhanism puudutab suuruse määramist. Töötajate arvu juhtimine järjekorra suuruse, mitte CPU koormuse põhjal on õige refleks teenuse jaoks, mis veedab suurema osa ajast võrguvastuste ootamisel: CPU seisab jõude, samal ajal kui järjekord kasvab. Pane tähele rakendatud reegli asümmeetriat – skaleerimisel suurendame kahekordistades ja vähendame poolitades, kasutades lahus olevaid lävendeid (100 vs 10). See vahe hoiab ära võnkumise: ilma selleta veedaks süsteem aega töötajate loomise ja hävitamisega ümber pöördepunkti.
class AutoScaler:
"""Kohandab töötajate arvu koormuse põhjal."""
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:
"""Tagastab soovitatava töötajate arvu."""
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
Toomisseviimise kontrollnimekiri
See kursus lõpeb kontrollnimekirjaga, mis tuleb läbi vaadata enne rakenduse avalikkusele avamist. Iga punkt viitab tunnis käsitletud teemale; kui mõni tundub ebaselge, loe see tund enne kasutuselevõttu uuesti läbi.
- Latentsuse jälgimine (p50, p95, p99) ja veamäärad
- Hoiatused konfigureeritud kriitilistel lävenditel
- Vooluahela katkestaja API tõrkete eest kaitsmiseks
- Mudeli varukoopia konfigureeritud
- Sisendi ja väljundi moderatsioon lubatud
- Kliendipoolne kiiruse piiramine rakendatud
- Struktureeritud logid silumiseks
- Automatiseeritud hindamised (evals) CI/CD protsessis
- Kulude eelarve koos hoiatustega
- Versioneeritud vihjete (prompt) dokumentatsioon
Peamised punktid
- Jälgimine hõlmab latentsust, vigu, kulusid ja vastuse kvaliteeti
- Jälgi latentsuse protsentiile, mitte kunagi ainult keskmist
- Hoiatused peavad olema astmelised: esmalt hoiatus, siis kriitiline
- Vooluahela katkestaja kaitseb tõrgete kaskaadi eest; varukoopia tagab kättesaadavuse
- Tootmise kontrollnimekiri hoiab ära kriitilised unustused
Testi oma teadmisi
Latentsus, kulud, hindamised: tootmisrefleksid viies küsimuses.
1. Mis on peamised hoovad latentsuse vähendamiseks?
Vastus: Voogedastus (tajutav latentsus), vihjete vahemällu salvestamine (stabiilsed prefiksid), ennustatud väljundid, kui vastus on suuresti ennustatav (Chat Completions, mudelitel, mis suleti 14. jaanuaril 2027), ja ise vihje optimeerimine – mõõdetuna otsast otsani.
2. Millal peaksid kasutama Batch API-t?
Vastus: Massiliseks töötlemiseks ilma reaalaja nõueteta: asünkroonsed paketid madalama hinnaga – järjestamine, rikastamine või mahuline genereerimine ei kuulu sünkroonsele teele.
3. Mida teeb vestluse kompaktseks muutmine?
Vastus: See tihendab pikka ajalugu (kokkuvõtted, kärpimine), et mahutada see konteksti ja kontrollida kulusid – hädavajalik agentide ja pikkade sessioonide jaoks.
4. Mis on hindamisraamistiku (Evals framework) eesmärk CI/CD-s?
Vastus: Käivitada automaatselt sinu hindamised iga vihje või mudeli muutuse korral: regressioon tuvastatakse kinnitamise (commit) hetkel, mitte tootmises.
5. Mida hõlmab terviklik tootmisarhitektuur?
Vastus: Jälgimine (latentsus, kulud, kvaliteet), hoiatused, asünkroonsed järjekorrad, mahukas moderatsioon ja skaleerimiskava – AI tootmises on süsteem, mitte API päring.
Mõõda, vahemällu salvesta, kasuta pakette, hinda pidevalt: neli harjumust, mis teevad rakendused kiireks, säästlikuks ja usaldusväärseks.