Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Produktionsarkitektur: overvågning, alarmering, skalering

Lektion 20 af 20 Opdateret 3. november 2026 Avanceret
På denne side
  1. Din applikation i produktion: de tre søjler
  2. Observer: hvad skal måles
  3. Reager: graduerede alarmer
  4. Absorber: tre robusthedsmekanismer
  5. Tjekliste til produktionsdeployering
  6. Vigtige pointer
  7. Test din viden

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.