Architektura produkcyjna: monitorowanie, alerty, skalowanie
Na tej stronie
Twoja aplikacja w środowisku produkcyjnym: trzy filary
Wdrożenie aplikacji LLM do produkcji to nie tylko kwestia kodu. Trzy filary gwarantują niezawodność: monitorowanie, aby obserwować; alerty, aby reagować; i skalowanie, aby pochłaniać obciążenie. Tworzą one łańcuch, a łańcuch jest tak silny, jak jego najsłabsze ogniwo: metryki, na które nikt nie patrzy, są bezużyteczne; alerty bez procedury reakcji to szum; a skalowanie, które uruchamia się za późno, to po prostu przerwa w działaniu. Ta ostatnia lekcja łączy wszystkie koncepcje z kursu w kompletną architekturę produkcyjną.
Obserwuj: co mierzyć
Cztery rodziny metryk pokrywają essentials: wolumen wywołań, opóźnienia, błędy i koszty, z podziałem na model. To właśnie podział na modele sprawia, że dashboard jest użyteczny – globalny wskaźnik błędów na poziomie 3% nic Ci nie mówi, podczas gdy ta sama wartość skupiona na jednym modelu natychmiast wskazuje winowajcę.
Poniższa klasa gromadzi te metryki w pamięci, używając ruchomego okna 10 000 opóźnień, aby zapobiec nieograniczonemu wzrostowi procesu. Zwróć uwagę na użycie percentyli zamiast średnich: średnie opóźnienie usługi LLM jest prawie zawsze mylące, ponieważ garstka bardzo wolnych wywołań ginie w średniej, a to właśnie one są powodem narzekań użytkowników.
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
Oczywiście zbieranie danych musi być systematyczne. Ręczne instrumentowanie każdego wywołania gwarantuje, że o którymś zapomnisz – i prawdopodobnie będzie to to, które sprawi kłopoty. Poniższy dekorator przenosi pomiary na poziom funkcji wywołującej: blok finally rejestruje opóźnienie i sukces niezależnie od tego, co się stanie, nawet gdy wyjątek jest propagowany dalej.
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
Liczniki tokenów i koszty pozostają w tej wersji zerowe, ponieważ obiekt odpowiedzi nie jest dostępny w momencie rejestracji. Uzupełnij je, odczytując pola usage zwracane przez API: bez tych informacji Twój dashboard będzie wiernie wyświetlał kolumnę zerowych kosztów.
Reaguj: stopniowane alerty
Alert ma wartość tylko wtedy, gdy wymaga działania. Dlatego system rozróżnia dwa progi dla każdej metryki: próg ostrzeżenia, sygnalizujący dryf do zbadania w ciągu dnia, oraz próg krytyczny, uzasadniający obudzenie kogoś ze zespołu. Pomylienie ich prowadzi do najgorszego możliwego outcome – zespół nauczy się ignorować powiadomienia.
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"],
},
)
Alerty dotyczące kosztów godzinowych są najczęściej pomijane, co jest szkodą: nieskończona pętla ponawiania prób lub zadanie wsadowe uruchomione dwukrotnie generuje rachunek, a nie błąd. To jedyna siatka bezpieczeństwa, która wykrywa tego typu incydenty w trakcie ich trwania.
Pochłaniaj: trzy mechanizmy odporności
Gdy API zwraca błąd, ponawianie próby pogarsza sprawę: dokładasz obciążenie usłudze, która już ma kłopoty, i każesz swoim użytkownikom czekać na nic. Wyłącznik nadprądowy (circuit breaker) odwraca tę logikę. Po określonej liczbie kolejnych niepowodzeń otwiera obwód i natychmiast odrzuca kolejne wywołania, próbując ponownie dopiero po upływie czasu resetowania.
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
Wyłącznik nadprądowy chroni Twoją aplikację, ale jej nie naprawia. Tę rolę pełni mechanizm fallbacku modelu, który próbuje alternatyw po kolei, pomijając te, których obwody są już otwarte. Zapamiętaj jeden punkt projektowy: kolejność na liście to decyzja produktowa, a nie techniczna. Na pierwszym miejscu postaw model, który dostarcza oczekiwaną usługę, a po nim te, które oferują usługę zdegradowaną, ale akceptowalną – nieco mniej trafna odpowiedź jest lepsza niż komunikat o niedostępności.
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.")
Trzeci mechanizm dotyczy doboru rozmiaru zasobów. Sterowanie liczbą workerów w oparciu o rozmiar kolejki, a nie obciążenie CPU, to właściwy odruch dla usługi, która większość czasu spędza na oczekiwaniu na odpowiedzi sieciowe: CPU siedzi bezczynnie, podczas gdy kolejka rośnie. Zwróć uwagę na asymetrię w zastosowanej regule – podwajamy przy skalowaniu w górę i dzielimy przez dwa przy skalowaniu w dół, przy mocno rozdzielonych progach (100 vs 10). Ta luka zapobiega oscylacjom: bez niej system spędzałby czas na tworzeniu i niszczeniu workerów wokół punktu przełączenia.
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
Lista kontrolna wdrożenia produkcyjnego
Kurs kończy się listą kontrolną do przejrzenia przed udostępnieniem aplikacji publicznie. Każdy punkt odnosi się do lekcji, którą już przerobiłeś; jeśli któryś wydaje się niejasny, przeczytaj tę lekcję ponownie przed wdrożeniem.
- Monitorowanie opóźnień (p50, p95, p99) i wskaźników błędów
- Alerty skonfigurowane na progach krytycznych
- Wyłącznik nadprądowy chroniący przed awariami API
- Skonfigurowany fallback modelu
- Włączona moderacja danych wejściowych i wyjściowych
- Zaimplementowane limitowanie po stronie klienta (rate limiting)
- Ustrukturyzowane logi do debugowania
- Automatyczne ewaluacje w CI/CD
- Budżet kosztowy z alertami
- Wersjonowana dokumentacja promptów
Kluczowe wnioski
- Monitorowanie obejmuje opóźnienia, błędy, koszty i jakość odpowiedzi
- Śledź percentyle opóźnień, nigdy tylko średnią
- Alerty muszą być stopniowane: najpierw ostrzeżenie, potem krytyczne
- Wyłącznik nadprądowy chroni przed kaskadą awarii; fallback zapewnia dostępność
- Lista kontrolna produkcji zapobiega krytycznym przeoczeniom
Sprawdź swoją wiedzę
Opóźnienia, koszty, ewaluacje: odruchy produkcyjne w pięciu pytaniach.
1. Jakie są główne dźwignie zmniejszania opóźnień?
Odpowiedź: Streaming (opóźnienie odczuwalne), buforowanie promptów (stabilne prefiksy), Przewidywane Dane Wyjściowe, gdy odpowiedź jest w dużym stopniu przewidywalna (Chat Completions, w modelach wycofanych 14 stycznia 2027 r.) oraz optymalizacja samego promptu – mierzona end-to-end.
2. Kiedy należy używać Batch API?
Odpowiedź: Do masowego przetwarzania bez wymogów czasu rzeczywistego: asynchroniczne wsady o obniżonym koszcie – ranking, wzbogacanie danych czy generowanie dużych wolumenów nie mają miejsca na ścieżce synchronicznej.
3. Co robi kompaktowanie konwersacji?
Odpowiedź: Kompresuje długą historię (podsumowania, przycinanie), aby zmieścić się w kontekście i kontrolować koszty – niezbędne dla agentów i długich sesji.
4. Jaki jest cel frameworka Evals w CI/CD?
Odpowiedź: Automatyczne uruchamianie ewaluacji przy każdej zmianie promptu lub modelu: regresja jest wykrywana przy commicie, a nie w produkcji.
5. Co zawiera kompletna architektura produkcyjna?
Odpowiedź: Monitorowanie (opóźnienia, koszty, jakość), alerty, kolejki asynchroniczne, moderację na skalę i plan skalowania – AI w produkcji to system, a nie wywołanie API.
Mierz, buforuj, grupuj w wsady, ewaluuj ciągle: cztery nawyki, które sprawiają, że aplikacje są szybkie, lekkie i niezawodne.