Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Tuotantoarkkitehtuuri: valvonta, hälytykset, skaalaus

Oppitunti 20 / 20 Päivitetty 3. marraskuuta 2026 Edistynyt
Tällä sivulla
  1. Sovelluksesi tuotannossa: kolme peruspilaria
  2. Havainnoi: mitä mitata
  3. Reagoi: porrastetut hälytykset
  4. Kestä: kolme joustavuusmekanismia
  5. Tuotantoonvietoinnin tarkistuslista
  6. Keskeiset asiat
  7. Testaa tietosi

Sovelluksesi tuotannossa: kolme peruspilaria

LLM-sovelluksen vieminen tuotantoon ei ole pelkkää koodia. Kolme pilaria takaa luotettavuuden: valvonta havainnointia varten, hälytykset reagointia varten ja skaalaus kuorman kestämiseksi. Ne muodostavat ketjun, ja ketju on vain niin vahva kuin sen heikoin lenkki: mittareita, joita kukaan ei tarkkaile, ovat hyödyttömiä; hälytykset ilman vastatoimenpidemenettelyä ovat melua; ja liian myöhään käynnistyvä skaalaus on vain käyttökatko. Tämä viimeinen oppitunti kokoaa kurssin kaikki käsitteet yhdeksi kokonaiseksi tuotantoarkkitehtuuriksi.

Havainnoi: mitä mitata

Neljä mittariryhmää kattaa oleellisen: kutsujen määrä, vasteaika, virheet ja kustannukset, eriteltynä malleittain. Erittely malleittain on se, mikä tekee kojelaudasta toimivan: globaali virheprosentti 3 % ei kerro mitään, kun taas sama luku keskittyneenä yhteen malliin osoittaa välittömästi syyllisen.

Alla oleva luokka kerää nämä mittarit muistiin käyttäen liukuvaa ikkunaa, jossa on 10 000 vasteaikaa, jotta prosessi ei kasvaisi loputtomiin. Huomaa prosenttipisteiden käyttö keskiarvojen sijaan: LLM-palvelun keskimääräinen vasteaika on lähes aina harhaanjohtava, koska kourallinen erittäin hitaita kutsuja katoaa keskiarvoon, vaikka juuri niistä käyttäjäsi valittavat.

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

Keräilyn on tietenkin oltava systemaattista. Jokaisen kutsun manuaalinen instrumentointi takaa, että unohdat yhden – ja todennäköisesti juuri sen, joka aiheuttaa ongelmia. Alla oleva dekorattori siirtää mittauksen kutsufunktion tasolle: finally-lohko kirjaa vasteajan ja onnistumisen riippumatta siitä, mitä tapahtuu, jopa silloin kun poikkeus etenee eteenpäin.

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

Token-laskurit ja kustannukset pysyvät tässä versiossa nollina, koska vastausobjekti ei ole tallennushetkellä saatavilla. Täydennä ne lukemalla rajapinnan palauttamat käyttötilastokentät: ilman tätä tietoa kojelautasi näyttää uskollisesti sarakkeen, jossa kustannukset ovat nolla.

Reagoi: porrastetut hälytykset

Hälytys on arvokas vain, jos se vaatii toimia. Siksi järjestelmä erottaa kaksi kynnysarvoa mittaria kohden: varoituskynnys, joka signaloi poikkeamaa, joka tulee tarkistaa päivän aikana, ja kriittinen kynnys, joka oikeuttaa henkilön herättämisen. Näiden sekoittaminen tuottaa pahimman mahdollisen lopputuloksen: tiimin, joka on oppinut ignoroi ilmoitukset.

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

Tuntikohtaiset kustannushälytykset ovat niitä, jotka useimmiten unohdetaan, ja se on sääli: rajaton uudelleenyrityssilmukka tai kahdesti käynnistetty eräajo tuottaa laskun, ei virhettä. Se on ainoa turvaverkko, joka havaitsee tämän tyyppiset tapahtumat niiden发生时.

Kestä: kolme joustavuusmekanismia

Kun rajapinta palauttaa virheen, uudelleenyritys pahentaa tilannetta: lisäät kuormaa palveluun, joka on jo hädissä, ja saat omat käyttäjäsi odottamaan turhaan. Piirikatkaisin kääntää tämän logiikan. Määritetyn määrän peräkkäisiä epäonnistumisia jälkeen se avaa piirin ja hylkää välittömästi seuraavat kutsut yrittäen uudelleen nollausviiveen jälkeen.

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

Piirikatkaisin suojaa sovellustasi; se ei kuitenkaan saa sitä toimimaan. Se on mallin varamallin tehtävä, joka kokeilee vaihtoehtoja järjestyksessä ohittaen ne, joiden piirit ovat jo auki. Yksi muistettava suunnittelukohta: listan järjestys on tuotepäätös, ei tekninen. Laita ensimmäiseksi malli, joka tuottaa odotetun palvelun, ja sen perään ne, jotka tuottavat heikentyneen mutta hyväksyttävän palvelun – hieman vähemmän terävä vastaus on parempi kuin saavuttamaton viesti.

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

Kolmas mekanismi koskee mitoitusta. Työntekijöiden määrän ohjaaminen jonon koon eikä CPU-kuorman perusteella on oikea refleksi palvelulle, joka viettää suurimman osan ajastaan odottaen verkkovasteita: CPU lepää jouten, kun jono kasvaa. Huomaa sovelletun säännön epäsymmetria: kaksinkertaistamme skaalattaessa ylös ja puolitamme skaalattaessa alas, käyttäen toisistaan kaukana olevia kynnysarvoja (100 vs. 10). Tämä kuilu estää heilahtelun: ilman sitä järjestelmä käyttäisi aikansa luoden ja tuhoten työntekijöitä käännekohdan ympärillä.

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

Tuotantoonvietoinnin tarkistuslista

Tämä kurssi päättyy tarkistuslistaan, joka tulee käydä läpi ennen sovelluksen avaamista yleisölle. Jokainen kohta viittaa käymääsi oppituntiin; jos jokin vaikuttaa epäselvältä, lue kyseinen oppitunti uudelleen ennen käyttöönottoa.

  • Vasteajan valvonta (p50, p95, p99) ja virheprosentit
  • Hälytykset konfiguroitu kriittisille kynnysarvoille
  • Piirikatkaisin suojaamassa rajapinnan vioilta
  • Mallin varajärjestelmä konfiguroitu
  • Syötteen ja tulosteen moderointi käytössä
  • Asiakaspuolen nopeusrajoitus toteutettu
  • Jäsennellyt lokit vianetsintää varten
  • Automatisoidut arvioinnit CI/CD:ssä
  • Kustannusbudjetti hälytyksineen
  • Versioitu kehote-dokumentaatio

Keskeiset asiat

  • Valvonta kattaa vasteajat, virheet, kustannukset ja vastauksen laadun
  • Seuraa vasteajan prosenttipisteitä, älä koskaan pelkkää keskiarvoa
  • Hälytysten on oltava porrastettuja: ensin varoitus, sitten kriittinen
  • Piirikatkaisin suojaa vikaketjuilta; varajärjestelmä varmistaa saatavuuden
  • Tuotantotarkistuslista estää kriittiset laiminlyönnit

Testaa tietosi

Vasteajat, kustannukset, arvioinnit: tuotantorefleksit viidessä kysymyksessä.

1. Mitkä ovat tärkeimmät vivut vasteajan lyhentämiseksi?

Vastaus: Streamaus (koettu vasteaika), kehotevälimuisti (vakaat etuliitteet), Ennustetut tulosteet, kun vastaus on suurelta osin ennustettavissa (Chat Completions, malleissa, jotka poistuvat käytöstä 14. tammikuuta 2027), ja itse kehotteen optimointi – mitattuna päästä päähän.

2. Milloin Batch API:a tulisi käyttää?

Vastaus: Massiiviseen käsittelyyn ilman reaaliaikavaatimuksia: asynkroniset erät alennetulla hinnalla – luokittelu, rikastaminen tai volyymigenerointi eivät kuulu synkroniselle polulle.

3. Mitä keskustelun tiivistäminen tekee?

Vastaus: Se pakkaa pitkän historian (tiivistelmät, karsinta) mahtumaan kontekstiin ja hallitsemaan kustannuksia – välttämätöntä agenteille ja pitkille istunnoille.

4. Mikä on Evals-kehyksen tarkoitus CI/CD:ssä?

Vastaus: Suorittaa arviointisi automaattisesti jokaisen kehote- tai mallimuutoksen yhteydessä: regressio havaitaan commit-vaiheessa, ei tuotannossa.

5. Mitä täydellinen tuotantoarkkitehtuuri sisältää?

Vastaus: Valvonnan (vasteajat, kustannukset, laatu), hälytykset, asynkroniset jonot, moderoinnin skaalattuna ja skaalussuunnitelman – AI tuotannossa on järjestelmä, ei API-kutsu.

Mittaa, välimuistita, eräkäsittele, arvioi jatkuvasti: neljä tapaa, jotka tekevät sovelluksista nopeita, kevyitä ja luotettavia.