Премини към основното съдържание
Български— Изберете език
Меню

Архитектура за продукция: мониторинг, предупреждения, мащабиране

Урок 20 от 20 Обновен 3 ноември 2026 г. Напреднало
На тази страница
  1. Вашето приложение в продукция: трите стълба
  2. Наблюдавайте: какво да измервате
  3. Реагирайте: градуирани предупреждения
  4. Поемайте: три механизма за устойчивост
  5. Контролен списък за внедряване в продукция
  6. Ключови изводи
  7. Проверете знанията си

Вашето приложение в продукция: трите стълба

Разполагането на LLM приложение в продукция не се свежда само до кода. Три стълба гарантират надеждността: мониторинг за наблюдение, предупреждения за реакция и мащабиране за поемане на натоварването. Те образуват верига, а веригата е здрава толкова, колкото е най-слабото ѝ звено: метрики, които никой не разглежда, са безполезни; предупреждения без процедура за реакция са просто шум; а мащабиране, което се активира твърде късно, води до прекъсване на услугата. Този финален урок обединява всички концепции от курса в една цялостна производствена архитектура.

Наблюдавайте: какво да измервате

Четири семейства метрики покриват основното: обем на заявките, латентност, грешки и разходи, разбити по модел. Разбивката по модел е това, което прави таблото с инструменти полезно – глобален процент на грешки от 3% не Ви говори нищо, докато същата стойност, концентрирана върху един единствен модел, веднага посочва виновника.

Класът по-долу натрупва тези метрики в паметта, използвайки плъзгащ се прозорец от 10 000 стойности за латентност, за да предотврати неограниченото нарастване на процеса. Обърнете внимание на използването на перцентили вместо средни стойности: средната латентност на LLM услуга почти винаги е подвеждаща, защото шепа много бавни заявки се „разтварят“ в средното, а точно те са тези, за които потребителите Ви се оплакват.

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

Разбира се, събирането трябва да бъде систематично. Ръчното инструментирање на всяка заявка гарантира, че ще пропуснете една – и вероятно точно тази, която ще създаде проблеми. Декораторът по-долу премества измерването на ниво функция за извикване: блокът finally записва латентността и успеха независимо от всичко, дори когато се propagate изключение.

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

Броячите на токени и разходите остават нулеви в тази версия, защото обектът с отговора не е наличен в момента на записването. Попълнете ги, като прочетете полетата usage, върнати от API: без тази информация Вашето табло ще показва вярно колона с нулеви разходи.

Реагирайте: градуирани предупреждения

Едно предупреждение има стойност само ако призовава към действие. Затова системата разграничава два прага за всяка метрика: праг за предупреждение (warning), сигнализиращ отклонение, което трябва да се разгледа през деня, и критичен праг (critical), оправдаващ събуждането на някого. Бъркането на двете води до най-лошия възможен резултат – екип, който се е научил да игнорира известията.

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

Предупрежденията за почасови разходи са тези, които най-често се забравят, и това е жалко: неограничен цикъл на повторни опити или пакетна задача, стартирана два пъти, води до сметка, а не до грешка. Това е единствената предпазна мрежа, която открива този тип инциденти, докато се случват.

Поемайте: три механизма за устойчивост

Когато API връща грешка, повторният опит влошава нещата: добавяте натоварване към услуга, която вече е в затруднение, и карате собствените си потребители да чакат напразно. Прекъсвачът на веригата (circuit breaker) обръща тази логика. След определен брой последователни неуспехи той „отваря“ веригата и веднага отхвърля следващите обаждания, след което прави нов опит след забавяне за нулиране.

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

Прекъсвачът на веригата защитава Вашето приложение, но не го кара да работи. Това е ролята на резервния модел (model fallback), който изпробва алтернативи по ред, пропускайки онези, чиито вериги вече са отворени. Един важен проектантски детайл: редът в списъка е продуктово решение, а не техническо. Поставете първи модела, който доставя очакваната услуга, последван от тези, които доставят degraded, но приемлива услуга – малко по-малко остър отговор е по-добър от недостъпно съобщение.

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

Третият механизъм се отнася до оразмеряването. Управлението на броя работници въз основа на размера на опашката, а не на натоварването на CPU, е правилният рефлекс за услуга, която прекарва повечето време в очакване на мрежови отговори: CPU седи бездействащ, докато опашката расте. Обърнете внимание на асиметрията в приложеното правило – удвояваме при мащабиране нагоре и намаляваме наполовина при мащабиране надолу, с широко разделени прагове (100 спрямо 10). Тази разлика предотвратява осцилацията: без нея системата щеше да прекарва времето си в създаване и унищожаване на работници около точката на пречупване.

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

Контролен списък за внедряване в продукция

Този курс завършва с контролен списък, който трябва да преминете, преди да отворите приложението си за публиката. Всеки пункт се отнася до урок, който сте разгледали; ако някой изглежда неясен, препрочетете съответния урок преди внедряването.

  • Мониторинг на латентността (p50, p95, p99) и процентите на грешки
  • Предупреждения, конфигурирани на критични прагове
  • Прекъсвач на веригата за защита срещу сривове на API
  • Конфигуриран резервен модел (fallback)
  • Активирана модерация на входа и изхода
  • Внедрено ограничаване на честотата (rate limiting) на клиентска страна
  • Структурирани логове за дебъгване
  • Автоматизирани оценки (evals) в CI/CD
  • Бюджет за разходи с предупреждения
  • Документация на промптовете с версии

Ключови изводи

  • Мониторингът обхваща латентност, грешки, разходи и качество на отговора
  • Следете перцентилите на латентност, никога само средната стойност
  • Предупрежденията трябва да са градирани: първо предупреждение, после критично
  • Прекъсвачът на веригата защитава срещу каскадни сривове; резервният модел осигурява наличност
  • Контролен списък за продукция предотвратява критични пропуски

Проверете знанията си

Латентност, разходи, оценки: производствени рефлекси в пет въпроса.

1. Кои са основните лостове за намаляване на латентността?

Отговор: Стрийминг (възприемана латентност), кеширане на промптове (стабилни префикси), Predicted Outputs, когато отговорът е до голяма степен предвидим (Chat Completions, при модели, оттеглени на 14 януари 2027 г.), и оптимизиране на самия промпт – измерено от край до край.

2. Кога трябва да използвате Batch API?

Отговор: За масова обработка без ограничения в реално време: асинхронни пакети на намалена цена – класирането, обогатяването или генерирането на големи обеми нямат място в синхронния път.

3. Какво прави компресирането на разговора?

Отговор: То компресира дълга история (обобщения, изрязване), за да се побере в контекста и да контролира разходите – от съществено значение за агентите и дългите сесии.

4. Каква е целта на рамката за оценки (Evals) в CI/CD?

Отговор: Автоматично изпълнение на Вашите оценки при всяка промяна на промпт или модел: регресията се открива при commit, а не в продукция.

5. Какво включва една цялостна производствена архитектура?

Отговор: Мониторинг (латентност, разходи, качество), предупреждения, асинхронни опашки, модерация в мащаб и план за мащабиране – AI в продукция е система, а не API извикване.

Измервайте, кеширайте, групирайте в пакети, оценявайте непрекъснато: четири навика, които правят приложенията бързи, леки и надеждни.