Salt la conținutul principal
Română— Alege o limbă
Meniu

Gestionarea sesiunilor WebSocket

Lecția 11 din 14 Actualizată 3 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Stăpânirea ciclului de viață al sesiunii
  2. Ciclul de viață al sesiunii
  3. Reconectare automată
  4. Gestionarea duratei de viață a sesiunii
  5. Pool de sesiuni
  6. Metrici de monitorizat
  7. Puncte cheie

Actualizat la 3 noiembrie 2026, pe baza paginii xAI Text to Speech, care menționează un „permis de sesiune“ de 600 de secunde și o conexiune fără timeout. Strategia de reînnoire de mai jos este o măsură de precauție. Sursă: Text to Speech.

Stăpânirea ciclului de viață al sesiunii

În producție, o gestionare robustă a sesiunilor WebSocket este ceea ce face diferența dintre un prototip și un produs fiabil. Sesiunile TTS vin cu constrângeri specifice (durată de viață, limite de concurență) pe care aplicația dumneavoastră trebuie să le gestioneze corect.

Ciclul de viață al sesiunii

O sesiune WebSocket TTS parcurge următorul ciclu:

  1. Deschidere: conectarea la wss://api.x.ai/v1/tts cu parametrii necesari
  2. Activ: schimbul de mesaje text.delta/audio.delta
  3. Închidere normală: clientul sau serverul închide conexiunea
  4. Închidere neașteptată: o eroare, o operațiune de mentenanță sau expirarea permisului de sesiune de 600 de secunde menționat în documentație

Detectarea închiderii

Serverul poate închide conexiunea în orice moment (eroare internă, mentenanță, expirarea permisului de sesiune). Aplicația dumneavoastră trebuie să gestioneze întotdeauna evenimentul de închidere:

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")

Reconectare automată

Pentru aplicațiile cu funcționare îndelungată, implementați o reconectare cu backoff exponențial:

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:
            # Reconectare și reîncercare
            await self.connect()
            return await self.synthesize(text)

Gestionarea duratei de viață a sesiunii

Pagina xAI Text to Speech menționează un „permis de sesiune“ de 600 de secunde, fără a specifica momentul de start sau ce se întâmplă la expirare, afirmând separat că conexiunea nu are timeout. Cea mai prudentă abordare este să numărați timpul de la momentul conectării și să reînnoiți sesiunea înainte de acel termen:

import time

class TTLAwareSession:
    TTL = 600  # secunde
    REFRESH_MARGIN = 60  # reconectare cu 60 s înainte de expirare

    def __init__(self):
        self.connected_at = None

    async def connect(self):
        # ... conexiune ...
        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()  # Sesiune nouă
        # ... trimiterea textului ...

Reconectarea cu 60 de secunde înainte de expirare vă evită întreruperea în timpul sintezei.

Pool de sesiuni

Pentru aplicațiile cu trafic intens, mențineți un pool de sesiuni reutilizabile:

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

        # Așteptarea eliberării unei sesiuni
        return await self.available.get()

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

Mențineți dimensiunea pool-ului la o fracțiune din limita de 50 de sesiuni pentru a lăsa marjă de manevră celorlalte servicii ale aplicației dumneavoastră.

Metrici de monitorizat

Pentru a menține sesiunile sănătoase în producție, monitorizați:

  • Numărul de sesiuni active: nu trebuie să depășească 50
  • Rata de reconectare: o rată ridicată indică o problemă de rețea sau de durată de viață
  • Latenta primului audio.delta: măsoară capacitatea de reacție a serviciului
  • Erori WebSocket: coduri de închidere anormale (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)

Puncte cheie

  • Documentația menționează un permis de sesiune de 600 de secunde: din precauție, numărați timpul de la momentul conectării
  • Implementați reconectarea automată cu backoff exponențial
  • Reînnoiți sesiunea înainte de expirare (cu o marjă de 60 de secunde)
  • Utilizați un pool de sesiuni pentru aplicațiile cu trafic intens
  • Respectați limita de 50 de sesiuni concurente per echipă
  • Monitorizați metricile de conexiune în producție