Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Arkitektur för produktion: övervakning, avisering, skalning

Lektion 20 av 20 Uppdaterad 3 november 2026 Avancerad
På denna sida
  1. Din applikation i produktion: de tre pelarna
  2. Observera: vad du ska mäta
  3. Reagera: graderade aviseringar
  4. Absorbera: tre mekanismer för resiliens
  5. Checklista för driftsättning i produktion
  6. Viktiga punkter
  7. Testa dina kunskaper

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.