Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Håndtering af WebSocket-sessioner

Lektion 11 af 14 Opdateret 3. november 2026 Udvikler
På denne side
  1. Behersk sessionens livscyklus
  2. Sessionens livscyklus
  3. Automatisk genoprettelse af forbindelse
  4. Håndtering af sessionens levetid
  5. Sessionspulje
  6. Metrikker at overvåge
  7. Vigtige pointer

Opdateret 3. november 2026 baseret på xAI-siden Text to Speech, som nævner en “sessionstilladelse” på 600 sekunder og en forbindelse uden timeout. Genopfriskningsstrategien nedenfor er en forholdsregel. Kilde: Text to Speech.

Behersk sessionens livscyklus

I produktion er robust håndtering af WebSocket-sessioner det, der adskiller en prototype fra et pålideligt produkt. TTS-sessioner har specifikke begrænsninger (levetid, samtidighedsgrænser), som din app skal håndtere korrekt.

Sessionens livscyklus

En TTS WebSocket-session gennemgår denne cyklus:

  1. Åbning: Opret forbindelse til wss://api.x.ai/v1/tts med parametrene
  2. Aktiv: Udveksling af text.delta/audio.delta-beskeder
  3. Normal lukning: Klienten eller serveren lukker forbindelsen
  4. Uventet lukning: En fejl, vedligeholdelse eller udløbet af den 600-sekunders sessionstilladelse, som dokumentationen nævner

Registrer lukning

Serveren kan lukke forbindelsen når som helst (intern fejl, vedligeholdelse, udløb af sessionstilladelsen). Din app skal altid håndtere lukke-begivenheden:

async def managed_session(api_key, language="en", voice="eve"):
    uri = f"wss://api.x.ai/v1/tts?language={language}&voice={voice}"
    headers = {"Authorization": f"Bearer {api_key}"}

    try:
        async with websockets.connect(uri, additional_headers=headers) as ws:
            yield ws
    except websockets.ConnectionClosed as e:
        print(f"Connection closed: code={e.code}, reason={e.reason}")
    except websockets.ConnectionClosedError:
        print("Connection lost unexpectedly")

Automatisk genoprettelse af forbindelse

Til langvarige apps skal du implementere genoprettelse med eksponentiel backoff:

import asyncio
import random

class TTSSessionManager:
    def __init__(self, api_key, language="en", voice="eve"):
        self.api_key = api_key
        self.language = language
        self.voice = voice
        self.ws = None
        self.max_retries = 5

    async def connect(self):
        uri = f"wss://api.x.ai/v1/tts?language={self.language}&voice={self.voice}"
        headers = {"Authorization": f"Bearer {self.api_key}"}

        for attempt in range(self.max_retries):
            try:
                self.ws = await websockets.connect(uri, additional_headers=headers)
                print(f"Connected (attempt {attempt + 1})")
                return
            except Exception as e:
                wait = min(2 ** attempt + random.random(), 30)
                print(f"Connection failed: {e}. Retrying in {wait:.1f}s")
                await asyncio.sleep(wait)

        raise ConnectionError("Could not connect after 5 attempts")

    async def ensure_connected(self):
        if self.ws is None or self.ws.closed:
            await self.connect()

    async def synthesize(self, text):
        await self.ensure_connected()

        try:
            await self.ws.send(json.dumps({
                "type": "text.delta",
                "delta": text
            }))
            await self.ws.send(json.dumps({"type": "text.done"}))

            audio_chunks = []
            async for msg in self.ws:
                data = json.loads(msg)
                if data["type"] == "audio.delta":
                    audio_chunks.append(base64.b64decode(data["delta"]))
                elif data["type"] == "audio.done":
                    break
                elif data["type"] == "error":
                    raise Exception(data["message"])

            return b"".join(audio_chunks)

        except websockets.ConnectionClosed:
            # Genopret forbindelse og prøv igen
            await self.connect()
            return await self.synthesize(text)

Håndtering af sessionens levetid

xAI-siden Text to Speech nævner en “sessionstilladelse” på 600 sekunder uden at specificere, hvornår den starter, eller hvad der sker, når den udløber, og angiver separat, at forbindelsen ikke har nogen timeout. Den mest forsigtige tilgang er at tælle fra det øjeblik, du opretter forbindelsen, og forny sessionen før dette tidspunkt:

import time

class TTLAwareSession:
    TTL = 600  # sekunder
    REFRESH_MARGIN = 60  # genopret forbindelse 60 s før udløb

    def __init__(self):
        self.connected_at = None

    async def connect(self):
        # ... oprettelse af forbindelse ...
        self.connected_at = time.time()

    def should_refresh(self):
        if self.connected_at is None:
            return True
        elapsed = time.time() - self.connected_at
        return elapsed >= (self.TTL - self.REFRESH_MARGIN)

    async def synthesize(self, text):
        if self.should_refresh():
            await self.connect()  # Ny session
        # ... send teksten ...

Genoprettelse af forbindelsen 60 sekunder før udløb sikrer, at du ikke bliver afbrudt midt i syntesen.

Sessionspulje

Til apps med høj trafik skal du holde en pulje af genanvendelige sessioner:

class SessionPool:
    def __init__(self, api_key, pool_size=10):
        self.api_key = api_key
        self.pool_size = min(pool_size, 50)  # Maks. 50 pr. team
        self.available = asyncio.Queue()
        self.active_count = 0

    async def acquire(self):
        if not self.available.empty():
            session = await self.available.get()
            if not session.should_refresh():
                return session

        if self.active_count < self.pool_size:
            session = TTSSessionManager(self.api_key)
            await session.connect()
            self.active_count += 1
            return session

        # Vent på, at en session bliver ledig
        return await self.available.get()

    async def release(self, session):
        await self.available.put(session)

Hold puljestørrelsen til en brøkdel af grænsen på 50 sessioner for at留出 plads til din apps andre tjenester.

Metrikker at overvåge

For at holde sessioner sunde i produktionen skal du overvåge:

  • Antal aktive sessioner: Må ikke overstige 50
  • Genoprettelsesrate: En høj rate indikerer et netværks- eller levetidsproblem
  • Latenstid for første audio.delta: Måler, hvor responsiv tjenesten er
  • WebSocket-fejl: Unormale lukkekoder (1006, 1011)
class MetricsCollector:
    def __init__(self):
        self.connections = 0
        self.reconnections = 0
        self.errors = 0
        self.first_audio_latencies = []

    def record_connection(self):
        self.connections += 1

    def record_reconnection(self):
        self.reconnections += 1

    def record_first_audio(self, latency_ms):
        self.first_audio_latencies.append(latency_ms)

Vigtige pointer

  • Dokumentationen nævner en sessionstilladelse på 600 sekunder: For en sikkerheds skyld skal du tælle fra det øjeblik, du opretter forbindelsen
  • Implementer automatisk genoprettelse af forbindelse med eksponentiel backoff
  • Forny sessionen før dette tidspunkt (med en margin på 60 sekunder)
  • Brug en sessionspulje til apps med høj trafik
  • Overhold grænsen på 50 samtidige sessioner pr. team
  • Overvåg forbindelsesmetrikker i produktionen