Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Produktion: Skalering og overvågning

Lektion 18 af 18 Opdateret 3. november 2026 Udvikler
På denne side
  1. Produktion: Skalering og overvågning
  2. Produktionsarkitektur
  3. Håndtering af samtidige sessioner
  4. Struktureret logning
  5. Prometheus-metrikker
  6. Omkostningsstyring
  7. Fejlhåndtering i produktion
  8. Vigtige pointer
  9. Test din viden

Opdateret 2. november 2026 — Lydmodeller. Flere modeller i dette kursus er udfaset: tts-1, tts-1-hd og gpt-4o-mini-tts ophører med at fungere den 6. januar 2027 (erstatning: gpt-realtime-2.1-mini, som OpenAI’s TTS-guide angiver ikke understøttes af /v1/audio/speech: migration af talesyntese skal ske via Realtime API); gpt-realtime, gpt-4o-realtime og ældre lydmodeller den 20. januar 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe og /v1/audio/translations den 26. februar 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Til fuld-duplex tale har GPT-Live 1 været tilgængelig i API’en siden 10. september 2026.

Opdateret 3. november 2026. Omkostningsstyring passede tidligere ind i én sætning; det afspejler nu den faktureringsmodel, som OpenAI beskriver (fakturering pr. svar, samtale returneres hver omgang, audio tælles i tokens, automatisk caching, transskription faktureres separat) og trunkering via retention_ratio, hvis format blev verificeret mod openai SDK-typer version 3.42.1. Kilde: Cost optimization.

Produktion: Skalering og overvågning

At gå fra en prototype på en taleagent til en pålidelig, skalerbar produktionstjeneste kræver tæt fokus på infrastruktur, overvågning og fejlhåndtering. Denne sidste lektion dækker de operationelle essentials for at deploye en taleagent under reelle forhold.

Produktionsarkitektur

I produktion kører taleagenten bag en load balancer og en pulje af workers:

1

Load Balancer (nginx / HAProxy)

Fordeler indgående WebSocket-forbindelser på tværs af workers. Understøtter sticky sessions for at opretholde affinitet.

2

Workers (FastAPI + uvicorn)

Hver worker håndterer flere samtidige Realtime-sessioner takket være asyncio.

3

Database (PostgreSQL)

Gemmer samtalelogs, metrikker og agentkonfiguration.

4

Overvågning (Prometheus + Grafana)

Indsamler realtidsmetrikker: latency, antal sessioner, fejl, omkostninger.

Håndtering af samtidige sessioner

Hver WebSocket-forbindelse vedligeholder en Realtime API-session. Antallet af samtidige sessioner er begrænset af dine OpenAI-rate limits og dine workers’ kapacitet:

import asyncio
from dataclasses import dataclass

@dataclass
class SessionManager:
    """Håndterer samtidige Realtime API-sessioner."""
    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):
        """Opretter en ny session med kontrol af samtidighed."""
        async with self.semaphore:
            if session_id in self.active_sessions:
                raise ValueError(f"Session {session_id} allerede aktiv")

            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):
        """Lukker en session korrekt."""
        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)

Struktureret logning

Log hver interaktion til fejlfinding og compliance:

import logging
import json
from datetime import datetime

class ConversationLogger:
    """Struktureret logger til talesamtaler."""

    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):
        """Gemmer den komplette log i databasen."""
        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-metrikker

Eksponér metrikker til overvågning i realtid:

from prometheus_client import Counter, Histogram, Gauge, start_http_server

# Nøglemetrikker
sessions_active = Gauge(
    "voice_sessions_active",
    "Antal aktive talesessioner"
)

session_duration = Histogram(
    "voice_session_duration_seconds",
    "Varighed af talesessioner",
    buckets=[30, 60, 120, 300, 600, 1800]
)

response_latency = Histogram(
    "voice_response_latency_ms",
    "Svarlatency (slutning af tale → første audio)",
    buckets=[200, 400, 600, 800, 1000, 1500, 2000, 3000]
)

errors_total = Counter(
    "voice_errors_total",
    "Samlet antal fejl",
    ["error_type"]
)

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

# Start metrikserveren
start_http_server(9090)

Omkostningsstyring

Ifølge OpenAI’s guide Cost optimization faktureres en Realtime-samtale pr. svar, i input- og output-tokens for tekst, audio og billeder. Tre mekanismer driver størstedelen af regningen:

  • Hele samtalen sendes tilbage til modellen ved hvert svar: senere omganger koster mere end tidligere.
  • Audio tælles i tokens: 1 token pr. 100 ms bruger-audio, 1 token pr. 50 ms assistant-audio.
  • Prompt-caching gælder automatisk: Så længe begyndelsen af samtalen ikke ændres, faktureres den til den reducerede cachede token-sats. At modificere eller slette et ældre element „bryder” cachen fra det punkt og frem.

Input-transskription, hvis aktiveret, faktureres separat til sin egen models sats: gpt-transcribe opkræves efter varighed, aflæst fra conversation.item.input_audio_transcription.completed-begivenheden. Forbruget for hvert svar fremgår af response.done under response.usage (total_tokens, input_tokens, output_tokens, plus opdelingen for tekst, audio, billede og cache).

For at begrænse kontekststørrelsen – og dermed omkostningerne ved senere omganger – accepterer sessionen en trunkeringsregel: ud over grænsen droppes de ældste beskeder. Med retention_ratio sat under 1 fjerner serveren lidt mere end nødvendigt, hvilket spreder trunkeringerne og bevarer cachen:

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

Afvæjningen: En agent, der beholder mindre kontekst, glemmer hurtigere. Supplér dette med sessionsgrænser i din kode:

class CostController:
    """Styrer omkostninger for en Realtime-session."""

    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"Denne session afsluttes om {int(remaining)} sekunder."
        return ""

Fejlhåndtering i produktion

async def production_event_loop(ws, logger, cost_ctrl):
    """Robust begivenhedsløkke til produktion."""
    cost_ctrl.start()

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

            # Tjek omkostningsgrænser
            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": "Sessionen nærmer sig sin varighedsgrænse."}]
                    }
                }))
                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()

Vigtige pointer

  • Produktionsarkitektur adskiller load balancer, asyncio-workers, database og overvågning
  • En SessionManager med en semaphore styrer antallet af samtidige sessioner
  • JSON-struktureret logning muliggør fejlfinding og compliance (optagelse af samtaler)
  • Prometheus-metrikker (TTFA, varighed, tokens, fejl) er essentielle for den daglige drift
  • CostController begrænser sessionsvarighed og tokens for at forhindre budgetoverskridelser

Test din viden

Fem spørgsmål, der dækker hele talekæden, fra WebSocket til produktions-deployment.

1. Hvorfor bruger Realtime API WebSocket i stedet for HTTP-forespørgsler?

Svar: Fordi en vedvarende, tovejsforbindelse lader dig streame mikrofon-audio og modtage svar kontinuerligt uden at betale overheadet ved at etablere en forespørgsel for hver udveksling. Dette er forudsætningen for samtaler med lav latency.

2. Hvad skal du sende umiddelbart efter `session.created`, og hvorfor?

Svar: session.update, med det samme: her konfigurerer du stemme, instrukser, værktøjer og audioformat. Indtil denne besked er sendt, kører sessionen med standardværdier.

3. Hvorfor er en proxyserver essentiel i produktion?

Svar: Den forhindrer eksponering af API-nøglen i klienten, og den lader dig autentificere brugeren, begrænse forbrug og logge kald – tre ting, der er umulige, hvis browseren taler direkte med API’en.

4. Hvad er formålet med parameteren `prompt` i transskriptions-API'en?

Svar: At styre genkendelsen mod forventet ordforråd: egennavne, brands, fagjargon. Termer, du lister der, transskriberes langt mere præcist.

5. Hvad er den vigtigste løftestang for oplevet latency i en taleagent?

Svar: End-to-end streaming: at afspille audio, så snart de første fragmenter ankommer, i stedet for at vente på det fulde svar, og at håndtere afbrydelser, så brugeren kan bryde ind når som helst.