Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Časové limity a odolnosť v produkčnom prostredí

Lekcia 15 z 16 Aktualizované 30. júla 2026 Vývojár
Na tejto strane
  1. Priprav svoju aplikáciu na reálny svet
  2. Časový limit 3600 sekúnd
  3. Spracovanie chýb
  4. Asynchrónna architektúra
  5. Istič (Circuit Breaker)
  6. Kľúčové poznatky

Priprav svoju aplikáciu na reálny svet

V produkčnom prostredí môžu požiadavky na API Responses trvať dlho – najmä pri modeloch s usudzovaním, ktoré pred odpoveďou intenzívne premýšľajú. Zlé nastavenie časových limitov môže spôsobiť tiché zlyhania alebo zhoršiť používateľskú skúsenosť.

Časový limit 3600 sekúnd

xAI odporúča minimálny časový limit 3600 sekúnd (1 hodina) pre požiadavky smerujúce na modely s usudzovaním. To je výrazne viac než pri štandardných API, čo má dopad na tvoju architektúru.

Prečo až tak dlho?

Modely s usudzovaním Grok-4.5 môžu pred vygenerovaním odpovede spotrebovať stovky tisíc interných tokenov na usudzovanie. Pri zložitých úlohách (pokročilá matematika, analýza kódu, viacstupňové usudzovanie) môže model premýšľať niekoľko minút.

Konfigurácia na strane klienta

import httpx
from openai import OpenAI

# OpenAI SDK s predĺženým časovým limitom
client = OpenAI(
    api_key="xai-...",
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0, connect=10.0)
)

V príkaze curl:

curl --max-time 3600 https://api.x.ai/v1/responses \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{...}'

Spracovanie chýb

Bežné chyby

HTTP kódPríčinaAkcia
401Neplatný API kľúčOver kľúč
429Dosiahnutý limit rýchlostiOpakuj s exponenciálnym oneskorením
500Chyba servera xAIOpakuj po niekoľkých sekundách
503Služba nedostupnáOpakuj po 30 sekundách
Časový limitPožiadavka príliš dlháZvýš časový limit alebo zjednoduš prompt

Vzorec opakovania s oneskorením

import time

def call_with_retry(client, max_retries=3, **kwargs):
    for attempt in range(max_retries):
        try:
            return client.responses.create(**kwargs)
        except Exception as e:
            if attempt == max_retries - 1:
                raise
            wait = 2 ** attempt  # 1s, 2s, 4s
            print(f"Error: {e}. Retrying in {wait}s...")
            time.sleep(wait)

Obmedzenie rýchlosti (Rate Limiting)

xAI presadzuje obmedzenia rýchlosti na základe tvojho plánu. Implementuj obmedzovač rýchlosti na strane klienta:

import time
from collections import deque

class RateLimiter:
    def __init__(self, max_requests_per_minute=60):
        self.max_rpm = max_requests_per_minute
        self.timestamps = deque()

    def wait_if_needed(self):
        now = time.time()
        # Odstráni časové pečiatky staršie ako jedna minúta
        while self.timestamps and self.timestamps[0] < now - 60:
            self.timestamps.popleft()
        if len(self.timestamps) >= self.max_rpm:
            sleep_time = 60 - (now - self.timestamps[0])
            time.sleep(max(0, sleep_time))
        self.timestamps.append(time.time())

Asynchrónna architektúra

Pri webových aplikáciách neblokuj hlavné vlákno na 3600 sekúnd. Použi asynchrónnu architektúru:

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    api_key="xai-...",
    base_url="https://api.x.ai/v1"
)

async def process_request(user_input):
    response = await client.responses.create(
        model="grok-4.20-0309-reasoning",
        input=user_input,
        stream=True
    )
    async for event in response:
        if event.type == "response.output_text.delta":
            yield event.delta

Streamovanie je najlepší prístup pre interaktívne aplikácie: používatelia uvidia prvé tokeny v priebehu niekoľkých sekúnd, aj keď úplné generovanie trvá dlhšie.

Istič (Circuit Breaker)

Na ochranu tvojej aplikácie pred výpadkami API xAI:

class CircuitBreaker:
    def __init__(self, failure_threshold=5, reset_timeout=60):
        self.failures = 0
        self.threshold = failure_threshold
        self.reset_timeout = reset_timeout
        self.last_failure = 0
        self.is_open = False

    def call(self, func, *args, **kwargs):
        if self.is_open:
            if time.time() - self.last_failure > self.reset_timeout:
                self.is_open = False
                self.failures = 0
            else:
                raise Exception("Circuit open — API unavailable")

        try:
            result = func(*args, **kwargs)
            self.failures = 0
            return result
        except Exception as e:
            self.failures += 1
            self.last_failure = time.time()
            if self.failures >= self.threshold:
                self.is_open = True
            raise

Kľúčové poznatky

  • Nastav minimálny časový limit 3600 sekúnd pre modely s usudzovaním
  • Implementuj opakovanie s exponenciálnym oneskorením pre chyby 429 a 500
  • Používaj streamovanie pre interaktívne aplikácie – používatelia vidia tokeny okamžite
  • Spracuj obmedzenie rýchlosti na strane klienta, aby si predišiel chybám 429
  • Zváž použitie ističa na ochranu aplikácie pred výpadkami API