Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Verwaltung von WebSocket-Sitzungen

Lektion 11 von 14 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. Beherrschen Sie den Sitzungslebenszyklus
  2. Sitzungslebenszyklus
  3. Automatische Wiederverbindung
  4. Verwaltung der Sitzungsdauer
  5. Sitzungspool
  6. Zu beobachtende Metriken
  7. Kernaussagen

Aktualisiert am 3. November 2026, basierend auf der xAI-Seite Text to Speech, die eine 600-Sekunden-„Sitzungserlaubnis” und eine Verbindung ohne Timeout erwähnt. Die unten beschriebene Erneuerungsstrategie dient als Vorsichtsmaßnahme. Quelle: Text to Speech.

Beherrschen Sie den Sitzungslebenszyklus

In der Produktion ist eine robuste Verwaltung von WebSocket-Sitzungen der Unterschied zwischen einem Prototyp und einem zuverlässigen Produkt. TTS-Sitzungen unterliegen spezifischen Einschränkungen (Lebensdauer, Begrenzung der Parallelität), die Ihre Anwendung korrekt handhaben muss.

Sitzungslebenszyklus

Eine TTS-WebSocket-Sitzung durchläuft diesen Zyklus:

  1. Öffnen: Verbindung zu wss://api.x.ai/v1/tts mit den Parametern herstellen
  2. Aktiv: Austausch von text.delta/audio.delta-Nachrichten
  3. Normales Schließen: Der Client oder der Server schließt die Verbindung
  4. Unerwartetes Schließen: Ein Fehler, Wartungsarbeiten oder das Ende der 600-Sekunden-Sitzungserlaubnis, wie in der Dokumentation erwähnt

Erkennen von Verbindungsabbrüchen

Der Server kann die Verbindung jederzeit schließen (interner Fehler, Wartung, Ende der Sitzungserlaubnis). Ihre Anwendung sollte das Schließenereignis immer behandeln:

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"Verbindung geschlossen: code={e.code}, reason={e.reason}")
    except websockets.ConnectionClosedError:
        print("Verbindung unerwartet verloren")

Automatische Wiederverbindung

Für langlaufende Anwendungen implementieren Sie eine Wiederverbindung mit exponentiellem 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"Verbunden (Versuch {attempt + 1})")
                return
            except Exception as e:
                wait = min(2 ** attempt + random.random(), 30)
                print(f"Verbindung fehlgeschlagen: {e}. Wiederversuch in {wait:.1f}s")
                await asyncio.sleep(wait)

        raise ConnectionError("Konnte nach 5 Versuchen nicht verbinden")

    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:
            # Wiederverbinden und erneut versuchen
            await self.connect()
            return await self.synthesize(text)

Verwaltung der Sitzungsdauer

Die xAI-Seite Text to Speech erwähnt eine 600-Sekunden-Sitzungserlaubnis, ohne zu sagen, wann sie beginnt oder was passiert, wenn sie endet, und erwähnt separat, dass die Verbindung keinen Timeout hat. Der vorsichtigste Ansatz besteht darin, die Zeit ab dem Moment zu zählen, in dem Sie sich verbinden, und die Sitzung vor diesem Zeitpunkt zu erneuern:

import time

class TTLAwareSession:
    TTL = 600  # Sekunden
    REFRESH_MARGIN = 60  # erneuern 60 s vor Ablauf

    def __init__(self):
        self.connected_at = None

    async def connect(self):
        # ... Verbindung herstellen ...
        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()  # Neue Sitzung
        # ... Text senden ...

Das Wiederverbinden 60 Sekunden vor Ablauf verhindert, dass die Synthese mitten im Prozess unterbrochen wird.

Sitzungspool

Für Anwendungen mit hohem Datenverkehr halten Sie einen Pool wiederverwendbarer Sitzungen bereit:

class SessionPool:
    def __init__(self, api_key, pool_size=10):
        self.api_key = api_key
        self.pool_size = min(pool_size, 50)  # Maximal 50 pro 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

        # Auf eine freie Sitzung warten
        return await self.available.get()

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

Halten Sie die Poolgröße auf einen Bruchteil des 50-Sitzungen-Limits, um Spielraum für andere Dienste Ihrer Anwendung zu lassen.

Zu beobachtende Metriken

Um Sitzungen in der Produktion gesund zu halten, überwachen Sie:

  • Anzahl aktiver Sitzungen: darf 50 nicht überschreiten
  • Wiederverbindungsrate: eine hohe Rate deutet auf ein Netzwerk- oder Lebensdauerproblem hin
  • Latenz des ersten audio.delta: misst, wie reaktiv der Dienst ist
  • WebSocket-Fehler: abnormale Schließcodes (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)

Kernaussagen

  • Die Dokumentation erwähnt eine 600-Sekunden-Sitzungserlaubnis: Seien Sie sicher und zählen Sie sie ab dem Moment, in dem Sie sich verbinden
  • Implementieren Sie automatische Wiederverbindung mit exponentiellem Backoff
  • Erneuern Sie die Sitzung vor diesem Zeitpunkt (mit einem 60-Sekunden-Puffer)
  • Verwenden Sie einen Sitzungspool für Anwendungen mit hohem Datenverkehr
  • Bleiben Sie innerhalb des Limits von 50 gleichzeitigen Sitzungen pro Team
  • Überwachen Sie Verbindungsmetriken in der Produktion