WebSocket-munkamenetek kezelése
Ezen az oldalon
Frissítve: 2026. november 3., az xAI Text to Speech oldala alapján, amely egy 600 másodperces „munkameneti engedélyről“ és időtúllépés nélküli kapcsolatról tesz említést. Az alábbi megújítási stratégia elővigyázatosságból javasolt. Forrás: Text to Speech.
A munkamenet életciklusának elsajátítása
Éles környezetben a robusztus WebSocket-munkamenet-kezelés választja el a prototípust a megbízható terméktől. A TTS-munkamenetek sajátos korlátokkal járnak (élettartam, egyidejűség korlátai), amelyeket az alkalmazásodnak megfelelően kezelnie kell.
A munkamenet életciklusa
Egy TTS WebSocket-munkamenet a következő cikluson megy keresztül:
- Megnyitás: kapcsolódás a
wss://api.x.ai/v1/ttscímhez a szükséges paraméterekkel - Aktív:
text.delta/audio.deltaüzenetek cseréje - Normál lezárás: a kliens vagy a szerver zárja le a kapcsolatot
- Váratlan lezárás: hiba, karbantartás vagy a dokumentációban említett 600 másodperces munkameneti engedély lejártakor
A lezárás észlelése
A szerver bármikor lezárhatja a kapcsolatot (belső hiba, karbantartás, a munkameneti engedély lejárt). Az alkalmazásodnak mindig kezelnie kell a lezárási eseményt:
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")
Automatikus újracsatlakozás
Hosszú ideig futó alkalmazások esetén valósíts meg újracsatlakozást exponenciális visszaszámlálással (exponential 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:
# Újracsatlakozás és újrapróbálkozás
await self.connect()
return await self.synthesize(text)
A munkamenet élettartamának kezelése
Az xAI Text to Speech oldala említ egy 600 másodperces „munkameneti engedélyt“ anélkül, hogy pontosítaná, mikor kezdődik, vagy mi történik a lejártakor, külön pedig azt állítja, hogy a kapcsolatnak nincs időtúllépése. A legóvatosabb megközelítés, ha a csatlakozás pillanatától számolod az időt, és ez előtt a pont előtt megújítod a munkamenetet:
import time
class TTLAwareSession:
TTL = 600 # másodperc
REFRESH_MARGIN = 60 # újracsatlakozás 60 másodperccel a lejárat előtt
def __init__(self):
self.connected_at = None
async def connect(self):
# ... csatlakozás ...
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() # Új munkamenet
# ... szöveg elküldése ...
Ha 60 másodperccel a lejárat előtt újracsatlakozol, elkerülheted, hogy a szintézis félbeszakadjon.
Munkamenet-készlet (Pool)
Nagy forgalmú alkalmazások esetén tarts fenn egy újrafelhasználható munkamenet-készletet:
class SessionPool:
def __init__(self, api_key, pool_size=10):
self.api_key = api_key
self.pool_size = min(pool_size, 50) # Maximum 50 csapatonként
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
# Várakozás, amíg egy munkamenet felszabadul
return await self.available.get()
async def release(self, session):
await self.available.put(session)
Tartsd a készlet méretét az 50 munkamenetes korlát egy töredékén, hogy maradjon tartalék az alkalmazásod többi szolgáltatása számára.
Figyelemmel kísérendő metrikák
A munkamenetek éles környezetben való egészséges állapotának biztosításához kövesd nyomon a következőket:
- Aktív munkamenetek száma: nem haladhatja meg az 50-et
- Újracsatlakozási arány: a magas arány hálózati vagy élettartam-problémára utal
- Az első audio.delta késleltetése: a szolgáltatás válaszidejét méri
- WebSocket-hibák: rendellenes lezárási kódok (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)
Főbb megállapítások
- A dokumentáció egy 600 másodperces munkameneti engedélyt említ: a biztonság kedvéért a csatlakozás pillanatától számold
- Valósíts meg automatikus újracsatlakozást exponenciális visszaszámlálással
- Újítsd meg a munkamenetet a lejárat előtt (60 másodperces tartalékkal)
- Használj munkamenet-készletet nagy forgalmú alkalmazásokhoz
- Maradj a csapatonkénti 50 egyidejű munkamenetes korláton belül
- Kövesd nyomon a kapcsolati metrikákat éles környezetben