Produktionsarkitektur: overvågning, alarmering, skalering
På denne side
Din applikation i produktion: de tre søjler
At deploye en LLM-applikation til produktion handler ikke kun om koden. Tre søjler garanterer pålidelighed: overvågning for at observere, alarmering for at reagere og skalering for at absorbere belastning. De danner en kæde, og en kæde er kun så stærk som sit svageste led: metrikker, som ingen kigger på, er ubrugelige; alarmer uden en responsprocedure er støj; og skalering, der træder i kraft for sent, er blot et nedbrud. Denne sidste lektion samler alle begreber fra kurset i en komplet produktionsarkitektur.
Observer: hvad skal måles
Fire familier af metrikker dækker det væsentlige: opkaldsvolumen, ventetid, fejl og omkostninger, opdelt pr. model. Det er opdelingen pr. model, der gør dashboardet handlingsorienteret – en global fejlrate på 3 % fortæller dig ingenting, mens samme tal koncentreret på én enkelt model peger straks på synderen.
Klassen nedenfor akkumulerer disse metrikker i hukommelsen ved hjælp af et glidende vindue på 10.000 ventetider for at forhindre, at processen vokser uendeligt. Bemærk brugen af percentiler frem for gennemsnit: den gennemsnitlige ventetid for en LLM-tjeneste er næsten altid vildledende, fordi en håndfuld meget langsomme opkald forsvinder i gennemsnittet, og det er netop dem, dine brugere klager over.
import time
from dataclasses import dataclass, field
from collections import defaultdict
@dataclass
class ProductionMetrics:
"""Indsamler essentielle produktionsmetrikker."""
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
# Behold kun de sidste 10.000 ventetider
if len(self.latencies[model]) > 10_000:
self.latencies[model] = self.latencies[model][-10_000:]
def percentile(self, model: str, p: float) -> float:
"""Beregner en ventetidspercentil."""
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:
"""Genererer et komplet 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
Indsamlingen skal naturligvis være systematisk. Hvis du manuelt instrumenterer hvert enkelt opkald, garanterer du, at du glemmer ét – og sandsynligvis netop det, der skaber problemer. Decoratoren nedenfor flytter målingen til niveauet for opkaldsfunktionen: finally-blokken registrerer ventetid og succes uanset hvad, selv når en undtagelse propageres.
import openai
import functools
metrics = ProductionMetrics()
def monitor(func):
"""Decorator der overvåger hvert API-opkald."""
@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
Tællere for tokens og omkostninger forbliver nul i denne version, fordi responsobjektet ikke er tilgængeligt på registreringstidspunktet. Udfyld dem ved at læse brugsfelterne returneret af API’et: uden disse oplysninger vil dit dashboard trofast vise en kolonne med nul omkostninger.
Reager: graduerede alarmer
En alarm er kun værdifuld, hvis den kræver handling. Derfor skelner systemet mellem to tærskler pr. metrik: en advarselstærskel, der signalerer en afvigelse, der skal undersøges i løbet af dagen, og en kritisk tærskel, der berettiger til at vække nogen. At forveksle de to producerer det værst tænkelige resultat – et team, der har lært at ignorere notifikationer.
from enum import Enum
class AlertLevel(Enum):
INFO = "info"
WARNING = "warning"
CRITICAL = "critical"
class AlertSystem:
"""Udløser alarmer baseret på metrikker."""
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]:
"""Tjekker metrikker og genererer alarmer."""
alerts = []
for model in metrics.counters:
# Fejlrate
rate = metrics.error_rate(model)
if rate >= self.thresholds["error_rate"]["critical"]:
alerts.append({
"level": AlertLevel.CRITICAL,
"message": (
f"KRITISK fejlrate for {model}: "
f"{rate:.1%}"
),
"model": model,
})
elif rate >= self.thresholds["error_rate"]["warning"]:
alerts.append({
"level": AlertLevel.WARNING,
"message": (
f"Høj fejlrate for {model}: "
f"{rate:.1%}"
),
"model": model,
})
# Ventetid
p99 = metrics.percentile(model, 99)
if p99 >= self.thresholds["latency_p99"]["critical"]:
alerts.append({
"level": AlertLevel.CRITICAL,
"message": (
f"KRITISK p99-ventetid for {model}: "
f"{p99:.1f}s"
),
"model": model,
})
self.sent_alerts.extend(alerts)
return alerts
async def notify(self, alerts: list[dict]):
"""Sender notifikationer (webhook, e-mail, Slack)."""
import httpx
for alert in alerts:
if alert["level"] == AlertLevel.CRITICAL:
# Øjeblikkelig notifikation
async with httpx.AsyncClient() as http:
await http.post(
"https://your-webhook.example.com/alerts",
json={
"level": alert["level"].value,
"message": alert["message"],
},
)
Alarmer for timeomkostninger er dem, der oftest glemmes, og det er ærgerligt: en ubegrænset genforsøgsløkke eller et batch-job, der startes to gange, resulterer i en regning, ikke en fejl. Det er det eneste sikkerhedsnet, der opdager denne type hændelser, mens de sker.
Absorber: tre robusthedsmekanismer
Når API’et returnerer en fejl, gør genforsøg tingene værre: du tilføjer belastning til en tjeneste, der allerede har problemer, og får dine egne brugere til at vente forgæves. Circuit breaker vender denne logik om. Efter et defineret antal på hinanden følgende fejl åbner den kredsløbet og afviser straks efterfølgende opkald for derefter at forsøge igen efter en nulstillingsforsinkelse.
class CircuitBreaker:
"""Afbryder opkald, når der opstår for mange fejl."""
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:
# Forsøg at lukke kredsløbet
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):
"""Eksekverer funktionen, hvis kredsløbet er lukket."""
if self.is_open:
raise RuntimeError(
"Kredsløb åbent — API utilgængeligt. "
f"Prøv igen om {self.reset_delay}s."
)
try:
result = func(*args, **kwargs)
self.record_success()
return result
except Exception as e:
self.record_failure()
raise
Circuit breaker beskytter din applikation; den får den dog ikke til at fungere. Det er rollen for model-fallback, som prøver alternativer i rækkefølge og springer dem over, hvis kredsløb allerede er åbne. Ét designpunkt er værd at huske: rækkefølgen på listen er en produktbeslutning, ikke en teknisk én. Sæt først den model, der leverer den forventede service, efterfulgt af dem, der leverer en degraderet, men acceptabel service – et svar, der er lidt mindre skarpt, er bedre end en besked om utilgængelighed.
class ModelFallback:
"""Skifter til en backup-model ved fejl."""
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:
"""Prøver hver model, indtil et svar opnås."""
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("Alle modeller er utilgængelige.")
Den tredje mekanisme vedrører dimensionering. At styre antallet af workers baseret på køstørrelse frem for CPU-belastning er den rigtige refleks for en tjeneste, der bruger det meste af sin tid på at vente på netværksrespons: CPU’en står idle, mens køen vokser. Bemærk asymmetrien i den anvendte regel – vi fordobler ved opskalering og halverer ved nedskalering med vidt adskilte tærskler (100 vs. 10). Dette gab forhindrer oscillation: uden det ville systemet bruge al sin tid på at oprette og destruere workers omkring vippepunktet.
class AutoScaler:
"""Justerer antallet af workers baseret på belastning."""
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:
"""Returnerer det anbefalede antal 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
Tjekliste til produktionsdeployering
Dette kursus slutter med tjeklisten, du skal gennemgå, før du åbner din applikation for offentligheden. Hvert punkt refererer til en lektion, du har dækket; hvis noget virker uklart, så genlæs den pågældende lektion før deployering.
- Overvågning af ventetid (p50, p95, p99) og fejlrater
- Alarmer konfigureret på kritiske tærskler
- Circuit breaker til beskyttelse mod API-fejl
- Model-fallback konfigureret
- Input- og output-moderation aktiveret
- Rate limiting implementeret på klientsiden
- Strukturerede logs til fejlfinding
- Automatiserede evals i CI/CD
- Omkostningsbudget med alarmer
- Versioneret prompt-dokumentation
Vigtige pointer
- Overvågning dækker ventetid, fejl, omkostninger og responskvalitet
- Spor ventetidspercentiler, aldrig kun gennemsnittet
- Alarmer skal være graduerede: først advarsel, derefter kritisk
- Circuit breaker beskytter mod fejlkaskader; fallback sikrer tilgængelighed
- En produktions-tjekliste forhindrer kritiske oversigelser
Test din viden
Ventetid, omkostninger, evals: produktionsreflekser i fem spørgsmål.
1. Hvad er de vigtigste løftestænger til at reducere ventetid?
Svar: Streaming (oplevet ventetid), prompt-caching (stabile præfikser), Predicted Outputs, når svaret er stort set forudsigeligt (Chat Completions, på modeller trukket tilbage 14. januar 2027), og optimering af selve prompten – målt ende-til-ende.
2. Hvornår skal du bruge Batch API?
Svar: Til massiv behandling uden realtidskrav: asynkrone batches til reducerede omkostninger – rangering, berigelse eller volumengenerering har intet sted på den synkrone sti.
3. Hvad gør samtalekomprimering?
Svar: Den komprimerer lang historik (sammendrag, beskæring) for at passe inden for konteksten og kontrollere omkostninger – essentielt for agenter og lange sessioner.
4. Hvad er formålet med Evals-rammeværket i CI/CD?
Svar: At køre dine evalueringer automatisk ved hver ændring af prompt eller model: regression opdages ved commit, ikke i produktion.
5. Hvad inkluderer en komplet produktionsarkitektur?
Svar: Overvågning (ventetid, omkostninger, kvalitet), alarmering, asynkrone køer, moderation i stor skala og en skaleringsplan – AI i produktion er et system, ikke et API-opkald.
Mål, cache, batch, evaluer kontinuerligt: fire vaner, der gør applikationer hurtige, slanke og pålidelige.