Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

WebSocket-munkamenetek kezelése

11. lecke 14 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. A munkamenet életciklusának elsajátítása
  2. A munkamenet életciklusa
  3. Automatikus újracsatlakozás
  4. A munkamenet élettartamának kezelése
  5. Munkamenet-készlet (Pool)
  6. Figyelemmel kísérendő metrikák
  7. Főbb megállapítások

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:

  1. Megnyitás: kapcsolódás a wss://api.x.ai/v1/tts címhez a szükséges paraméterekkel
  2. Aktív: text.delta/audio.delta üzenetek cseréje
  3. Normál lezárás: a kliens vagy a szerver zárja le a kapcsolatot
  4. 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