Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Architektúra produkcie: monitorovanie, alerting, škálovanie

Lekcia 20 z 20 Aktualizované 3. novembra 2026 Pokročilý
Na tejto strane
  1. Tvoja aplikácia v produkcii: tri piliere
  2. Pozoruj: čo merať
  3. Reaguj: gradované alerty
  4. Absorbuj: tri mechanizmy odolnosti
  5. Kontrolný zoznam nasadenia do produkcie
  6. Kľúčové poznatky
  7. Otestuj si svoje vedomosti

Tvoja aplikácia v produkcii: tri piliere

Nasadenie LLM aplikácie do produkcie nie je len o kóde. Tri piliere zaručujú spoľahlivosť: monitorovanie na pozorovanie, alerting na reakciu a škálovanie na zvládnutie záťaže. Tvoria reťaz a reťaz je taký silný, ako jeho najslabší článok: metriky, na ktoré sa nikto nepozerá, sú zbytočné, alerty bez postupu reakcie sú šum a škálovanie, ktoré sa spustí príliš neskoro, je výpadok. Táto záverečná lekcia spája všetky koncepty kurzu do kompletnej produkčnej architektúry.

Pozoruj: čo merať

Štyri rodiny metrík pokrývajú to podstatné: objem volaní, latencia, chyby a náklady, členené podľa modelu. Členenie podľa modelu je to, čo robí dashboard použiteľným – globálna miera chýb 3 % ti nič nepovie, zatiaľ čo tá istá hodnota sústredená na jeden model okamžite ukáže vinníka.

Nižšie uvedená trieda akumuluje tieto metriky v pamäti pomocou posuvného okna 10 000 latencií, aby sa proces neustále nezväčšoval. Všimni si použitie percentilov namiesto priemerov: priemerná latencia služby LLM je takmer vždy zavádzajúca, pretože handful veľmi pomalých volaní sa stratí v priemere, no práve tie sú dôvodom sťažností tvojich používateľov.

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

Zber musí byť samozrejme systematický. Ručné inštrumentovanie každého volania garantuje, že na jedno zabudneš – a pravdepodobne na to, ktoré spôsobí problémy. Nižšie uvedený dekorátor presúva meranie na úroveň funkcie volania: blok finally zaznamená latenciu a úspešnosť bez ohľadu na okolnosti, aj keď sa vyhodí výnimka.

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

Počítadlá tokenov a náklady zostávajú v tejto verzii nulové, pretože objekt odpovede nie je v čase záznamu k dispozícii. Doplň ich čítaním polí usage vrátených API: bez týchto informácií bude tvoj dashboard verne zobrazovať stĺpec nulových nákladov.

Reaguj: gradované alerty

Alert má hodnotu len vtedy, ak si vyžaduje akciu. Preto systém rozlišuje dva prahy pre každú metriku: varovný prah, ktorý signalizuje posun hodný preskúmania počas dňa, a kritický prah, ktorý ospravedlňuje prebudenie niekoho zo spánku. Zmiešanie týchto dvoch vedie k najhoršiemu možnému výsledku – tím, ktorý sa naučil ignorovať notifikácie.

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"],
                        },
                    )

Alerty na hodinové náklady sú tie, na ktoré sa najčastejšie zabúda, a to je škoda: neobmedzená slučka opakovaných pokusov alebo dávková úloha spustená dvakrát výsledkom nie je chyba, ale faktúra. Je to jediná bezpečnostná sieť, ktorá deteguje tento typ incidentu priamo v momente jeho vzniku.

Absorbuj: tri mechanizmy odolnosti

Keď API vráti chybu, opakovanie veci zhoršuje: pridávaš záťaž službe, ktorá už má problémy, a nútiš svojich používateľov čakať nazdarmo. Istič (circuit breaker) obracia túto logiku. Po definovanom počte po sebe idúcich zlyhaní otvorí obvod a okamžite odmietne následné volania, potom sa po oneskorení resetu pokúsi znova.

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

Istič chráni tvoju aplikáciu, ale nezabezpečuje jej funkčnosť. To je úlohou záložného modelu (model fallback), ktorý skúša alternatívy v poradí a preskakuje tie, ktorých obvody sú už otvorené. Jeden dizajnový bod, na ktorý treba pamätať: poradie zoznamu je produktové rozhodnutie, nie technické. Na prvé miesto daj model, ktorý poskytuje očakávanú službu, nasledovaný tými, ktoré poskytujú degradovanú, ale prijateľnú službu – trochu menej ostrá odpoveď je lepšia ako nedostupná správa.

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.")

Tretí mechanizmus sa týka dimenzovania. Riadenie počtu workerov na základe veľkosti frontu namiesto zaťaženia CPU je správny reflex pre službu, ktorá trávi väčšinu času čakáním na odpovede siete: CPU sedí nečinne, zatiaľ čo front rastie. Všimni si asymetriu v aplikovanom pravidle – pri škálovaní nahor zdvojnásobujeme a pri škálovaní nadol polovičíme, pričom prahy sú široko oddelené (100 oproti 10). Táto medzera zabraňuje oscilácii: bez nej by systém trávil čas vytváraním a ničením workerov okolo bodu zvratu.

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

Kontrolný zoznam nasadenia do produkcie

Tento kurz končí kontrolným zoznamom, ktorý si musíš prejsť pred otvorením aplikácie pre verejnosť. Každá položka odkazuje na lekciu, ktorú si prešiel; ak sa ti niečo zdá nejasné, prečítaj si túto lekciu znova pred nasadením.

  • Monitorovanie latencie (p50, p95, p99) a mier chýb
  • Alerty nakonfigurované na kritické prahy
  • Istič na ochranu pred zlyhaniami API
  • Nakonfigurovaný záložný model
  • Povolená moderácia vstupov a výstupov
  • Implementované obmedzenie rýchlosti na strane klienta
  • Štruktúrované logy na ladenie
  • Automatizované evals v CI/CD
  • Rozpočet na náklady s alertmi
  • Verzionovaná dokumentácia promptov

Kľúčové poznatky

  • Monitorovanie pokrýva latenciu, chyby, náklady a kvalitu odpovedí
  • Sleduj percentily latencie, nikdy len priemer
  • Alerty musia byť gradované: najprv varovanie, potom kritické
  • Istič chráni pred kaskádovým zlyhaním; záložný model zabezpečuje dostupnosť
  • Kontrolný zoznam produkcie zabraňuje kritickým prehliadnutiam

Otestuj si svoje vedomosti

Latencia, náklady, evals: produkčné reflexy v piatich otázkach.

1. Aké sú hlavné páky na zníženie latencie?

Odpoveď: Streamovanie (vnímaná latencia), ukladanie promptov do cache (stabilné prefixy), Predpovedané výstupy, keď je odpoveď z veľkej časti predvídateľná (Chat Completions, na modeloch vyradených 14. januára 2027) a optimalizácia samotného promptu – merané end-to-end.

2. Kedy by si mal použiť Batch API?

Odpoveď: Pre masívne spracovanie bez požiadaviek na reálny čas: asynchrónne dávky za znížené náklady – hodnotenie, obohatenie alebo generovanie objemu nemajú miesto na synchrónnej ceste.

3. Čo robí kompresia konverzácie?

Odpoveď: Kompresuje dlhú históriu (súhrny, orezávanie), aby sa zmestila do kontextu a kontrolovali náklady – nevyhnutné pre agentov a dlhé relácie.

4. Aký je účel frameworku Evals v CI/CD?

Odpoveď: Automaticky spustiť tvoje evaluácie pri každej zmene promptu alebo modelu: regresia sa deteguje pri commite, nie v produkcii.

5. Čo zahŕňa kompletná produkčná architektúra?

Odpoveď: Monitorovanie (latencia, náklady, kvalita), alerting, asynchrónne fronty, moderácia vo veľkom mierke a plán škálovania – AI v produkcii je systém, nie volanie API.

Meraj, ukladaj do cache, dávkuje, neustále evaluuj: štyri návyky, ktoré robia aplikácie rýchlymi, štíhlymi a spoľahlivými.