Tuotantoarkkitehtuuri: valvonta, hälytykset, skaalaus
Tällä sivulla
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.