Arhitektūra ražošanai: uzraudzība, brīdinājumi, mērogošana
Šajā lapā
Tava lietotne ražošanā: trīs pīlāri
LLM lietotnes izvietošana ražošanā nav tikai par kodu. Trīs pīlāri garantē uzticamību: uzraudzība, lai novērotu, brīdinājumi, lai reaģētu, un mērogošana, lai absorbētu slodzi. Tie veido ķēdi, un ķēde ir tik stipra, cik tās vājākais posms: metrikas, uz kurām neviens neskatās, ir bezjēdzīgas, brīdinājumi bez reakcijas procedūras ir troksnis, un mērogošana, kas iedarbojas par vēlu, ir vienkārši pārtraukums. Šī noslēdzošā nodarbība apvieno visus kursa konceptus vienotā ražošanas arhitektūrā.
Novēro: ko mērīt
Četras metrikas ģimenes aptver būtisko: izsaukumu apjomu, latentumu, kļūdas un izmaksas, sadalot pa modeļiem. Tieši sadalījums pa modeļiem padara informācijas paneli izmantojamu — globāls kļūdu līmenis 3% tev neko nepasaka, savukārt tas pats rādītājs, kas koncentrēts uz vienu modeli, uzreiz norāda uz vaininieku.
Zemāk esošā klase uzkrāj šīs metrikas atmiņā, izmantojot slīdošo logu ar 10 000 latentuma vērtībām, lai novērstu procesa neierobežotu augšanu. Ņem vērā, ka tiek izmantoti percentiļi, nevis vidējās vērtības: LLM servisa vidējais latentums gandrīz vienmēr ir maldinošs, jo daži ļoti lēni izsaukumi pazūd vidējā rādītājā, taču tieši par tiem sūdzas tavi lietotāji.
import time
from dataclasses import dataclass, field
from collections import defaultdict
@dataclass
class ProductionMetrics:
"""Vāc būtiskas ražošanas 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
# Saglabā tikai pēdējos 10 000 latentumus
if len(self.latencies[model]) > 10_000:
self.latencies[model] = self.latencies[model][-10_000:]
def percentile(self, model: str, p: float) -> float:
"""Aprēķina latentuma percentili."""
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:
"""Ģenerē pilnu informācijas paneli."""
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
Protams, vākšanai jābūt sistemātiskai. Katra izsaukuma manuāla instrumentēšana garantē, ka kādu aizmirsīsi — un, visticamāk, tieši to, kas radīs problēmas. Zemāk esošais dekorators pārvieto mērīšanu uz izsaukuma funkcijas līmeni: bloks finally reģistrē latentumu un veiksmi neatkarīgi no tā, kas notiek, pat ja izplatās izņēmums.
import openai
import functools
metrics = ProductionMetrics()
def monitor(func):
"""Dekorators, kas uzrauga katru API izsaukumu."""
@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
Šajā versijā tokena skaitītāji un izmaksas paliek nulles, jo ierakstīšanas brīdī atbildes objekts vēl nav pieejams. Papildini tos, nolasot API atgrieztos lietojuma laukus: bez šīs informācijas tavs informācijas panelis uzticami attēlos nullu kolonnu izmaksām.
Reaģē: pakāpeniski brīdinājumi
Brīdinājums ir vērtīgs tikai tad, ja tas prasa rīcību. Tieši tāpēc sistēma katram rādītājam nošķir divus sliekšņus: brīdinājuma slieksni, kas signalizē par novirzi, kas jāizvērtē dienas laikā, un kritisko slieksni, kas attaisno kāda pamodināšanu. Šo divu sajaukšana rada vissliktāko iespējamo iznākumu — komandu, kas ir iemācījusies ignorēt paziņojumus.
from enum import Enum
class AlertLevel(Enum):
INFO = "info"
WARNING = "warning"
CRITICAL = "critical"
class AlertSystem:
"Izraisa brīdinājumus, pamatojoties uz metrikām."
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]:
"""Pārbauda metrikas un ģenerē brīdinājumus."""
alerts = []
for model in metrics.counters:
# Kļūdu līmenis
rate = metrics.error_rate(model)
if rate >= self.thresholds["error_rate"]["critical"]:
alerts.append({
"level": AlertLevel.CRITICAL,
"message": (
f"KRITISKS kļūdu līmenis modelim {model}: "
f"{rate:.1%}"
),
"model": model,
})
elif rate >= self.thresholds["error_rate"]["warning"]:
alerts.append({
"level": AlertLevel.WARNING,
"message": (
f"Augsts kļūdu līmenis modelim {model}: "
f"{rate:.1%}"
),
"model": model,
})
# Latentums
p99 = metrics.percentile(model, 99)
if p99 >= self.thresholds["latency_p99"]["critical"]:
alerts.append({
"level": AlertLevel.CRITICAL,
"message": (
f"KRITISKS p99 latentums modelim {model}: "
f"{p99:.1f}s"
),
"model": model,
})
self.sent_alerts.extend(alerts)
return alerts
async def notify(self, alerts: list[dict]):
"""Nosūta paziņojumus (webhook, e-pasts, Slack)."""
import httpx
for alert in alerts:
if alert["level"] == AlertLevel.CRITICAL:
# Tūlītējs paziņojums
async with httpx.AsyncClient() as http:
await http.post(
"https://your-webhook.example.com/alerts",
json={
"level": alert["level"].value,
"message": alert["message"],
},
)
Brīdinājumi par stundas izmaksām ir tie, kurus visbiežāk aizmirst, un tas ir žēl: neierobežots atkārtojumu cikls vai divreiz palaists batch uzdevums rada rēķinu, nevis kļūdu. Tas ir vienīgais drošības tīkls, kas šāda veida incidentus atklāj to norises laikā.
Absorbē: trīs noturības mehānismi
Kad API atgriež kļūdu, atkārtošana pasliktina situāciju: tu pievieno slodzi servisam, kas jau ir grūtībās, un liec saviem lietotājiem velti gaidīt. Ķēdes pārtraucējs (circuit breaker) apvērš šo loģiku. Pēc noteikta secīgu neveiksmju skaita tas atver ķēdi un nekavējoties noraida turpmākos izsaukumus, pēc tam mēģinot atkārtoti pēc atiestatīšanas aiztures.
class CircuitBreaker:
"""Pārtrauc izsaukumus, ja notiek pārāk daudz kļūdu."""
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:
# Mēģina aizvērt ķēdi
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):
"""Izpilda funkciju, ja ķēde ir aizvērta."""
if self.is_open:
raise RuntimeError(
"Ķēde atvērta — API nav pieejams. "
f"Mēģini vēlreiz pēc {self.reset_delay}s."
)
try:
result = func(*args, **kwargs)
self.record_success()
return result
except Exception as e:
self.record_failure()
raise
Ķēdes pārtraucējs aizsargā tavu lietotni; tas tomēr neliek tai strādāt. To dara modeļa rezerves kopija (fallback), kas secīgi mēģina alternatīvas, izlaižot tās, kuru ķēdes jau ir atvērtas. Viens dizaina punkts, kas jāatceras: saraksta kārtība ir produkta lēmums, nevis tehnisks. Pirmo liec modeli, kas nodrošina paredzēto servisu, kam seko tie, kas nodrošina degradētu, bet pieņemamu servisu — nedaudz mazāk asa atbilde ir labāka par nepieejamu ziņojumu.
class ModelFallback:
"""Pārslēdzas uz rezerves modeli neveiksmes gadījumā."""
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:
"""Mēģina katru modeli, līdz tiek iegūta atbilde."""
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 modeļi nav pieejami.")
Trešais mehānisms attiecas uz izmēru noteikšanu. Darbinieku skaita vadīšana, balstoties uz rindas lielumu, nevis CPU slodzi, ir pareizais reflekss servisam, kas lielāko daļu laika pavada, gaidot tīkla atbildes: CPU dīvē, kamēr rinda aug. Ņem vērā asimetriju pielietotajā likumā — mēs dubultojam, mērogojot uz augšu, un samazinām uz pusi, mērogojot uz leju, izmantojot plaši atdalītus sliekšņus (100 pret 10). Šī atstarpe novērš svārstības: bez tās sistēma pastāvīgi radītu un iznīcinātu darbiniekus ap pagrieziena punktu.
class AutoScaler:
"""Pielāgo darbinieku skaitu atkarībā no slodzes."""
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:
"""Atgriež ieteicamo darbinieku skaitu."""
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
Ražošanas izvietošanas kontrolsaraksts
Šis kurss noslēdzas ar kontrolsarakstu, kas jāiziet pirms lietotnes atvēršanas publiskai lietošanai. Katrs punkts atsaucas uz nodarbību, ko esi apguvis; ja kāds šķiet neskaidrs, pārlasi šo nodarbību pirms izvietošanas.
- Latentuma uzraudzība (p50, p95, p99) un kļūdu līmeņi
- Brīdinājumi konfigurēti uz kritiskajiem sliekšņiem
- Ķēdes pārtraucējs aizsardzībai pret API kļūdām
- Konfigurēta modeļa rezerves kopija (fallback)
- Ievades un izvades moderācija iespējota
- Klienta puses ātruma ierobežošana (rate limiting) ieviesta
- Strukturēti žurnāli atkļūdošanai
- Automatizēti evali CI/CD procesā
- Izmaksu budžets ar brīdinājumiem
- Versijotu promptu dokumentācija
Galvenās atziņas
- Uzraudzība aptver latentumu, kļūdas, izmaksas un atbilžu kvalitāti
- Izseko latentuma percentiļus, nekad tikai vidējo vērtību
- Brīdinājumiem jābūt pakāpeniskiem: vispirms brīdinājums, tad kritisks
- Ķēdes pārtraucējs aizsargā pret kļūdu kaskādēm; rezerves kopija nodrošina pieejamību
- Ražošanas kontrolsaraksts novērš kritiskas kļūdas
Pārbaudi savas zināšanas
Latentums, izmaksas, evali: ražošanas refleksi piecos jautājumos.
1. Kādi ir galvenie sviras, lai samazinātu latentumu?
Atbilde: Straumēšana (uztvertais latentums), promptu kešošana (stabilas prefiksu daļas), Prognozētās izejas (Predicted Outputs), kad atbilde ir lielā mērā paredzama (Chat Completions, modeļiem, kas izņemti no aprites 2027. gada 14. janvārī), un paša prompta optimizēšana — mērīts no gala līdz galam.
2. Kad jāizmanto Batch API?
Atbilde: Masveida apstrādei bez reāllaika ierobežojumiem: asinhronas partijas par samazinātu cenu — rangēšanai, bagātināšanai vai apjoma ģenerēšanai nav vietas sinhronajā ceļā.
3. Ko dara sarunu kompaktizēšana?
Atbilde: Tā saspiež garu vēsturi (kopsavilkumi, apgriešana), lai ietilptu kontekstā un kontrolētu izmaksas — būtiski aģentiem un garām sesijām.
4. Kāds ir Evals frameworka mērķis CI/CD?
Atbilde: Automātiski palaist tavus novērtējumus pie katras prompta vai modeļa izmaiņas: regresija tiek atklāta pie fiksācijas (commit), nevis ražošanā.
5. Ko ietver pilnīga ražošanas arhitektūra?
Atbilde: Uzraudzību (latentums, izmaksas, kvalitāte), brīdinājumus, asinhronas rindas, mērogojamu moderāciju un mērogošanas plānu — AI ražošanā ir sistēma, nevis API izsaukums.
Mēri, kešo, veido partijas, nepārtraukti vērtē: četri ieradumi, kas padara lietotnes ātras, vieglas un uzticamas.