Arkitektur för produktion: övervakning, avisering, skalning
På denna sida
Din applikation i produktion: de tre pelarna
Att driftsätta en LLM-applikation i produktion handlar inte bara om koden. Tre pelare garanterar tillförlitligheten: övervakning för att observera, avisering för att reagera och skalning för att hantera belastning. De bildar en kedja, och en kedja är bara så stark som sin svagaste länk: mätvärden som ingen tittar på är värdelösa, aviseringar utan en responsprocedur är brus, och skalning som sätter in för sent är bara ett driftstopp. Denna sista lektion sammanför alla begrepp från kursen till en komplett produktionsarkitektur.
Observera: vad du ska mäta
Fyra familjer av mätvärden täcker det väsentliga: anropsvolym, latens, fel och kostnad, uppdelat per modell. Att bryta ner per modell är vad som gör instrumentpanelen handlingsbar; en global felprocent på 3 % säger dig ingenting, medan samma siffra koncentrerad på en enda modell pekar omedelbart ut boven.
Klassen nedan ackumulerar dessa mätvärden i minnet, med ett glidande fönster på 10 000 latenser för att förhindra att processen växer obegränsat. Notera användningen av percentiler istället för medelvärden: den genomsnittliga latensen för en LLM-tjänst är nästan alltid vilseledande eftersom en handfull mycket långsamma anrop försvinner i snittet, trots att det är dessa dina användare klagar på.
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
Insamlingen måste naturligtvis vara systematisk. Att manuellt instrumentera varje anrop garanterar att du kommer att glömma ett – och sannolikt det som ställer till problem. Dekoratorn nedan flyttar mätningen till nivån för anropsfunktionen: blocket finally registrerar latens och framgång oavsett vad som händer, även när ett undantag propagerar.
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
Tokenräknare och kostnad förblir noll i denna version eftersom svarsobjektet inte är tillgängligt vid registreringstillfället. Komplettera dem genom att läsa fälten för användning som returneras av API:et; utan denna information kommer din instrumentpanel troget att visa en kolumn med nollkostnader.
Reagera: graderade aviseringar
En avisering är bara värdefull om den kräver åtgärd. Därför skiljer systemet mellan två tröskelvärden per mätvärde: en varningströskel, som signalerar en avvikelse att undersöka under dagen, och en kritisk tröskel, som motiverar att någon väcks. Att blanda ihop dessa två ger det värsta tänkbara resultatet – ett team som har lärt sig att ignorera notifieringar.
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"],
},
)
Aviseringar för timkostnad är de som oftast glöms bort, och det är synd: en obegränsad retry-loop eller ett batchjobb som startas två gånger resulterar i en faktura, inte ett fel. Det är det enda säkerhetsnätet som upptäcker denna typ av incident medan den pågår.
Absorbera: tre mekanismer för resiliens
När API:et returnerar ett fel gör försök att återupprepa saken värre: du lägger till belastning på en tjänst som redan har problem och får dina egna användare att vänta förgäves. Strömbrytaren (circuit breaker) vänder på denna logik. Efter ett definierat antal på varandra följande fel öppnar den kretsen och avvisar omedelbart efterföljande anrop, för att sedan försöka igen efter en återställningsfördröjning.
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
Strömbrytaren skyddar din applikation; den får den dock inte att fungera. Det är rollen för modell-reserv (fallback), som provar alternativ i ordning och hoppar över de vars kretsar redan är öppna. En designpunkt att komma ihåg: ordningen i listan är ett produktbeslut, inte ett tekniskt. Placera först den modell som levererar den förväntade tjänsten, följt av de som levererar en försämrad men acceptabel tjänst – ett något mindre skarpt svar är bättre än ett otillgängligt meddelande.
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.")
Den tredje mekanismen gäller dimensionering. Att styra antalet arbetare baserat på köstorlek snarare än CPU-belastning är rätt reflex för en tjänst som spenderar mest tid på att vänta på nätverkssvar: CPU:n står overksam medan kön växer. Notera asymmetrin i den tillämpade regeln – vi fördubblar vid uppskalning och halverar vid nedskalning, med vitt åtskilda tröskelvärden (100 mot 10). Detta gap förhindrar oscillation: utan det skulle systemet spendera sin tid med att skapa och förstöra arbetare runt vändpunkten.
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
Checklista för driftsättning i produktion
Denna kurs avslutas med en checklista att gå igenom innan du öppnar din applikation för allmänheten. Varje punkt refererar till en lektion du har behandlat; om någon verkar oklar, läs om den lektionen innan du driftsätter.
- Övervakning av latens (p50, p95, p99) och felprocent
- Aviseringar konfigurerade på kritiska tröskelvärden
- Strömbrytare för att skydda mot API-fel
- Modell-reserv konfigurerad
- Moderering av in- och utdata aktiverad
- Hastighetsbegränsning på klientsidan implementerad
- Strukturerade loggar för felsökning
- Automatiserade utvärderingar i CI/CD
- Kostnadsbudget med aviseringar
- Versionshanterad prompt-dokumentation
Viktiga punkter
- Övervakning täcker latens, fel, kostnader och svarskvalitet
- Spåra latenspercentiler, aldrig bara medelvärdet
- Aviseringar måste vara graderade: varning sedan kritisk
- Strömbrytare skyddar mot felkaskader; reserv säkerställer tillgänglighet
- En checklista för produktion förhindrar kritiska förbiseenden
Testa dina kunskaper
Latens, kostnader, utvärderingar: produktionsreflexer i fem frågor.
1. Vilka är de huvudsakliga hävstängerna för att minska latens?
Svar: Streaming (upplevd latens), prompt-cache (stabila prefix), Predicted Outputs när svaret är till stor del förutsägbart (Chat Completions, på modeller som avvecklades den 14 januari 2027), och optimering av själva prompten – mätt från ände till ände.
2. När ska du använda Batch API?
Svar: För massiv bearbetning utan krav på realtid: asynkrona batchar till reducerad kostnad – rangordning, berikning eller volymgenerering har ingen plats på den synkrona vägen.
3. Vad gör konversationskomprimering?
Svar: Den komprimerar lång historik (sammanfattningar, beskärning) för att passa inom kontexten och kontrollera kostnader – avgörande för agenter och långa sessioner.
4. Vad är syftet med ramverket för utvärdering (Evals) i CI/CD?
Svar: Att automatiskt köra dina utvärderingar vid varje ändring av prompt eller modell: regression upptäcks vid commit, inte i produktion.
5. Vad inkluderar en komplett produktionsarkitektur?
Svar: Övervakning (latens, kostnader, kvalitet), avisering, asynkrona köer, moderering i skala och en skalningsplan – AI i produktion är ett system, inte ett API-anrop.
Mät, cacha, batcha, utvärdera kontinuerligt: fyra vanor som gör applikationer snabba, smala och tillförlitliga.