Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Arhitektūra ražošanai: uzraudzība, brīdinājumi, mērogošana

Nodarbība 20 no 20 Atjaunota 2026. gada 3. novembris Augstākais
Šajā lapā
  1. Tava lietotne ražošanā: trīs pīlāri
  2. Novēro: ko mērīt
  3. Reaģē: pakāpeniski brīdinājumi
  4. Absorbē: trīs noturības mehānismi
  5. Ražošanas izvietošanas kontrolsaraksts
  6. Galvenās atziņas
  7. Pārbaudi savas zināšanas

Tava lietotne ražošanā: trīs pīlāri

LLM lietotnes izvietošana ražošanā nav tikai par kodu. Trīs pīlāri garantē uzticamību: uzraudzība, lai novērotu, brīdinājumi, lai reaģētu, un mērogošana, lai absorbētu slodzi. Tie veido ķēdi, un ķēde ir tik stipra, cik tās vājākais posms: metrikas, uz kurām neviens neskatās, ir bezjēdzīgas, brīdinājumi bez reakcijas procedūras ir troksnis, un mērogošana, kas iedarbojas par vēlu, ir vienkārši pārtraukums. Šī noslēdzošā nodarbība apvieno visus kursa konceptus vienotā ražošanas arhitektūrā.

Novēro: ko mērīt

Četras metrikas ģimenes aptver būtisko: izsaukumu apjomu, latentumu, kļūdas un izmaksas, sadalot pa modeļiem. Tieši sadalījums pa modeļiem padara informācijas paneli izmantojamu — globāls kļūdu līmenis 3% tev neko nepasaka, savukārt tas pats rādītājs, kas koncentrēts uz vienu modeli, uzreiz norāda uz vaininieku.

Zemāk esošā klase uzkrāj šīs metrikas atmiņā, izmantojot slīdošo logu ar 10 000 latentuma vērtībām, lai novērstu procesa neierobežotu augšanu. Ņem vērā, ka tiek izmantoti percentiļi, nevis vidējās vērtības: LLM servisa vidējais latentums gandrīz vienmēr ir maldinošs, jo daži ļoti lēni izsaukumi pazūd vidējā rādītājā, taču tieši par tiem sūdzas tavi lietotāji.

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

@dataclass
class ProductionMetrics:
    """Vāc būtiskas ražošanas metrikas."""

    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

        # Saglabā tikai pēdējos 10 000 latentumus
        if len(self.latencies[model]) > 10_000:
            self.latencies[model] = self.latencies[model][-10_000:]

    def percentile(self, model: str, p: float) -> float:
        """Aprēķina latentuma percentili."""
        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:
        """Ģenerē pilnu informācijas paneli."""
        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

Protams, vākšanai jābūt sistemātiskai. Katra izsaukuma manuāla instrumentēšana garantē, ka kādu aizmirsīsi — un, visticamāk, tieši to, kas radīs problēmas. Zemāk esošais dekorators pārvieto mērīšanu uz izsaukuma funkcijas līmeni: bloks finally reģistrē latentumu un veiksmi neatkarīgi no tā, kas notiek, pat ja izplatās izņēmums.

import openai
import functools

metrics = ProductionMetrics()

def monitor(func):
    """Dekorators, kas uzrauga katru API izsaukumu."""
    @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

Šajā versijā tokena skaitītāji un izmaksas paliek nulles, jo ierakstīšanas brīdī atbildes objekts vēl nav pieejams. Papildini tos, nolasot API atgrieztos lietojuma laukus: bez šīs informācijas tavs informācijas panelis uzticami attēlos nullu kolonnu izmaksām.

Reaģē: pakāpeniski brīdinājumi

Brīdinājums ir vērtīgs tikai tad, ja tas prasa rīcību. Tieši tāpēc sistēma katram rādītājam nošķir divus sliekšņus: brīdinājuma slieksni, kas signalizē par novirzi, kas jāizvērtē dienas laikā, un kritisko slieksni, kas attaisno kāda pamodināšanu. Šo divu sajaukšana rada vissliktāko iespējamo iznākumu — komandu, kas ir iemācījusies ignorēt paziņojumus.

from enum import Enum

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

class AlertSystem:
    "Izraisa brīdinājumus, pamatojoties uz metrikām."

    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]:
        """Pārbauda metrikas un ģenerē brīdinājumus."""
        alerts = []

        for model in metrics.counters:
            # Kļūdu līmenis
            rate = metrics.error_rate(model)
            if rate >= self.thresholds["error_rate"]["critical"]:
                alerts.append({
                    "level": AlertLevel.CRITICAL,
                    "message": (
                        f"KRITISKS kļūdu līmenis modelim {model}: "
                        f"{rate:.1%}"
                    ),
                    "model": model,
                })
            elif rate >= self.thresholds["error_rate"]["warning"]:
                alerts.append({
                    "level": AlertLevel.WARNING,
                    "message": (
                        f"Augsts kļūdu līmenis modelim {model}: "
                        f"{rate:.1%}"
                    ),
                    "model": model,
                })

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

        self.sent_alerts.extend(alerts)
        return alerts

    async def notify(self, alerts: list[dict]):
        """Nosūta paziņojumus (webhook, e-pasts, Slack)."""
        import httpx

        for alert in alerts:
            if alert["level"] == AlertLevel.CRITICAL:
                # Tūlītējs paziņojums
                async with httpx.AsyncClient() as http:
                    await http.post(
                        "https://your-webhook.example.com/alerts",
                        json={
                            "level": alert["level"].value,
                            "message": alert["message"],
                        },
                    )

Brīdinājumi par stundas izmaksām ir tie, kurus visbiežāk aizmirst, un tas ir žēl: neierobežots atkārtojumu cikls vai divreiz palaists batch uzdevums rada rēķinu, nevis kļūdu. Tas ir vienīgais drošības tīkls, kas šāda veida incidentus atklāj to norises laikā.

Absorbē: trīs noturības mehānismi

Kad API atgriež kļūdu, atkārtošana pasliktina situāciju: tu pievieno slodzi servisam, kas jau ir grūtībās, un liec saviem lietotājiem velti gaidīt. Ķēdes pārtraucējs (circuit breaker) apvērš šo loģiku. Pēc noteikta secīgu neveiksmju skaita tas atver ķēdi un nekavējoties noraida turpmākos izsaukumus, pēc tam mēģinot atkārtoti pēc atiestatīšanas aiztures.

class CircuitBreaker:
    """Pārtrauc izsaukumus, ja notiek pārāk daudz kļūdu."""

    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:
            # Mēģina aizvērt ķēdi
            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):
        """Izpilda funkciju, ja ķēde ir aizvērta."""
        if self.is_open:
            raise RuntimeError(
                "Ķēde atvērta — API nav pieejams. "
                f"Mēģini vēlreiz pēc {self.reset_delay}s."
            )
        try:
            result = func(*args, **kwargs)
            self.record_success()
            return result
        except Exception as e:
            self.record_failure()
            raise

Ķēdes pārtraucējs aizsargā tavu lietotni; tas tomēr neliek tai strādāt. To dara modeļa rezerves kopija (fallback), kas secīgi mēģina alternatīvas, izlaižot tās, kuru ķēdes jau ir atvērtas. Viens dizaina punkts, kas jāatceras: saraksta kārtība ir produkta lēmums, nevis tehnisks. Pirmo liec modeli, kas nodrošina paredzēto servisu, kam seko tie, kas nodrošina degradētu, bet pieņemamu servisu — nedaudz mazāk asa atbilde ir labāka par nepieejamu ziņojumu.

class ModelFallback:
    """Pārslēdzas uz rezerves modeli neveiksmes gadījumā."""

    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:
        """Mēģina katru modeli, līdz tiek iegūta atbilde."""
        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("Visi modeļi nav pieejami.")

Trešais mehānisms attiecas uz izmēru noteikšanu. Darbinieku skaita vadīšana, balstoties uz rindas lielumu, nevis CPU slodzi, ir pareizais reflekss servisam, kas lielāko daļu laika pavada, gaidot tīkla atbildes: CPU dīvē, kamēr rinda aug. Ņem vērā asimetriju pielietotajā likumā — mēs dubultojam, mērogojot uz augšu, un samazinām uz pusi, mērogojot uz leju, izmantojot plaši atdalītus sliekšņus (100 pret 10). Šī atstarpe novērš svārstības: bez tās sistēma pastāvīgi radītu un iznīcinātu darbiniekus ap pagrieziena punktu.

class AutoScaler:
    """Pielāgo darbinieku skaitu atkarībā no slodzes."""

    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:
        """Atgriež ieteicamo darbinieku skaitu."""
        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

Ražošanas izvietošanas kontrolsaraksts

Šis kurss noslēdzas ar kontrolsarakstu, kas jāiziet pirms lietotnes atvēršanas publiskai lietošanai. Katrs punkts atsaucas uz nodarbību, ko esi apguvis; ja kāds šķiet neskaidrs, pārlasi šo nodarbību pirms izvietošanas.

  • Latentuma uzraudzība (p50, p95, p99) un kļūdu līmeņi
  • Brīdinājumi konfigurēti uz kritiskajiem sliekšņiem
  • Ķēdes pārtraucējs aizsardzībai pret API kļūdām
  • Konfigurēta modeļa rezerves kopija (fallback)
  • Ievades un izvades moderācija iespējota
  • Klienta puses ātruma ierobežošana (rate limiting) ieviesta
  • Strukturēti žurnāli atkļūdošanai
  • Automatizēti evali CI/CD procesā
  • Izmaksu budžets ar brīdinājumiem
  • Versijotu promptu dokumentācija

Galvenās atziņas

  • Uzraudzība aptver latentumu, kļūdas, izmaksas un atbilžu kvalitāti
  • Izseko latentuma percentiļus, nekad tikai vidējo vērtību
  • Brīdinājumiem jābūt pakāpeniskiem: vispirms brīdinājums, tad kritisks
  • Ķēdes pārtraucējs aizsargā pret kļūdu kaskādēm; rezerves kopija nodrošina pieejamību
  • Ražošanas kontrolsaraksts novērš kritiskas kļūdas

Pārbaudi savas zināšanas

Latentums, izmaksas, evali: ražošanas refleksi piecos jautājumos.

1. Kādi ir galvenie sviras, lai samazinātu latentumu?

Atbilde: Straumēšana (uztvertais latentums), promptu kešošana (stabilas prefiksu daļas), Prognozētās izejas (Predicted Outputs), kad atbilde ir lielā mērā paredzama (Chat Completions, modeļiem, kas izņemti no aprites 2027. gada 14. janvārī), un paša prompta optimizēšana — mērīts no gala līdz galam.

2. Kad jāizmanto Batch API?

Atbilde: Masveida apstrādei bez reāllaika ierobežojumiem: asinhronas partijas par samazinātu cenu — rangēšanai, bagātināšanai vai apjoma ģenerēšanai nav vietas sinhronajā ceļā.

3. Ko dara sarunu kompaktizēšana?

Atbilde: Tā saspiež garu vēsturi (kopsavilkumi, apgriešana), lai ietilptu kontekstā un kontrolētu izmaksas — būtiski aģentiem un garām sesijām.

4. Kāds ir Evals frameworka mērķis CI/CD?

Atbilde: Automātiski palaist tavus novērtējumus pie katras prompta vai modeļa izmaiņas: regresija tiek atklāta pie fiksācijas (commit), nevis ražošanā.

5. Ko ietver pilnīga ražošanas arhitektūra?

Atbilde: Uzraudzību (latentums, izmaksas, kvalitāte), brīdinājumus, asinhronas rindas, mērogojamu moderāciju un mērogošanas plānu — AI ražošanā ir sistēma, nevis API izsaukums.

Mēri, kešo, veido partijas, nepārtraukti vērtē: četri ieradumi, kas padara lietotnes ātras, vieglas un uzticamas.