Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Gyártási architektúra: monitorozás, riasztás, méretezés

20. lecke 20 közül Frissítve 2026. november 3. Haladó
Ezen az oldalon
  1. Alkalmazásod éles környezetben: a három pillér
  2. Megfigyelés: mit mérjünk?
  3. Reagálás: fokozatos riasztások
  4. Elnyelés: három rugalmassági mechanizmus
  5. Gyártási telepítési ellenőrzőlista
  6. Főbb megállapítások
  7. Teszteld a tudásod

Alkalmazásod éles környezetben: a három pillér

Egy LLM-alkalmazás éles környezetbe helyezése nem csupán a kódról szól. Három pillér garantálja a megbízhatóságot: a monitorozás a megfigyeléshez, a riasztás a reagáláshoz és a méretezés a terhelés elnyeléséhez. Ezek egy láncot alkotnak, és egy lánc csak annyira erős, mint a leggyengébb láncszeme: a senki által nem figyelt metrikák haszontalanok, a válaszadási eljárás nélküli riasztások csak zajt keltenek, a túl későn bekapcsoló méretezés pedig egyszerűen kiesést jelent. Ez az utolsó lecke a tanfolyam összes koncepcióját egy teljes gyártási architektúrába foglalja össze.

Megfigyelés: mit mérjünk?

Négy metrikacsalád fedi le a lényeget: hívásszám, késleltetés, hibák és költség, modellenként lebontva. A modellenkénti lebontás teszi cselekvőképessé a műszerfalat – a globális 3%-os hibaarány semmit sem mond, míg ugyanez az érték egyetlen modellre koncentrálva azonnal rámutat a bűnösre.

Az alábbi osztály ezeket a metrikákat gyűjti össze a memóriában, egy 10 000 késleltetési értékből álló csúszó ablakot használva, hogy megakadályozza a folyamat végtelen növekedését. Figyeld meg a percentilisek használatát az átlagok helyett: egy LLM-szolgáltatás átlagos késleltetése szinte mindig félrevezető, mert néhány nagyon lassú hívás elvész az átlagban, pedig éppen ezek miatt panaszkodnak a felhasználóid.

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

@dataclass
class ProductionMetrics:
    """Összegyűjti a lényeges gyártási metrikákat."""

    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

        # Csak az utolsó 10 000 késleltetést tartsuk meg
        if len(self.latencies[model]) > 10_000:
            self.latencies[model] = self.latencies[model][-10_000:]

    def percentile(self, model: str, p: float) -> float:
        """Kiszámít egy késleltetési percentilist."""
        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:
        """Teljes műszerfalat generál."""
        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

Természetesen a gyűjtésnek szisztematikusnak kell lennie. Ha minden hívást manuálisan instrumentálsz, garantált, hogy elfelejtesz egyet – és valószínűleg éppen azt, amelyik gondot okoz. Az alábbi dekorátor a mérést a hívási függvény szintjére helyezi: a finally blokk rögzíti a késleltetést és a sikert függetlenül attól, mi történik, még akkor is, ha kivétel propagálódik.

import openai
import functools

metrics = ProductionMetrics()

def monitor(func):
    """Dekorátor, amely minden API-hívást monitoroz."""
    @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

A tokenszámlálók és a költség ebben a verzióban nullák maradnak, mert a válaszobjektum a rögzítés pillanatában még nem áll rendelkezésre. Egészítsd ki őket az API által visszaadott használati (usage) mezők olvasásával: ezen információk nélkül a műszerfalad hűségesen nullák oszlopát fogja megjeleníteni.

Reagálás: fokozatos riasztások

Egy riasztás csak akkor értékes, ha cselekvésre szólít fel. Ezért a rendszer metrikánként két küszöbértéket különböztet meg: egy figyelmeztető küszöböt, amely napközbeni vizsgálatot igénylő elcsúszást jelez, és egy kritikus küszöböt, amely indokolttá teszi valaki felébresztését. A kettő összekeverése a lehető legrosszabb kimenetelt eredményezi: egy csapatot, amely megtanulta figyelmen kívül hagyni az értesítéseket.

from enum import Enum

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

class AlertSystem:
    """Riasztásokat indít a metrikák alapján."""

    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]:
        """Ellenőrzi a metrikákat és riasztásokat generál."""
        alerts = []

        for model in metrics.counters:
            # Hibaarány
            rate = metrics.error_rate(model)
            if rate >= self.thresholds["error_rate"]["critical"]:
                alerts.append({
                    "level": AlertLevel.CRITICAL,
                    "message": (
                        f"KRITIKUS hibaarány ennél a modellnél: {model}: "
                        f"{rate:.1%}"
                    ),
                    "model": model,
                })
            elif rate >= self.thresholds["error_rate"]["warning"]:
                alerts.append({
                    "level": AlertLevel.WARNING,
                    "message": (
                        f"Magas hibaarány ennél a modellnél: {model}: "
                        f"{rate:.1%}"
                    ),
                    "model": model,
                })

            # Késleltetés
            p99 = metrics.percentile(model, 99)
            if p99 >= self.thresholds["latency_p99"]["critical"]:
                alerts.append({
                    "level": AlertLevel.CRITICAL,
                    "message": (
                        f"KRITIKUS p99 késleltetés ennél a modellnél: {model}: "
                        f"{p99:.1f}s"
                    ),
                    "model": model,
                })

        self.sent_alerts.extend(alerts)
        return alerts

    async def notify(self, alerts: list[dict]):
        """Értesítéseket küld (webhook, e-mail, Slack)."""
        import httpx

        for alert in alerts:
            if alert["level"] == AlertLevel.CRITICAL:
                # Azonnali értesítés
                async with httpx.AsyncClient() as http:
                    await http.post(
                        "https://your-webhook.example.com/alerts",
                        json={
                            "level": alert["level"].value,
                            "message": alert["message"],
                        },
                    )

Az óránkénti költségriasztásokat felejtik el leggyakrabban, és ez kár: egy korlátlan újrapróbálkozási ciklus vagy egy kétszer elindított kötegelt feladat számlát eredményez, nem hibát. Ez az egyetlen biztonsági háló, amely észleli ezt a típusú incidienst még közben.

Elnyelés: három rugalmassági mechanizmus

Amikor az API hibát ad vissza, az újrapróbálkozás csak ront a helyzeten: terhelést adsz egy már bajban lévő szolgáltatásra, és hiába várakoztatod a saját felhasználóidat. A megszakító áramkör (circuit breaker) megfordítja ezt a logikát. A meghatározott számú egymást követő hiba után megnyitja az áramkört, és azonnal elutasítja a subsequent hívásokat, majd egy visszaállítási késleltetés után újra próbálkozik.

class CircuitBreaker:
    """Levágja a hívásokat túl sok hiba esetén."""

    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:
            # Kísérlet az áramkör zárására
            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):
        """Végrehajtja a függvényt, ha az áramkör zárva van."""
        if self.is_open:
            raise RuntimeError(
                "Áramkör nyitva — az API nem elérhető. "
                f"Próbáld újra {self.reset_delay}s múlva."
            )
        try:
            result = func(*args, **kwargs)
            self.record_success()
            return result
        except Exception as e:
            self.record_failure()
            raise

A megszakító áramkör megvédi az alkalmazásodat, de nem teszi működőképessé. Ez a modell-tartalék (fallback) feladata, amely sorrendben próbálkozik alternatívákkal, kihagyva azokat, amelyeknek az áramköre már nyitva van. Egy tervezési pontra érdemes emlékezni: a lista sorrendje termékdöntés, nem technikai. Előre tedd azt a modellt, amelyik a várt szolgáltatást nyújtja, utána azokat, amelyek degradált, de elfogadható szolgáltatást biztosítanak – egy kicsit kevésbé éles válasz jobb, mint egy elérhetetlen üzenet.

class ModelFallback:
    """Hiba esetén tartalék modellre vált."""

    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:
        """Minden modellt megpróbál, amíg választ nem kap."""
        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("Minden modell elérhetetlen.")

A harmadik mechanizmus a méretezéssel foglalkozik. A munkafolyamatok számának a sorhossz alapján történő vezérlése, nem pedig a CPU-terhelés alapján, a helyes reflex egy olyan szolgáltatásnál, amely ideje nagy részét hálózati válaszokra várva tölti: a CPU tétlenül áll, miközben a sor nő. Figyeld meg az alkalmazott szabály aszimmetriáját – duplázunk felfelé méretezéskor és felezünk lefelé, szélesen elválasztott küszöbökkel (100 vs. 10). Ez a rés megakadályozza az oszcillációt: enélkül a rendszer folyamatosan munkafolyamatokat hozna létre és semmisítene meg a billenési pont körül.

class AutoScaler:
    """A munkafolyamatok számát a terhelés alapján igazítja."""

    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:
        """Visszaadja az ajánlott munkafolyamatok számát."""
        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

Gyártási telepítési ellenőrzőlista

Ez a tanfolyam azzal az ellenőrzőlistával zárul, amelyet végig kell futtatnod, mielőtt alkalmazásodat megnyitnád a nyilvánosság előtt. Minden tétel egy általad tárgyalt leckére utal; ha valamelyik nem világos, olvasd újra azt a leckét telepítés előtt.

  • Késleltetés-monitorozás (p50, p95, p99) és hibaarányok
  • Kritikus küszöbökön beállított riasztások
  • Megszakító áramkör az API-hibák elleni védelemhez
  • Konfigurált modell-tartalék
  • Bemeneti és kimeneti moderálás engedélyezve
  • Kliens oldali sebességkorlátozás implementálva
  • Strukturált naplók a hibakereséshez
  • Automatizált értékelések a CI/CD-ben
  • Költségkeret riasztásokkal
  • Verzionált prompt dokumentáció

Főbb megállapítások

  • A monitorozás kiterjed a késleltetésre, hibákra, költségekre és a válasz minőségére
  • Kövesd nyomon a késleltetés percentiliseit, soha ne csak az átlagot
  • A riasztásoknak fokozatosaknak kell lenniük: először figyelmeztetés, majd kritikus
  • A megszakító áramkör megvéd a hibaláncolatoktól; a tartalék biztosítja a rendelkezésre állást
  • Egy gyártási ellenőrzőlista megelőzi a kritikus mulasztásokat

Teszteld a tudásod

Késleltetés, költségek, értékelések: gyártási reflexek öt kérdésben.

1. Mik a késleltetés csökkentésének fő eszközei?

Válasz: Streaming (észlelt késleltetés), prompt gyorsítótárazás (stabil prefixek), Előre jelzett kimenetek (Predicted Outputs), amikor a válasz nagyban előre jelezhető (Chat Completions, a 2027. január 14-én nyugdíjazott modelleken), és maga a prompt optimalizálása – végpontok között mérve.

2. Mikor kell használni a Batch API-t?

Válasz: Hatalmas feldolgozáshoz valós idejű követelmények nélkül: aszinkron kötegek csökkentett költséggel – a rangsorolás, dúsítás vagy nagy volumenű generálás nem való a szinkron útvonalra.

3. Mit csinál a beszélgetés-tömörítés?

Válasz: Összenyomja a hosszú előzményeket (összefoglalók, metszés), hogy illeszkedjen a kontextusba és kontrollálja a költségeket – elengedhetetlen ügynököknél és hosszú munkameneteknél.

4. Mi az Evals keretrendszer célja a CI/CD-ben?

Válasz: Az értékelések automatikus futtatása minden prompt- vagy modellváltoztatáskor: a regressziót a commitnál észleljük, nem éles környezetben.

5. Mit tartalmaz egy teljes gyártási architektúra?

Válasz: Monitorozást (késleltetés, költségek, minőség), riasztást, aszinkron sorokat, nagy léptékű moderálást és egy méretezési tervet – az AI éles környezetben egy rendszer, nem egy API-hívás.

Mérj, gyorsítótárazz, kötegeld, értékelj folyamatosan: négy szokás, amely gyors, karcsú és megbízható alkalmazásokat eredményez.