Przejdź do głównej treści
Polski— Wybierz język
Menu

Produkcja: Skalowanie i monitorowanie

Lekcja 18 z 18 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Produkcja: Skalowanie i monitorowanie
  2. Architektura produkcyjna
  3. Zarządzanie sesjami współbieżnymi
  4. Ustrukturyzowane logowanie
  5. Metryki Prometheus
  6. Zarządzanie kosztami
  7. Obsługa błędów w produkcji
  8. Kluczowe wnioski
  9. Sprawdź swoją wiedzę

Zaktualizowano 2 listopada 2026 — Modele audio. Kilka modeli w tym kursie zostało wycofanych: tts-1, tts-1-hd oraz gpt-4o-mini-tts przestaną działać 6 stycznia 2027 (zamiennik: gpt-realtime-2.1-mini, który zgodnie z przewodnikiem OpenAI TTS nie jest obsługiwany przez /v1/audio/speech: migracja syntezy mowy musi odbywać się przez Realtime API); gpt-realtime, gpt-4o-realtime oraz starsze modele audio 20 stycznia 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe oraz /v1/audio/translations 26 lutego 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). W przypadku głosu pełnodupleksowego GPT-Live 1 jest dostępny w API od 10 września 2026.

Zaktualizowano 3 listopada 2026. Zarządzanie kosztami, które wcześniej mieściło się w jednym zdaniu, teraz odzwierciedla model rozliczeń opisany przez OpenAI (płatność za odpowiedź, konwersacja zwracana przy każdej turze, audio liczone w tokenach, automatyczne buforowanie, transkrypcja rozliczana osobno) oraz skracanie kontekstu za pomocą retention_ratio, którego format zweryfikowano względem typów SDK openai w wersji 3.42.1. Źródło: Optymalizacja kosztów.

Produkcja: Skalowanie i monitorowanie

Przejście od prototypu agenta głosowego do niezawodnej, skalowalnej usługi produkcyjnej wymaga ścisłej uwagi na infrastrukturę, monitorowanie i obsługę błędów. Ta ostatnia lekcja omawia kluczowe aspekty operacyjne wdrażania agenta głosowego w warunkach rzeczywistych.

Architektura produkcyjna

W środowisku produkcyjnym agent głosowy działa za balanserem obciążenia i pulą workerów:

1

Balanser obciążenia (nginx / HAProxy)

Rozdziela przychodzące połączenia WebSocket między workery. Obsługuje sesje lepkie (sticky sessions) w celu utrzymania afiniczności.

2

Workery (FastAPI + uvicorn)

Każdy worker obsługuje wiele jednoczesnych sesji Realtime dzięki asyncio.

3

Baza danych (PostgreSQL)

Przechowuje dzienniki konwersacji, metryki i konfigurację agenta.

4

Monitorowanie (Prometheus + Grafana)

Zbiera metryki w czasie rzeczywistym: opóźnienia, liczbę sesji, błędy, koszty.

Zarządzanie sesjami współbieżnymi

Każde połączenie WebSocket utrzymuje sesję Realtime API. Liczba jednoczesnych sesji jest ograniczona limitami przepustowości OpenAI oraz wydajnością twoich workerów:

import asyncio
from dataclasses import dataclass

@dataclass
class SessionManager:
    """Zarządza współbieżnymi sesjami Realtime API."""
    max_sessions: int = 50
    active_sessions: dict = None
    semaphore: asyncio.Semaphore = None

    def __post_init__(self):
        self.active_sessions = {}
        self.semaphore = asyncio.Semaphore(self.max_sessions)

    async def create_session(self, session_id: str, config: dict):
        """Tworzy nową sesję z kontrolą współbieżności."""
        async with self.semaphore:
            if session_id in self.active_sessions:
                raise ValueError(f"Session {session_id} already active")

            self.active_sessions[session_id] = {
                "created_at": asyncio.get_event_loop().time(),
                "config": config,
                "status": "active"
            }
            return session_id

    async def close_session(self, session_id: str):
        """Prawidłowo zamyka sesję."""
        if session_id in self.active_sessions:
            del self.active_sessions[session_id]

    @property
    def active_count(self) -> int:
        return len(self.active_sessions)

    @property
    def available_slots(self) -> int:
        return self.max_sessions - self.active_count

session_manager = SessionManager(max_sessions=50)

Ustrukturyzowane logowanie

Loguj każdą interakcję w celach debugowania i zgodności z przepisami:

import logging
import json
from datetime import datetime

class ConversationLogger:
    """Ustrukturyzowany logger dla rozmów głosowych."""

    def __init__(self, session_id: str):
        self.session_id = session_id
        self.logger = logging.getLogger(f"voice.{session_id}")
        self.events = []

    def log_event(self, event_type: str, data: dict = None):
        entry = {
            "timestamp": datetime.utcnow().isoformat(),
            "session_id": self.session_id,
            "event_type": event_type,
            "data": data or {}
        }
        self.events.append(entry)
        self.logger.info(json.dumps(entry))

    def log_transcription(self, role: str, text: str):
        self.log_event("transcription", {
            "role": role,
            "text": text
        })

    def log_function_call(self, name: str, args: dict, result: dict, duration_ms: float):
        self.log_event("function_call", {
            "name": name,
            "arguments": args,
            "result": result,
            "duration_ms": round(duration_ms)
        })

    def log_error(self, error_type: str, message: str):
        self.log_event("error", {
            "type": error_type,
            "message": message
        })

    async def save_to_db(self, db_pool):
        """Trwale zapisuje pełny dziennik w bazie danych."""
        async with db_pool.acquire() as conn:
            await conn.execute(
                "INSERT INTO conversation_logs (session_id, events, created_at) "
                "VALUES ($1, $2, NOW())",
                self.session_id, json.dumps(self.events)
            )

Metryki Prometheus

Udostępnij metryki do monitorowania w czasie rzeczywistym:

from prometheus_client import Counter, Histogram, Gauge, start_http_server

# Kluczowe metryki
sessions_active = Gauge(
    "voice_sessions_active",
    "Number of active voice sessions"
)

session_duration = Histogram(
    "voice_session_duration_seconds",
    "Duration of voice sessions",
    buckets=[30, 60, 120, 300, 600, 1800]
)

response_latency = Histogram(
    "voice_response_latency_ms",
    "Response latency (end of speech → first audio)",
    buckets=[200, 400, 600, 800, 1000, 1500, 2000, 3000]
)

errors_total = Counter(
    "voice_errors_total",
    "Total number of errors",
    ["error_type"]
)

tokens_used = Counter(
    "voice_tokens_total",
    "Tokens consumed",
    ["type"]  # input_audio, output_audio, input_text, output_text
)

# Uruchomienie serwera metryk
start_http_server(9090)

Zarządzanie kosztami

Zgodnie z przewodnikiem Cost optimization od OpenAI, sesja konwersacji Realtime jest rozliczana za każdą odpowiedź, w tokenach wejściowych i wyjściowych dla tekstu, audio i obrazów. Trzy mechanizmy generują większość kosztów:

  • Cała konwersacja jest odsyłana do modelu z każdą odpowiedzią: późniejsze tury kosztują więcej niż wcześniejsze.
  • Audio jest liczone w tokenach: 1 token na 100 ms audio użytkownika, 1 token na 50 ms audio asystenta.
  • Buforowanie promptów działa automatycznie: dopóki początek konwersacji się nie zmienia, jest rozliczany według obniżonej stawki za tokeny buforowane. Modyfikacja lub usunięcie starszego elementu „łamie“ bufor od tego momentu.

Transkrypcja wejściowa, jeśli jest włączona, jest rozliczana osobno według stawki własnego modelu: gpt-transcribe jest płatny za czas trwania, odczytywany z eventu conversation.item.input_audio_transcription.completed. Zużycie dla każdej odpowiedzi pojawia się w response.done, pod response.usage (total_tokens, input_tokens, output_tokens, plus szczegółowy podział na tekst, audio, obraz i cache).

Aby ograniczyć rozmiar kontekstu – a tym samym koszt późniejszych tur – sesja akceptuje regułę skracania: po przekroczeniu limitu najstarsze wiadomości są usuwane. Gdy retention_ratio jest ustawione poniżej 1, serwer usuwa nieco więcej niż konieczne, co rozrzedza momenty skracania i zachowuje cache:

await ws.send(json.dumps({
    "type": "session.update",
    "session": {
        "type": "realtime",
        "truncation": {
            "type": "retention_ratio",
            "retention_ratio": 0.8,
            "token_limits": {"post_instructions": 8000},
        },
    },
}))

Kompromis jest taki: agent, który przechowuje mniej kontekstu, szybciej zapomina. Uzupełnij to limitami sesji w swoim kodzie:

class CostController:
    """Kontroluje koszty sesji Realtime."""

    def __init__(self, max_duration_s: int = 600, max_tokens: int = 50000):
        self.max_duration_s = max_duration_s
        self.max_tokens = max_tokens
        self.total_tokens = 0
        self.start_time = None

    def start(self):
        self.start_time = asyncio.get_event_loop().time()

    def update_tokens(self, usage: dict):
        self.total_tokens += usage.get("total_tokens", 0)

    @property
    def elapsed_seconds(self) -> float:
        if not self.start_time:
            return 0
        return asyncio.get_event_loop().time() - self.start_time

    @property
    def should_terminate(self) -> bool:
        if self.elapsed_seconds > self.max_duration_s:
            return True
        if self.total_tokens > self.max_tokens:
            return True
        return False

    @property
    def warning_message(self) -> str:
        remaining = self.max_duration_s - self.elapsed_seconds
        if remaining < 60:
            return f"This session will end in {int(remaining)} seconds."
        return ""

Obsługa błędów w produkcji

async def production_event_loop(ws, logger, cost_ctrl):
    """Solidna pętla zdarzeń dla środowiska produkcyjnego."""
    cost_ctrl.start()

    try:
        async for raw in ws:
            event = json.loads(raw)
            t = event["type"]

            # Sprawdzenie limitów kosztów
            if cost_ctrl.should_terminate:
                logger.log_event("session_limit_reached")
                await ws.send(json.dumps({
                    "type": "conversation.item.create",
                    "item": {
                        "type": "message",
                        "role": "user",
                        "content": [{"type": "input_text",
                                     "text": "The session is approaching its duration limit."}]
                    }
                }))
                break

            if t == "response.done":
                usage = event["response"].get("usage", {})
                cost_ctrl.update_tokens(usage)
                tokens_used.labels(type="total").inc(usage.get("total_tokens", 0))

            elif t == "error":
                error = event["error"]
                logger.log_error(error["type"], error["message"])
                errors_total.labels(error_type=error["type"]).inc()

                if error["type"] == "rate_limit_error":
                    await asyncio.sleep(1)

    except websockets.exceptions.ConnectionClosed as e:
        logger.log_error("connection_closed", str(e))
    except Exception as e:
        logger.log_error("unexpected", str(e))
    finally:
        session_duration.observe(cost_ctrl.elapsed_seconds)
        sessions_active.dec()

Kluczowe wnioski

  • Architektura produkcyjna rozdziela balanser obciążenia, workery asyncio, bazę danych i system monitorowania
  • SessionManager z semaforem kontroluje liczbę jednoczesnych sesji
  • Ustrukturyzowane logowanie JSON umożliwia debugowanie i zgodność z przepisami (nagrywanie rozmów)
  • Metryki Prometheus (TTFA, czas trwania, tokeny, błędy) są niezbędne do codziennych operacji
  • CostController ogranicza czas trwania sesji i liczbę tokenów, aby zapobiec przekroczeniu budżetu

Sprawdź swoją wiedzę

Pięć pytań obejmujących cały łańcuch głosowy, od WebSocketu po wdrożenie produkcyjne.

1. Dlaczego Realtime API używa WebSocketu zamiast żądań HTTP?

Odpowiedź: Ponieważ trwałe, dwukierunkowe połączenie pozwala strumieniować audio z mikrofonu i ciągle otrzymywać odpowiedzi, bez ponoszenia narzutu związanego z ustanawianiem żądania dla każdej wymiany. Jest to warunek wstępny rozmowy o niskim opóźnieniu.

2. Co musisz wysłać natychmiast po `session.created` i dlaczego?

Odpowiedź: session.update, natychmiast: to tutaj konfigurujesz głos, instrukcje, narzędzia i format audio. Dopóki ta wiadomość nie zostanie wysłana, sesja działa z wartościami domyślnymi.

3. Dlaczego serwer proxy jest niezbędny w produkcji?

Odpowiedź: Zapobiega ujawnieniu klucza API w kliencie i pozwala uwierzytelnić użytkownika, ograniczyć zużycie oraz logować wywołania – trzy rzeczy niemożliwe, gdy przeglądarka komunikuje się bezpośrednio z API.

4. Jaki jest cel parametru `prompt` w API transkrypcji?

Odpowiedź: Ukierunkowanie rozpoznawania na oczekiwane słownictwo: nazwy własne, marki, żargon branżowy. Terminy tam wymienione są transkrybowane znacznie dokładniej.

5. Jaki jest główny dźwignia wpływająca na postrzegane opóźnienie w agencie głosowym?

Odpowiedź: Strumieniowanie end-to-end: odtwarzanie audio natychmiast po nadejściu pierwszych fragmentów zamiast czekania na pełną odpowiedź oraz obsługa przerwań, aby użytkownik mógł wejść w słowo w dowolnym momencie.