Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Pārvaldīt WebSocket sesijas

Nodarbība 11 no 14 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Apgūsti sesijas dzīves ciklu
  2. Sesijas dzīves cikls
  3. Automātiska atkārtota savienojuma izveide
  4. Sesijas darbības laika pārvaldība
  5. Sesiju kopums (Pool)
  6. Uzraudzāmie rādītāji
  7. Galvenās atziņas

Atjaunināts 2026. gada 3. novembrī, pamatojoties uz xAI Text to Speech lapu, kurā minēta 600 sekunžu “sesijas atļauja” un savienojums bez noilguma. Tālāk aprakstītā atjaunošanas stratēģija ir piesardzības pasākums. Avots: Text to Speech.

Apgūsti sesijas dzīves ciklu

Produkcijas vidē tieši stabila WebSocket sesiju pārvaldība atšķir prototipu no uzticama produkta. TTS sesijām ir specifiski ierobežojumi (darbības laiks, vienlaicīgu savienojumu limiti), kas tavai lietotnei ir jāapstrādā pareizi.

Sesijas dzīves cikls

TTS WebSocket sesija iziet cauri šādam ciklam:

  1. Atvēršana: savienojuma izveide ar wss://api.x.ai/v1/tts, norādot parametrus
  2. Aktīva: ziņojumu text.delta/audio.delta apmaiņa
  3. Normāla aizvēršana: klients vai serveris aizver savienojumu
  4. Negaidīta aizvēršana: kļūda, apkope vai dokumentācijā minētās 600 sekunžu sesijas atļaujas beigšanās

Aizvēršanas noteikšana

Serveris var aizvert savienojumu jebkurā brīdī (iekšēja kļūda, apkope, sesijas atļaujas beigšanās). Tavai lietotnei vienmēr ir jāapstrādā aizvēršanas notikums:

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

Automātiska atkārtota savienojuma izveide

Ilgstoši darbojošām lietotnēm ievies atkārtotu savienojuma izveidi ar eksponenciālu pauzi (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:
            # Atkārtoti izveido savienojumu un mēģina vēlreiz
            await self.connect()
            return await self.synthesize(text)

Sesijas darbības laika pārvaldība

xAI Text to Speech lapā minēta 600 sekunžu “sesijas atļauja”, nenorādot, kad tā sākas vai kas notiek, kad tā beidzas, un atsevišķi norādīts, ka savienojumam nav noilguma. Piesardzīgākā pieeja ir skaitīt laiku no savienojuma izveides brīža un atjaunot sesiju pirms šī punkta:

import time

class TTLAwareSession:
    TTL = 600  # sekundes
    REFRESH_MARGIN = 60  # atkārtoti savienoties 60 s pirms derīguma termiņa beigām

    def __init__(self):
        self.connected_at = None

    async def connect(self):
        # ... savienojuma izveide ...
        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()  # Jauna sesija
        # ... nosūti tekstu ...

Atkārtota savienojuma izveide 60 sekundes pirms derīguma termiņa beigām novērš pārtraukumu sintēzes procesa vidū.

Sesiju kopums (Pool)

Lietotnēm ar lielu datu plūsmu uzturi atkārtoti izmantojamu sesiju kopu:

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

        # Gaidi, kamēr kāda sesija atbrīvojas
        return await self.available.get()

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

Uzturi kopas lielumu kā daļu no 50 sesiju limita, lai atstātu rezervi savas lietotnes citiem servisiem.

Uzraudzāmie rādītāji

Lai uzturētu sesijas veselīgas produkcijas vidē, uzraugi:

  • Aktīvo sesiju skaits: nedrīkst pārsniegt 50
  • Atkārtotas savienojuma izveides biežums: augsts rādītājs norāda uz tīkla vai darbības laika problēmām
  • Pirmā audio.delta latentums: mēra, cik atsaucīgs ir serviss
  • WebSocket kļūdas: neparasti aizvēršanas kodi (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)

Galvenās atziņas

  • Dokumentācijā minēta 600 sekunžu sesijas atļauja: drošības labad skaiti to no savienojuma izveides brīža
  • Ievies automātisku atkārtotu savienojuma izveidi ar eksponenciālu pauzi
  • Atjauno sesiju pirms šī punkta (ar 60 sekunžu rezervi)
  • Lietotnēm ar lielu datu plūsmu izmanto sesiju kopu
  • Ievēro 50 vienlaicīgu sesiju limitu vienai komandai
  • Produkcijas vidē uzraugi savienojuma metrikas