Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Produkcija: Skaliranje in spremljanje

Lekcija 18 od 18 Posodobljeno 3. november 2026 Razvijalec
Na tej strani
  1. Produkcija: Skaliranje in spremljanje
  2. Produkcijska arhitektura
  3. Upravljanje sočasnih sej
  4. Strukturirano beleženje
  5. Metrike Prometheus
  6. Upravljanje stroškov
  7. Obravnava napak v produkciji
  8. Ključne ugotovitve
  9. Preveri svoje znanje

Posodobljeno 2. novembra 2026 — Zvočni modeli. Nekateri modeli v tem tečaju so zastareli: tts-1, tts-1-hd in gpt-4o-mini-tts bodo prenehali delovati 6. januarja 2027 (zamenjava: gpt-realtime-2.1-mini, ki ga vodnik OpenAI za TTS navaja kot nepodprtega z /v1/audio/speech: selitev sinteze govora mora potekati prek Realtime API); gpt-realtime, gpt-4o-realtime in starejši zvočni modeli 20. januarja 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe in /v1/audio/translations 26. februarja 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Za polno duplexni glas je GPT-Live 1 na voljo v API-ju od 10. septembra 2026.

Posodobljeno 3. novembra 2026. Upravljanje stroškov je bilo prej zajeto v enem stavku; zdaj odraža obračunski model, ki ga opisuje OpenAI (obračun na odgovor, pogovor vrnjen ob vsakem koraku, zvok štet v žetone, samodejno predpomnjenje, prepis obračunan ločeno) in obrezovanje prek retention_ratio, katerega format je bil preverjen glede na tipe SDK openai različice 3.42.1. Vir: Optimizacija stroškov.

Produkcija: Skaliranje in spremljanje

Prehod od prototipa glasovnega agenta do zanesljive, skalabilne produkcijske storitve zahteva veliko pozornosti do infrastrukture, spremljanja in obravnave napak. Ta zadnja lekcija pokriva operativne osnove za uvedbo glasovnega agenta v realnih pogojih.

Produkcijska arhitektura

V produkciji glasovni agent teče za uravnotežilnikom obremenitve in bazenom delavcev:

1

Uravnotežilnik obremenitve (nginx / HAProxy)

Porazdeljuje dohodne WebSocket povezave med delavce. Podpira lepljive seje za ohranjanje afinitete.

2

Delavci (FastAPI + uvicorn)

Vsak delavec hkrati obravnava več sej Realtime zahvaljujoč asyncio.

3

Baza podatkov (PostgreSQL)

Shranjuje dnevnike pogovorov, metrike in konfiguracijo agenta.

4

Spremljanje (Prometheus + Grafana)

Zbira metrike v realnem času: zakasnitev, število sej, napake, stroški.

Upravljanje sočasnih sej

Vsaka povezava WebSocket vzdržuje sejo Realtime API. Število sočasnih sej je omejeno z vašimi omejitvami hitrosti OpenAI in zmogljivostjo vaših delavcev:

import asyncio
from dataclasses import dataclass

@dataclass
class SessionManager:
    """Upravlja sočasne seje 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):
        """Ustvari novo sejo z nadzorom sočasnosti."""
        async with self.semaphore:
            if session_id in self.active_sessions:
                raise ValueError(f"Seja {session_id} je že aktivna")

            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):
        """Pravilno zapre sejo."""
        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)

Strukturirano beleženje

Zabeleži vsako interakcijo za razhroščevanje in skladnost:

import logging
import json
from datetime import datetime

class ConversationLogger:
    """Strukturirani beležnik za glasovne pogovore."""

    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):
        """Trajno shrani celoten dnevnik v bazo podatkov."""
        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)
            )

Metrike Prometheus

Izpostavi metrike za spremljanje v realnem času:

from prometheus_client import Counter, Histogram, Gauge, start_http_server

# Ključne metrike
sessions_active = Gauge(
    "voice_sessions_active",
    "Število aktivnih glasovnih sej"
)

session_duration = Histogram(
    "voice_session_duration_seconds",
    "Trajanje glasovnih sej",
    buckets=[30, 60, 120, 300, 600, 1800]
)

response_latency = Histogram(
    "voice_response_latency_ms",
    "Zakasnitev odziva (konec govora → prvi zvok)",
    buckets=[200, 400, 600, 800, 1000, 1500, 2000, 3000]
)

errors_total = Counter(
    "voice_errors_total",
    "Skupno število napak",
    ["error_type"]
)

tokens_used = Counter(
    "voice_tokens_total",
    "Porabljeni žetoni",
    ["type"]  # input_audio, output_audio, input_text, output_text
)

# Zaženi strežnik metrik
start_http_server(9090)

Upravljanje stroškov

Glede na vodnik OpenAI Optimizacija stroškov se seja pogovora Realtime obračunava na odgovor, v vhodnih in izhodnih žetonih za besedilo, zvok in slike. Trije mehanizmi poganjajo večino računa:

  • Celoten pogovor je poslan nazaj modelu z vsakim odgovorom: kasnejši koraki stanejo več kot zgodnejši.
  • Zvok je štet v žetone: 1 žeton na 100 ms uporabnikovega zvoka, 1 žeton na 50 ms zvoka asistenta.
  • Predpomnjenje pozivov se uporablja samodejno: dokler se začetek pogovora ne spremeni, se obračuna po znižani stopnji za predpomnjene žetone. Sprememba ali brisanje starejšega elementa „zlomi” predpomnilnik od te točke naprej.

Vhodni prepis, če je omogočen, se obračunava ločeno po lastni tarifi modela: gpt-transcribe se zaračuna po trajanju, prebranem iz dogodka conversation.item.input_audio_transcription.completed. Poraba za vsak odgovor se pojavi v response.done, pod response.usage (total_tokens, input_tokens, output_tokens, plus razčlenitev za besedilo, zvok, sliko in predpomnilnik).

Za omejitev velikosti konteksta – in s tem stroškov kasnejših korakov – seja sprejme pravilo obrezovanja: prek meje se najstarejša sporočila zavržejo. Z nastavitvijo retention_ratio pod 1 strežnik odstrani nekoliko več, kot je potrebno, kar razmakne obrezovanja in ohrani predpomnilnik:

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: agent, ki obdrži manj konteksta, hitreje pozabi. To dopolni z omejitvami sej v svoji kodi:

class CostController:
    """Nadzira stroške za sejo 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"Ta seja se bo končala čez {int(remaining)} sekund."
        return ""

Obravnava napak v produkciji

async def production_event_loop(ws, logger, cost_ctrl):
    """Robustna zanka dogodkov za produkcijo."""
    cost_ctrl.start()

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

            # Preveri omejitve stroškov
            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": "Seja se približuje svoji časovni omejitvi."}]
                    }
                }))
                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()

Ključne ugotovitve

  • Produkcijska arhitektura ločuje uravnotežilnik obremenitve, delavce asyncio, bazo podatkov in spremljanje
  • SessionManager s semaforjem nadzira število sočasnih sej
  • Strukturirano beleženje JSON omogoča razhroščevanje in skladnost (snemanje pogovorov)
  • Metrike Prometheus (TTFA, trajanje, žetoni, napake) so bistvene za vsakodnevno delovanje
  • CostController omejuje trajanje sej in žetone, da prepreči presežke proračuna

Preveri svoje znanje

Pet vprašanj, ki pokrivajo celoten glasovni niz, od WebSocket do uvedbe v produkcijo.

1. Zakaj Realtime API uporablja WebSocket namesto zahtev HTTP?

Odgovor: Ker trajna, dvosmerna povezava omogoča pretakanje zvoka mikrofona in neprekinjeno prejemanje odgovorov, ne da bi plačevali stroške vzpostavljanja zahteve za vsako izmenjavo. To je predpogoj za pogovor z nizko zakasnitvijo.

2. Kaj moraš poslati takoj po `session.created` in zakaj?

Odgovor: session.update, takoj: tu konfiguriraš glas, navodila, orodja in zvočni format. Dokler to sporočilo ni poslano, seja teče z privzetimi vrednostmi.

3. Zakaj je posredniški strežnik v produkciji nujen?

Odgovor: Preprečuje razkrivanje ključa API v odjemalcu in ti omogoča avtentikacijo uporabnika, omejitev porabe in beleženje klicev – tri stvari, ki so nemogoče, če brskalnik govori neposredno z API-jem.

4. Kakšen je namen parametra `prompt` v API-ju za prepis?

Odgovor: Usmerjanje prepoznavanja proti pričakovanemu besedišču: lastna imena, blagovne znamke, strokovni žargon. Izrazi, ki jih tam navedeš, so prepisani veliko natančneje.

5. Kaj je glavni vzvod za zaznano zakasnitev pri glasovnem agentu?

Odgovor: Pretakanje od konca do konca: predvajanje zvoka, takoj ko prispejo prvi fragmenti, namesto čakanja na celoten odgovor, in obravnava prekinitev, tako da lahko uporabnik kadarkoli poseže vmes.