Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Éles környezet: méretezés és monitorozás

18. lecke 18 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Éles környezet: méretezés és monitorozás
  2. Éles architektúra
  3. Egyidejű munkamenetek kezelése
  4. Strukturált naplózás
  5. Prometheus metrikák
  6. Költséggazdálkodás
  7. Éles hibakezelés
  8. Főbb megállapítások
  9. Teszteld a tudásod!

Frissítve: 2026. november 2. – Hangmodellek. A tanfolyam több modellje elavult: a tts-1, tts-1-hd és a gpt-4o-mini-tts 2027. január 6-án megszűnik működni (helyettesítőjük: gpt-realtime-2.1-mini, amelyet az OpenAI TTS útmutatója szerint nem támogat a /v1/audio/speech: a beszédszintézis migrációjának a Realtime API-n keresztül kell történnie); a gpt-realtime, gpt-4o-realtime és a régi hangmodellek 2027. január 20-án válnak elavulttá (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); a whisper-1, gpt-4o-transcribe és a /v1/audio/translations pedig 2027. február 26-án (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). A teljes duplex hangkommunikációhoz a GPT-Live 1 már 2026. szeptember 10. óta elérhető az API-ban.

Frissítve: 2026. november 3. A költséggazdálkodás korábban egyetlen mondatba fért; most már tükrözi az OpenAI által leírt számlázási modellt (válaszonkénti számlázás, minden körben visszaküldött beszélgetés, tokenekben számolt hang, automatikus gyorsítótárazás, külön számlázott átírás), valamint a retention_ratio segítségével végzett csonkítást, amelynek formátumát az openai SDK 3.42.1-es verziójának típusai alapján ellenőriztük. Forrás: Költségoptimalizálás.

Éles környezet: méretezés és monitorozás

Egy hangalapú ügynök prototípusából megbízható, méretezhető éles szolgáltatást létrehozni szoros figyelmet igényel az infrastruktúra, a monitorozás és a hibakezelés terén. Ez az utolsó lecke lefedi a hangügynök valós körülmények közötti telepítésének működési alapjait.

Éles architektúra

Éles környezetben a hangügynök egy terheléselosztó és egy munkafolyamat-pool (worker pool) mögött fut:

1

Terheléselosztó (nginx / HAProxy)

Szétosztja a bejövő WebSocket kapcsolatokat a munkafolyamatok között. Támogatja a ragadós munkameneteket (sticky sessions) az affinitás fenntartásához.

2

Munkafolyamatok (FastAPI + uvicorn)

Minden munkafolyamat az asyncio-nak köszönhetően több egyidejű Realtime munkamenetet is kezel.

3

Adatbázis (PostgreSQL)

Tárolja a beszélgetési naplókat, a metrikákat és az ügynök konfigurációját.

4

Monitorozás (Prometheus + Grafana)

Valós idejű metrikákat gyűjt: késleltetés, munkamenetek száma, hibák, költségek.

Egyidejű munkamenetek kezelése

Minden WebSocket kapcsolat egy Realtime API munkamenetet tart fenn. Az egyidejű munkamenetek számát az OpenAI sebességkorlátai és a munkafolyamataid kapacitása korlátozza:

import asyncio
from dataclasses import dataclass

@dataclass
class SessionManager:
    """Egyidejű Realtime API munkameneteket kezel."""
    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):
        """Új munkamenetet hoz létre konkurencia-vezérléssel."""
        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):
        """Szakszerűen lezár egy munkamenetet."""
        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)

Strukturált naplózás

Minden interakciót naplózz hibakeresés és megfelelés céljából:

import logging
import json
from datetime import datetime

class ConversationLogger:
    """Strukturált naplózó hangbeszélgetésekhez."""

    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):
        """Tartósítja a teljes naplót az adatbázisban."""
        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)
            )

Prometheus metrikák

Tedd elérhetővé a metrikákat valós idejű monitorozáshoz:

from prometheus_client import Counter, Histogram, Gauge, start_http_server

# Kulcsfontosságú metrikák
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
)

# A metrika szerver elindítása
start_http_server(9090)

Költséggazdálkodás

Az OpenAI Költségoptimalizálás útmutatója szerint egy Realtime beszélgetési munkamenet válaszonként kerül számlázásra, bemeneti és kimeneti tokenek alapján szöveg, hang és kép esetén. Három mechanizmus határozza meg a számla nagy részét:

  • A teljes beszélgetés visszaküldésre kerül a modellnek minden válasznál: a későbbi körök többe kerülnek, mint a korábbiak.
  • A hangot tokenekben számolják: 1 token minden 100 ms felhasználói hangért, 1 token minden 50 ms asszisztens hangért.
  • A prompt gyorsítótárazás automatikusan alkalmazásra kerül: amíg a beszélgetés eleje nem változik, addig csökkentett gyorsítótárazott token áron számlázzák. Egy régebbi elem módosítása vagy törlése ettől a ponttól kezdve „megszakítja“ a gyorsítótárat.

A bemeneti átírás, ha engedélyezve van, külön számlázásra kerül a saját modelljének díjszabása szerint: a gpt-transcribe költsége időtartam alapú, amelyet a conversation.item.input_audio_transcription.completed eseményből olvashatsz ki. Az egyes válaszok fogyasztása a response.done alatt jelenik meg, a response.usage mezőben (total_tokens, input_tokens, output_tokens, plusz a szöveg, hang, kép és gyorsítótár lebontása).

A kontextus méretének – és ezáltal a későbbi körök költségének – korlátozására a munkamenet elfogad egy csonkítási szabályt: a limit felett a legrégebbi üzenetek eldobásra kerülnek. Ha a retention_ratio értékét 1 alá állítod, a szerver a szükségesnél kicsit többet távolít el, ami ritkítja a csonkításokat és megőrzi a gyorsítótárat:

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

A kompromisszum: egy ügynök, amely kevesebb kontextust őriz meg, gyorsabban felejt. Ezt egészítsd ki munkamenet-korlátokkal a kódodban:

class CostController:
    """Költségeket vezérel egy Realtime munkamenetben."""

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

Éles hibakezelés

async def production_event_loop(ws, logger, cost_ctrl):
    """Robusztus eseményhurok éles környezethez."""
    cost_ctrl.start()

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

            # Költségkorlátok ellenőrzése
            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()

Főbb megállapítások

  • Az éles architektúra szétválasztja a terheléselosztót, az asyncio munkafolyamatokat, az adatbázist és a monitorozást.
  • Egy szemaforral rendelkező SessionManager vezérli az egyidejű munkamenetek számát.
  • A JSON strukturált naplózás lehetővé teszi a hibakeresést és a megfelelést (beszélgetésrögzítés).
  • A Prometheus metrikák (TTFA, időtartam, tokenek, hibák) elengedhetetlenek a napi működéshez.
  • A CostController korlátozza a munkamenet időtartamát és a tokeneket a költségvetés túllépésének megelőzése érdekében.

Teszteld a tudásod!

Öt kérdés, amely lefedi a teljes hangláncot a WebSockettől az éles telepítésig.

1. Miért használ WebSocketet a Realtime API HTTP kérések helyett?

Válasz: Mert egy tartós, kétirányú kapcsolat lehetővé teszi a mikrofonhang folyamatos streamelését és a válaszok folyamatos fogadását anélkül, hogy minden egyes cseréhez új kérés felépítésének többletköltségét kellene fizetned. Ez az alacsony késleltetésű beszélgetés előfeltétele.

2. Mit kell azonnal elküldeni a `session.created` után, és miért?

Válasz: A session.update üzenetet, azonnal: itt konfigurálod a hangot, az utasításokat, az eszközöket és a hangformátumot. Ezen üzenet elküldéséig a munkamenet alapértelmezett értékekkel fut.

3. Miért elengedhetetlen egy proxy szerver éles környezetben?

Válasz: Megakadályozza az API-kulcs kliens oldali kitételét, és lehetővé teszi a felhasználó hitelesítését, a fogyasztás korlátozását, valamint a hívások naplózását – három olyan dolgot, amely lehetetlen, ha a böngésző közvetlenül beszél az API-val.

4. Mi a célja a `prompt` paraméternek az átírási API-ban?

Válasz: Hogy a felismerést a várt szókincs felé terelje: tulajdonnevek, márkanevek, szakmai zsargon. Az ott felsorolt kifejezések sokkal pontosabban kerülnek átírásra.

5. Mi a fő befolyásoló tényező a hangügynök észlelt késleltetésében?

Válasz: A végpontok közötti streaming: a hang lejátszása azonnal, ahogy az első töredékek megérkeznek, ahelyett, hogy megvárnánk a teljes választ, valamint a megszakítások kezelése, így a felhasználó bármikor közbeszólhat.