Bainistíocht seisiún WebSocket
Ar an leathanach seo
Nuashonraithe an 3 Samhain 2026, bunaithe ar an leathanach Text to Speech ó xAI, a luaann “cead seisiúin” 600 soicind agus nasc gan aon teorainn ama. Is beart réamhchúraim é an straitéis athnuachana thíos. Foinse: Text to Speech.
Máistir a dhéanamh ar shaolré an tseisiúin
Sa táirgeadh, is é bainistíocht láidir sheisiún WebSocket an difríocht idir fréamhshamhail agus táirge iontaofa. Tagann srianta sonracha le seisiúin TTS (saolré, teorainneacha comhthreomhaireachta) nach mór d’fheidhmchlár a láimhseáil i gceart.
Saolré an tseisiúin
Téann seisiún WebSocket TTS tríd an timthriall seo:
- Oscailt: nasc le
wss://api.x.ai/v1/ttsleis na paraiméadair - Gníomhach: malartú teachtaireachtaí
text.delta/audio.delta - Dúnadh gnáth: dúnann an cliant nó an freastalaí an nasc
- Dúnadh gan choinne: earráid, cothabháil, nó deireadh an cheada seisiúin 600 soicind a luaitear sa doiciméadú
Brath ar dhúnadh
Is féidir leis an bhfreastalaí an nasc a dhúnadh ag am ar bith (earráid inmheánach, cothabháil, deireadh an cheada seisiúin). Ba chóir d’fheidhmchlár an teagmhas dúntha a láimhseáil i gcónaí:
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")
Athnascadh uathoibríoch
Chun feidhmchláir a ritheann ar feadh i bhfad, cuir athnascadh i bhfeidhm le cúlú easpónantúil:
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:
# Athnasc agus déan iarracht arís
await self.connect()
return await self.synthesize(text)
Bainistíocht ar shaolré an tseisiúin
Luaann an leathanach Text to Speech ó xAI “cead seisiúin” 600 soicind gan a rá cathain a thosaíonn sé nó cad a tharlaíonn nuair a chríochnaíonn sé, agus deir sé ar leithligh nach bhfuil aon teorainn ama leis an nasc. Is é an cur chuige is cúthalaí ná comhaireamh ón nóiméad a nascann tú agus an seisiún a athnuachan roimh an bpointe sin:
import time
class TTLAwareSession:
TTL = 600 # soicind
REFRESH_MARGIN = 60 # athnasc 60 s roimh dhul in éag
def __init__(self):
self.connected_at = None
async def connect(self):
# ... nasc ...
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() # Seisiún nua
# ... seol an téacs ...
Coinníonn an t-athnascadh 60 soicind roimh dhul in éag as an ngearradh ort i lár sintéise.
Linne seisiún
Chun feidhmchláir thráchta arda, coinnigh linne de sheisiúin in-athúsáidte:
class SessionPool:
def __init__(self, api_key, pool_size=10):
self.api_key = api_key
self.pool_size = min(pool_size, 50) # Uasmhéid 50 in aghaidh na foirne
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
# Fan go saorfar seisiún
return await self.available.get()
async def release(self, session):
await self.available.put(session)
Coinnigh méid na linne ina chodán den teorainn 50-seisiún chun spás a fhágáil do sheirbhísí eile d’fheidhmchláir.
Méadrachtaí le faire orthu
Chun seisiúin a choinneáil sláintiúil sa táirgeadh, déan monatóireacht ar:
- Líon na seisiún gníomhach: ní mór nach sáraíonn sé 50
- Ráta athnascadh: léiríonn ráta ard fadhb líonra nó saolré
- Moill an chéad
audio.delta: tomhaiseann sé cé chomh freagrach agus atá an tseirbhís - Earráidí WebSocket: cóid dúntha mínormálta (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)
Príomhphointí
- Luaann an doiciméadú cead seisiúin 600 soicind: chun a bheith sábháilte, comhair ón nóiméad a nascann tú
- Cuir athnascadh uathoibríoch i bhfeidhm le cúlú easpónantúil
- Athnuadaigh an seisiún roimh an bpointe sin (le corrlach 60 soicind)
- Úsáid linne seisiún d’fheidhmchláir thráchta arda
- Fan faoin teorainn 50 seisiún comhthreomhar in aghaidh na foirne
- Déan monatóireacht ar mhéadrachtaí nasctha sa táirgeadh