Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Tootmisarhitektuur: jälgimine, hoiatused, skaleerimine

Õppetund 20 / 20 Värskendatud 3. november 2026 Edasijõudnutele
Sellel lehel
  1. Sinu rakendus tootmises: kolm sammast
  2. Vaatle: mida mõõta
  3. Reageeri: astmelised hoiatused
  4. Neela: kolm vastupidavusmehhanismi
  5. Toomisseviimise kontrollnimekiri
  6. Peamised punktid
  7. Testi oma teadmisi

Sinu rakendus tootmises: kolm sammast

LLM-rakenduse tootmisse viimine ei seisne ainult koodis. Kolm sammast tagavad töökindluse: jälgimine vaatlemiseks, hoiatused reageerimiseks ja skaleerimine koormuse talumiseks. Need moodustavad ahela ning ahel on nii tugev kui selle nõrgim lüli: mõõdikud, mida keegi ei vaata, on kasutud; hoiatused ilma reageerimisprotseduurita on müra; ja liiga hilja käivituv skaleerimine tähendab lihtsalt seisakut. See viimane tund koondab kõik kursuse mõisted terviklikuks tootmisarhitektuuriks.

Vaatle: mida mõõta

Neli mõõdikute perekonda katavad põhiosa: päringute maht, latentsus, vead ja kulud, jaotatuna mudelite kaupa. Just mudelite kaupa jaotamine teeb armatuurlaua tegutsemisvõimeliseks – globaalne veamäär 3% ei ütle sulle midagi, samas kui sama näitaja, mis koondub ühele konkreetsele mudelile, osutab koheselt süüdlasele.

Allpool olev klass kogub need mõõdikud mällu, kasutades 10 000 latentsusväärtuse libisevat akent, et vältida protsessi lõpmatut kasvu. Pane tähele protsentiilide kasutamist keskmiste asemel: LLM-teenuse keskmine latentsus on peaaegu alati eksitav, sest käputäis väga aeglaseid päringuid kaob keskmisesse ära, ometi on need just need, mille üle kasutajad kaebavad.

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

@dataclass
class ProductionMetrics:
    """Kogub olulisi tootmismõõdikuid."""

    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

        # Hoia alles ainult viimased 10 000 latentsust
        if len(self.latencies[model]) > 10_000:
            self.latencies[model] = self.latencies[model][-10_000:]

    def percentile(self, model: str, p: float) -> float:
        """Arvutab latentsuse protsentiili."""
        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:
        """Genereerib tervikliku armatuurlaua."""
        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

Muidugi peab kogumine olema süstemaatiline. Iga päringu käsitsi instrumendimine garanteerib, et unustad ühe – ja tõenäoliselt just selle, mis probleeme tekitab. Allpool olev dekoratoor viib mõõtmise päringufunktsiooni tasemele: plokk finally salvestab latentsuse ja edu olenemata olukorrast, isegi kui erand levib edasi.

import openai
import functools

metrics = ProductionMetrics()

def monitor(func):
    """Dekoraator, mis jälgib iga API päringut."""
    @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

Tokenite loendurid ja kulud jäävad selles versioonis nulliks, kuna vastuseobjekt pole salvestamise hetkel kättesaadav. Täida need, lugedes API tagastatud kasutusvälju: ilma selle informatsioonita kuvab sinu armatuurlaud ustavalt veergu nullkulusid.

Reageeri: astmelised hoiatused

Hoiatus on väärtuslik ainult siis, kui see nõuab tegutsemist. Seetõttu eristab süsteem iga mõdiku jaoks kahte lävendit: hoiatuslävend, mis annab märku kõrvalekaldest, mida tuleb päeva jooksul uurida, ja kriitiline lävend, mis õigustab kellegi ülesajamist. Nende kahe segamine toodab halvimat võimalikku tulemust – meeskonna, kes on õppinud teavitusi ignoreerima.

from enum import Enum

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

class AlertSystem:
    """Käivitab hoiatusi mõõdikute põhjal."""

    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]:
        """Kontrollib mõõdikuid ja genereerib hoiatusi."""
        alerts = []

        for model in metrics.counters:
            # Veamäär
            rate = metrics.error_rate(model)
            if rate >= self.thresholds["error_rate"]["critical"]:
                alerts.append({
                    "level": AlertLevel.CRITICAL,
                    "message": (
                        f"KRITILINE veamäär mudelil {model}: "
                        f"{rate:.1%}"
                    ),
                    "model": model,
                })
            elif rate >= self.thresholds["error_rate"]["warning"]:
                alerts.append({
                    "level": AlertLevel.WARNING,
                    "message": (
                        f"Kõrge veamäär mudelil {model}: "
                        f"{rate:.1%}"
                    ),
                    "model": model,
                })

            # Latentsus
            p99 = metrics.percentile(model, 99)
            if p99 >= self.thresholds["latency_p99"]["critical"]:
                alerts.append({
                    "level": AlertLevel.CRITICAL,
                    "message": (
                        f"KRITILINE p99 latentsus mudelil {model}: "
                        f"{p99:.1f}s"
                    ),
                    "model": model,
                })

        self.sent_alerts.extend(alerts)
        return alerts

    async def notify(self, alerts: list[dict]):
        """Saadab teavitused (webhook, e-post, Slack)."""
        import httpx

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

Tunnipõhised kuluhoiatused on need, mida kõige sagedamini unustatakse, ja see on kahju: piiramatu kordusproovide tsükkel või kaks korda käivitatud batch-töö tulemuseks on arve, mitte viga. See on ainus ohutusvõrk, mis tuvastab seda tüüpi intsidente nende toimumise hetkel.

Neela: kolm vastupidavusmehhanismi

Kui API tagastab vea, muudab uuesti proovimine asja hullemaks: lisad koormust teenusele, mis on juba hädas, ja paned oma kasutajad ootama tulemusteta. Vooluahela katkestaja (circuit breaker) pöörab selle loogika ümber. Pärast määratud arv järjestikuseid tõrkeid avab see vooluahela ja lükkab järgnevad päringud koheselt tagasi, proovides seejärel uuesti pärast lähtestusviivitust.

class CircuitBreaker:
    """Katkestab päringud, kui vigu tekib liiga palju."""

    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:
            # Püüa vooluahel sulgeda
            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):
        """Käivitab funktsiooni, kui vooluahel on suletud."""
        if self.is_open:
            raise RuntimeError(
                "Vooluahel avatud — API pole saadaval. "
                f"Proovi uuesti {self.reset_delay}s pärast."
            )
        try:
            result = func(*args, **kwargs)
            self.record_success()
            return result
        except Exception as e:
            self.record_failure()
            raise

Vooluahela katkestaja kaitseb sinu rakendust; see ei pane seda siiski tööle. Selle eest hoolitseb mudeli varukoopia (fallback), mis proovib alternatiive järjekorras, jättes vahele need, mille vooluahelad on juba avatud. Üks disainipunkt, mida meeles pidada: nimekirja järjekord on tooteotsus, mitte tehniline. Pane esimesena mudel, mis pakub oodatud teenust, sellele järgnevad need, mis pakuvad degradeerunud, kuid vastuvõetavat teenust – veidi vähem terav vastus on parem kui kättesaamatu teade.

class ModelFallback:
    """Lülitab tõrke korral üle varumudelile."""

    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:
        """Proovib iga mudelit, kuni vastus saadakse."""
        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("Kõik mudelid on kättesaamatud.")

Kolmas mehhanism puudutab suuruse määramist. Töötajate arvu juhtimine järjekorra suuruse, mitte CPU koormuse põhjal on õige refleks teenuse jaoks, mis veedab suurema osa ajast võrguvastuste ootamisel: CPU seisab jõude, samal ajal kui järjekord kasvab. Pane tähele rakendatud reegli asümmeetriat – skaleerimisel suurendame kahekordistades ja vähendame poolitades, kasutades lahus olevaid lävendeid (100 vs 10). See vahe hoiab ära võnkumise: ilma selleta veedaks süsteem aega töötajate loomise ja hävitamisega ümber pöördepunkti.

class AutoScaler:
    """Kohandab töötajate arvu koormuse põhjal."""

    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:
        """Tagastab soovitatava töötajate arvu."""
        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

Toomisseviimise kontrollnimekiri

See kursus lõpeb kontrollnimekirjaga, mis tuleb läbi vaadata enne rakenduse avalikkusele avamist. Iga punkt viitab tunnis käsitletud teemale; kui mõni tundub ebaselge, loe see tund enne kasutuselevõttu uuesti läbi.

  • Latentsuse jälgimine (p50, p95, p99) ja veamäärad
  • Hoiatused konfigureeritud kriitilistel lävenditel
  • Vooluahela katkestaja API tõrkete eest kaitsmiseks
  • Mudeli varukoopia konfigureeritud
  • Sisendi ja väljundi moderatsioon lubatud
  • Kliendipoolne kiiruse piiramine rakendatud
  • Struktureeritud logid silumiseks
  • Automatiseeritud hindamised (evals) CI/CD protsessis
  • Kulude eelarve koos hoiatustega
  • Versioneeritud vihjete (prompt) dokumentatsioon

Peamised punktid

  • Jälgimine hõlmab latentsust, vigu, kulusid ja vastuse kvaliteeti
  • Jälgi latentsuse protsentiile, mitte kunagi ainult keskmist
  • Hoiatused peavad olema astmelised: esmalt hoiatus, siis kriitiline
  • Vooluahela katkestaja kaitseb tõrgete kaskaadi eest; varukoopia tagab kättesaadavuse
  • Tootmise kontrollnimekiri hoiab ära kriitilised unustused

Testi oma teadmisi

Latentsus, kulud, hindamised: tootmisrefleksid viies küsimuses.

1. Mis on peamised hoovad latentsuse vähendamiseks?

Vastus: Voogedastus (tajutav latentsus), vihjete vahemällu salvestamine (stabiilsed prefiksid), ennustatud väljundid, kui vastus on suuresti ennustatav (Chat Completions, mudelitel, mis suleti 14. jaanuaril 2027), ja ise vihje optimeerimine – mõõdetuna otsast otsani.

2. Millal peaksid kasutama Batch API-t?

Vastus: Massiliseks töötlemiseks ilma reaalaja nõueteta: asünkroonsed paketid madalama hinnaga – järjestamine, rikastamine või mahuline genereerimine ei kuulu sünkroonsele teele.

3. Mida teeb vestluse kompaktseks muutmine?

Vastus: See tihendab pikka ajalugu (kokkuvõtted, kärpimine), et mahutada see konteksti ja kontrollida kulusid – hädavajalik agentide ja pikkade sessioonide jaoks.

4. Mis on hindamisraamistiku (Evals framework) eesmärk CI/CD-s?

Vastus: Käivitada automaatselt sinu hindamised iga vihje või mudeli muutuse korral: regressioon tuvastatakse kinnitamise (commit) hetkel, mitte tootmises.

5. Mida hõlmab terviklik tootmisarhitektuur?

Vastus: Jälgimine (latentsus, kulud, kvaliteet), hoiatused, asünkroonsed järjekorrad, mahukas moderatsioon ja skaleerimiskava – AI tootmises on süsteem, mitte API päring.

Mõõda, vahemällu salvesta, kasuta pakette, hinda pidevalt: neli harjumust, mis teevad rakendused kiireks, säästlikuks ja usaldusväärseks.