Productie-architectuur: monitoring, alerting, schalen
Op deze pagina
Uw applicatie in productie: de drie pijlers
Het deployen van een LLM-applicatie naar productie draait niet alleen om de code. Drie pijlers garanderen betrouwbaarheid: monitoring om te observeren, alerting om te reageren en schalen om belasting op te vangen. Ze vormen een ketting, en een ketting is slechts zo sterk als de zwakste schakel: metrics die niemand bekijkt zijn nutteloos, alerts zonder responsprocedure zijn ruis, en schalen dat te laat ingrijpt is gewoon een outage. Deze laatste les brengt elk concept uit de cursus samen in een complete productie-architectuur.
Observeren: wat u moet meten
Vier families metrics dekken de essentie: call-volume, latentie, fouten en kosten, uitgesplitst per model. Uitsplitsen per model is wat het dashboard actiegericht maakt; een globaal foutpercentage van 3% vertelt u niets, terwijl datzelfde cijfer geconcentreerd op één model direct de boosdoener aanwijst.
De onderstaande klasse accumuleert deze metrics in het geheugen, gebruikmakend van een schuivend venster van 10.000 latenties om te voorkomen dat het proces oneindig groeit. Let op het gebruik van percentielen in plaats van gemiddelden: de gemiddelde latentie van een LLM-service is bijna altijd misleidend omdat een handvol zeer trage calls wegvalt in het gemiddelde, terwijl het juist die calls zijn waar uw gebruikers over klagen.
import time
from dataclasses import dataclass, field
from collections import defaultdict
@dataclass
class ProductionMetrics:
"""Collects essential production metrics."""
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
# Keep only the last 10,000 latencies
if len(self.latencies[model]) > 10_000:
self.latencies[model] = self.latencies[model][-10_000:]
def percentile(self, model: str, p: float) -> float:
"""Calculates a latency percentile."""
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:
"""Generates a complete 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
Natuurlijk moet de verzameling systematisch zijn. Het handmatig instrumenteren van elke call garandeert dat u er één vergeet—en waarschijnlijk juist diegene die problemen veroorzaakt. De onderstaande decorator verplaatst de meting naar het niveau van de call-functie: het finally-blok registreert latentie en succes ongeacht wat er gebeurt, zelfs wanneer een uitzondering wordt doorgegeven.
import openai
import functools
metrics = ProductionMetrics()
def monitor(func):
"""Decorator that monitors every API call."""
@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
Token-tellers en kosten blijven in deze versie op nul staan omdat het responsobject niet beschikbaar is op het moment van registratie. Vul deze aan door de usage-velden uit te lezen die door de API worden teruggegeven; zonder deze informatie zal uw dashboard trouw een kolom met nul kosten weergeven.
Reageren: gefaseerde alerts
Een alert is alleen waardevol als het tot actie aanzet. Daarom onderscheidt het systeem twee drempels per metric: een waarschuwingsdrempel, die een afwijking signaleert die overdag onderzocht moet worden, en een kritieke drempel, die het wakker maken van iemand rechtvaardigt. Deze twee door elkaar halen levert het slechtst denkbare resultaat op: een team dat heeft geleerd meldingen te negeren.
from enum import Enum
class AlertLevel(Enum):
INFO = "info"
WARNING = "warning"
CRITICAL = "critical"
class AlertSystem:
"""Triggers alerts based on metrics."""
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]:
"""Checks metrics and generates alerts."""
alerts = []
for model in metrics.counters:
# Error rate
rate = metrics.error_rate(model)
if rate >= self.thresholds["error_rate"]["critical"]:
alerts.append({
"level": AlertLevel.CRITICAL,
"message": (
f"CRITICAL error rate for {model}: "
f"{rate:.1%}"
),
"model": model,
})
elif rate >= self.thresholds["error_rate"]["warning"]:
alerts.append({
"level": AlertLevel.WARNING,
"message": (
f"High error rate for {model}: "
f"{rate:.1%}"
),
"model": model,
})
# Latency
p99 = metrics.percentile(model, 99)
if p99 >= self.thresholds["latency_p99"]["critical"]:
alerts.append({
"level": AlertLevel.CRITICAL,
"message": (
f"CRITICAL p99 latency for {model}: "
f"{p99:.1f}s"
),
"model": model,
})
self.sent_alerts.extend(alerts)
return alerts
async def notify(self, alerts: list[dict]):
"""Sends notifications (webhook, email, Slack)."""
import httpx
for alert in alerts:
if alert["level"] == AlertLevel.CRITICAL:
# Immediate notification
async with httpx.AsyncClient() as http:
await http.post(
"https://your-webhook.example.com/alerts",
json={
"level": alert["level"].value,
"message": alert["message"],
},
)
Alerts voor uurkosten worden het vaakst vergeten, en dat is jammer: een onbegrensde retry-lus of een batch-job die per ongeluk tweemaal start, resulteert in een factuur, niet in een foutmelding. Het is het enige veiligheidsnet dat dit type incident detecteert terwijl het plaatsvindt.
Opvangen: drie veerkrachtmechanismen
Wanneer de API een fout retourneert, maakt opnieuw proberen de situatie vaak erger: u voegt belasting toe aan een service die al in de problemen zit en laat uw eigen gebruikers tevergeefs wachten. De circuit breaker draait deze logica om. Na een bepaald aantal opeenvolgende mislukkingen opent hij het circuit en wijst hij daaropvolgende calls direct af, waarna hij na een reset-vertraging opnieuw probeert.
class CircuitBreaker:
"""Cuts off calls when too many errors occur."""
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:
# Attempt to close the circuit
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):
"""Executes the function if the circuit is closed."""
if self.is_open:
raise RuntimeError(
"Circuit open — API unavailable. "
f"Retry in {self.reset_delay}s."
)
try:
result = func(*args, **kwargs)
self.record_success()
return result
except Exception as e:
self.record_failure()
raise
De circuit breaker beschermt uw applicatie; hij zorgt er echter niet voor dat deze werkt. Dat is de rol van model-fallback, dat alternatieven probeert in volgorde, waarbij diegenen worden overgeslagen waarvan het circuit al geopend is. Een belangrijk ontwerppunt om te onthouden: de volgorde van de lijst is een productbeslissing, geen technische. Zet het model dat de verwachte service levert eerst, gevolgd door diegenen die een gedegradeerde maar acceptabele service leveren—een iets minder scherp antwoord is beter dan een bericht dat niet beschikbaar is.
class ModelFallback:
"""Switches to a backup model in case of failure."""
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:
"""Tries each model until a response is obtained."""
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("All models are unavailable.")
Het derde mechanisme betreft dimensionering. Het aantal workers aansturen op basis van de wachtrijgrootte in plaats van CPU-belasting is de juiste reflex voor een service die het grootste deel van de tijd wacht op netwerkresponsen: de CPU staat dan stil terwijl de wachtrij groeit. Let op de asymmetrie in de toegepaste regel: we verdubbelen bij opschalen en halveren bij afschalen, met ver uit elkaar liggende drempels (100 versus 10). Deze kloof voorkomt oscillatie: zonder dit zou het systeem voortdurend workers creëren en vernietigen rond het kantelpunt.
class AutoScaler:
"""Adjusts the number of workers based on load."""
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:
"""Returns the recommended number of 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
Checklist voor productie-deployment
Deze cursus eindigt met de checklist die u moet doorlopen voordat u uw applicatie opent voor het publiek. Elk item verwijst naar een les die u heeft behandeld; als iets onduidelijk lijkt, lees die les dan opnieuw voordat u deployt.
- Latentie-monitoring (p50, p95, p99) en foutpercentages
- Alerts geconfigureerd op kritieke drempels
- Circuit breaker ter bescherming tegen API-fouten
- Model-fallback geconfigureerd
- Input- en output-moderatie ingeschakeld
- Client-side rate limiting geïmplementeerd
- Gestructureerde logs voor debugging
- Geautomatiseerde evals in CI/CD
- Kostenbudget met alerts
- Geversioneerde prompt-documentatie
Belangrijkste punten
- Monitoring omvat latentie, fouten, kosten en responskwaliteit
- Volg latentie-percentielen, nooit alleen het gemiddelde
- Alerts moeten gefaseerd zijn: eerst waarschuwing, dan kritiek
- Circuit breaker beschermt tegen falende cascades; fallback zorgt voor beschikbaarheid
- Een productie-checklist voorkomt kritieke omissies
Test uw kennis
Latentie, kosten, evals: productie-reflexen in vijf vragen.
1. Wat zijn de belangrijkste hefbomen om latentie te verminderen?
Antwoord: Streaming (waargenomen latentie), prompt-caching (stabiele prefixen), Predicted Outputs wanneer de respons grotendeels voorspelbaar is (Chat Completions, op modellen die op 14 januari 2027 met pensioen gaan), en het optimaliseren van de prompt zelf—end-to-end gemeten.
2. Wanneer moet u de Batch API gebruiken?
Antwoord: Voor massale verwerking zonder real-time vereisten: asynchrone batches tegen lagere kosten—ranking, verrijking of volumegeneratie hebben geen plek op het synchrone pad.
3. Wat doet conversatie-compactie?
Antwoord: Het comprimeert lange geschiedenis (samenvattingen, pruning) om binnen de context te passen en kosten te beheersen—essentieel voor agents en lange sessies.
4. Wat is het doel van het Evals-framework in CI/CD?
Antwoord: Om uw evaluaties automatisch uit te voeren bij elke prompt- of modelwijziging: regressie wordt gedetecteerd bij de commit, niet in productie.
5. Wat omvat een complete productie-architectuur?
Antwoord: Monitoring (latentie, kosten, kwaliteit), alerting, asynchrone wachtrijen, moderatie op schaal en een schaalplan—AI in productie is een systeem, geen API-call.
Meten, cachen, batchen, continu evalueren: vier gewoonten die applicaties snel, lean en betrouwbaar maken.