Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Arhitektura za produkcijo: nadzor, opozarjanje, skaliranje

Lekcija 20 od 20 Posodobljeno 3. november 2026 Napredni
Na tej strani
  1. Tvoja aplikacija v produkciji: trije stebri
  2. Opazuj: kaj meriti
  3. Reagiraj: stopnjevana opozorila
  4. Prevzemi: trije mehanizmi odpornosti
  5. Kontrolni seznam za uvedbo v produkcijo
  6. Ključne ugotovitve
  7. Preveri svoje znanje

Tvoja aplikacija v produkciji: trije stebri

Uvedba aplikacije z velikim jezikovnim modelom (LLM) v produkcijo ni zgolj stvar kode. Trije stebri zagotavljajo zanesljivost: nadzor za opazovanje, opozarjanje za reakcijo in skaliranje za prevzemanje obremenitve. Ti tvorijo verigo, veriga pa je močna toliko, kolikor je močan njen najšibkejši člen: metrike, ki jih nihče ne gleda, so neuporabne, opozorila brez postopka odzivanja so šum, skaliranje, ki se vklopi prepozno, pa je zgolj izpad storitve. Ta zadnja lekcija združuje vse koncepte tečaja v celovito produkcijsko arhitekturo.

Opazuj: kaj meriti

Štiri družine metrik pokrivajo bistvo: količina klicev, zakasnitev (latency), napake in stroški, razčlenjeni po modelu. Razčlenitev po modelu je tisto, zaradi česar je nadzorna plošča uporabna – globalna stopnja napak 3 % ti ne pove ničesar, medtem ko ista številka, skoncentrirana na enem samem modelu, takoj pokaže na krivca.

Spodnji razred zbira te metrike v pomnilniku z uporabo drsečega okna 10.000 zakasnitev, da se proces ne bi neskončno povečeval. Upoštevaj uporabo percentilov namesto povprečij: povprečna zakasnitev storitve LLM je skoraj vedno zavajajoča, ker peščica zelo počasnih klicev izgine v povprečju, čeprav so prav ti tisti, na katere se tvoji uporabniki pritožujejo.

import time
from dataclasses import dataclass, field
from collections import defaultdict

@dataclass
class ProductionMetrics:
    """Zbira ključne produkcijske metrike."""

    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

        # Ohrani le zadnjih 10.000 zakasnitev
        if len(self.latencies[model]) > 10_000:
            self.latencies[model] = self.latencies[model][-10_000:]

    def percentile(self, model: str, p: float) -> float:
        """Izračuna percentil zakasnitve."""
        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:
        """Generira celovito nadzorno ploščo."""
        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

Seveda mora biti zbiranje sistematično. Ročno instrumentiranje vsakega klica zagotavlja, da boš enega pozabil – in verjetno prav tistega, ki povzroča težave. Spodnji dekorator premakne merjenje na raven funkcije klica: blok finally zabeleži zakasnitev in uspešnost ne glede na vse, tudi ko se izjema razširi naprej.

import openai
import functools

metrics = ProductionMetrics()

def monitor(func):
    """Dekorator, ki nadzira vsak klic API-ja."""
    @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

Števci žetonov in stroški v tej različici ostanejo ničelni, ker objekt odgovora v času beleženja še ni na voljo. Dopolni jih z branjem polj uporabe (usage), ki jih vrne API: brez teh informacij bo tvoja nadzorna plošča zvesto prikazovala stolpec ničelnih stroškov.

Reagiraj: stopnjevana opozorila

Opozorilo je vredno le, če zahteva ukrepanje. Zato sistem razlikuje dva praga za vsako metriko: opozorilni prag, ki signalizira odmik, ki ga je treba pregledati čez dan, in kritični prag, ki upravičuje bujenje nekoga. Zamenjava teh dveh povzroči najslabši možni izid – ekipo, ki se je naučila ignorirati obvestila.

from enum import Enum

class AlertLevel(Enum):
    INFO = "info"
    WARNING = "warning"
    CRITICAL = "critical"

class AlertSystem:
    """Sproži opozorila na podlagi metrik."""

    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]:
        """Preveri metrike in generira opozorila."""
        alerts = []

        for model in metrics.counters:
            # Stopnja napak
            rate = metrics.error_rate(model)
            if rate >= self.thresholds["error_rate"]["critical"]:
                alerts.append({
                    "level": AlertLevel.CRITICAL,
                    "message": (
                        f"KRITIČNA stopnja napak za {model}: "
                        f"{rate:.1%}"
                    ),
                    "model": model,
                })
            elif rate >= self.thresholds["error_rate"]["warning"]:
                alerts.append({
                    "level": AlertLevel.WARNING,
                    "message": (
                        f"Visoka stopnja napak za {model}: "
                        f"{rate:.1%}"
                    ),
                    "model": model,
                })

            # Zakasnitev
            p99 = metrics.percentile(model, 99)
            if p99 >= self.thresholds["latency_p99"]["critical"]:
                alerts.append({
                    "level": AlertLevel.CRITICAL,
                    "message": (
                        f"KRITIČNA zakasnitev p99 za {model}: "
                        f"{p99:.1f}s"
                    ),
                    "model": model,
                })

        self.sent_alerts.extend(alerts)
        return alerts

    async def notify(self, alerts: list[dict]):
        """Pošlje obvestila (webhook, e-pošta, Slack)."""
        import httpx

        for alert in alerts:
            if alert["level"] == AlertLevel.CRITICAL:
                # Takojšnje obvestilo
                async with httpx.AsyncClient() as http:
                    await http.post(
                        "https://your-webhook.example.com/alerts",
                        json={
                            "level": alert["level"].value,
                            "message": alert["message"],
                        },
                    )

Opozorila o urnih stroških so tista, na katera najpogosteje pozabimo, kar je škoda: neomejena zanka za ponovne poskuse ali dvakrat zagnano serijsko opravilo (batch job) povzroči račun, ne napake. To je edina varnostna mreža, ki zazna tovrstne incidente, medtem ko se dogajajo.

Prevzemi: trije mehanizmi odpornosti

Ko API vrne napako, ponovni poskus stvari poslabša: dodaš obremenitev storitvi, ki je že v težavah, in prisiliš svoje uporabnike, da čakajo zaman. Odklopnik (circuit breaker) obrne to logiko. Po določenem številu zaporednih napak odklopi tokokrog in takoj zavrne naslednje klice, nato pa po zamiku za ponastavitev poskusi znova.

class CircuitBreaker:
    """Prekine klice, ko pride do preveč napak."""

    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:
            # Poskus zaprtja tokokroga
            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):
        """Izvede funkcijo, če je tokokrog zaprt."""
        if self.is_open:
            raise RuntimeError(
                "Tokokrog odprt — API ni na voljo. "
                f"Poskusi znova čez {self.reset_delay}s."
            )
        try:
            result = func(*args, **kwargs)
            self.record_success()
            return result
        except Exception as e:
            self.record_failure()
            raise

Odklopnik ščiti tvojo aplikacijo, vendar je ne naredi delujoče. To je vloga nadomestnega modela (fallback), ki po vrsti preizkusi alternative in preskoči tiste, katerih tokokrogi so že odprti. Pomembna oblikovna točka: vrstni red seznama je produktna odločitev, ne tehnična. Najprej postavi model, ki zagotavlja pričakovano storitev, sledijo pa tisti, ki nudijo poslabšano, a sprejemljivo storitev – nekoliko manj oster odgovor je boljši od sporočila o nedostopnosti.

class ModelFallback:
    """V primeru napake preklopi na rezervni model."""

    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:
        """Preizkusi vsak model, dokler ne dobi odgovora."""
        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("Vsi modeli so nedostopni.")

Tretji mehanizem se nanaša na dimenzioniranje. Upravljanje števila delavcev na podlagi velikosti čakalne vrste namesto obremenitve procesorja je pravi refleks za storitev, ki večino časa čaka na omrežne odgovore: procesor miruje, medtem ko čakalna vrsta raste. Upoštevaj asimetrijo v uporabljenem pravilu – ob povečanju podvojimo, ob zmanjšanju pa prepolovimo, s široko ločenima pragovoma (100 proti 10). Ta razmik preprečuje nihanje: brez njega bi sistem neprestano ustvarjal in uničeval delavce okoli prelomne točke.

class AutoScaler:
    """Prilagodi število delavcev glede na obremenitev."""

    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:
        """Vrne priporočeno število delavcev."""
        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

Kontrolni seznam za uvedbo v produkcijo

Ta tečaj se zaključuje s kontrolnim seznamom, ki ga moraš preiti, preden svojo aplikacijo odpreš za javnost. Vsaka točka se nanaša na lekcijo, ki si jo obravnaval; če se katera zdi nejasna, ponovno preberi to lekcijo pred uvedbo.

  • Nadzor zakasnitve (p50, p95, p99) in stopenj napak
  • Opozorila, konfigurirana na kritičnih pragovih
  • Odklopnik za zaščito pred napakami API-ja
  • Konfiguriran nadomestni model (fallback)
  • Omogočena moderacija vhodov in izhodov
  • Implementirana omejitev hitrosti (rate limiting) na strani odjemalca
  • Strukturirani dnevniki za odpravljanje napak
  • Avtomatizirane evalvacije v CI/CD
  • Proračun za stroške z opozorili
  • Dokumentacija pozivov z verzioniranjem

Ključne ugotovitve

  • Nadzor zajema zakasnitev, napake, stroške in kakovost odgovorov
  • Sledi percentilom zakasnitve, nikoli le povprečju
  • Opozorila morajo biti stopnjevana: najprej opozorilo, nato kritično
  • Odklopnik ščiti pred kaskadnimi napakami; nadomestni model zagotavlja razpoložljivost
  • Kontrolni seznam za produkcijo preprečuje kritične spreglede

Preveri svoje znanje

Zakasnitev, stroški, evalvacije: produkcijski refleksi v petih vprašanjih.

1. Kateri so glavni vzvodi za zmanjšanje zakasnitve?

Odgovor: Pretakanje (streaming) (zaznana zakasnitev), predpomnjenje pozivov (stabilne predpone), Predvideni izhodi (Predicted Outputs), ko je odgovor večinoma predvidljiv (Chat Completions, na modelih, umaknjenih 14. januarja 2027), in optimizacija samega poziva – merjeno od konca do konca.

2. Kdaj uporabiti Batch API?

Odgovor: Za obsežno obdelavo brez omejitev v realnem času: asinhroni sklopi po znižani ceni – razvrščanje, obogatitev ali generiranje velikih količin nimajo mesta na sinhroni poti.

3. Kaj naredi stiskanje pogovora?

Odgovor: Stisne dolgo zgodovino (povzetki, obrezovanje), da se prilega kontekstu in nadzoruje stroške – bistveno za agente in dolge seje.

4. Kakšen je namen ogrodja Evals v CI/CD?

Odgovor: Samodejno izvajanje tvojih evalvacij ob vsaki spremembi poziva ali modela: regresija je zaznana ob potrditvi (commit), ne v produkciji.

5. Kaj vključuje celovita produkcijska arhitektura?

Odgovor: Nadzor (zakasnitev, stroški, kakovost), opozarjanje, asinhrone čakalne vrste, moderacijo v obsegu in načrt skaliranja – AI v produkciji je sistem, ne klic API-ja.

Meri, predpomni, združi v serije, neprestano evalviraj: štiri navade, ki naredijo aplikacije hitre, vitke in zanesljive.