Verwaltung von WebSocket-Sitzungen
Auf dieser Seite
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:
- Öffnen: Verbindung zu
wss://api.x.ai/v1/ttsmit den Parametern herstellen - Aktiv: Austausch von
text.delta/audio.delta-Nachrichten - Normales Schließen: Der Client oder der Server schließt die Verbindung
- 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