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

Laika limiti un noturība ražošanas vidē

Nodarbība 15 no 16 Atjaunota 2026. gada 30. jūlijs Programmētājs
Šajā lapā
  1. Sagatavo savu lietotni reālajai videi
  2. 3600 sekunžu laika limits
  3. Kļūdu apstrāde
  4. Asinhrona arhitektūra
  5. Ķēdes pārtraucējs (Circuit Breaker)
  6. Galvenās atziņas

Sagatavo savu lietotni reālajai videi

Ražošanas vidē pieprasījumi Responses API var aizņemt ilgu laiku, it īpaši, ja izmanto spriešanas modeļus, kas pirms atbildes sniegšanas veic plašu domāšanas procesu. Nepareiza laika limitu apstrāde var izraisīt klusas kļūmes vai pasliktināt lietotāja pieredzi.

3600 sekunžu laika limits

xAI iesaka iestatīt minimālo laika limitu 3600 sekundēm (1 stunda) pieprasījumiem spriešanas modeļiem. Tas ir ievērojami ilgāk nekā standarta API gadījumā, kas ietekmē tavu arhitektūru.

Kāpēc tik ilgi?

Grok-4.5 spriešanas modeļi pirms atbildes ģenerēšanas var izmantot simtiem tūkstošu iekšējo spriešanas tokenus. Risinot sarežģītas problēmas (augstākā matemātika, koda analīze, daudzsoloņu spriešana), modelis var domāt vairākas minūtes.

Klienta puses konfigurācija

import httpx
from openai import OpenAI

# OpenAI SDK ar pagarinātu laika limitu
client = OpenAI(
    api_key="xai-...",
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0, connect=10.0)
)

Izmantojot curl:

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

Kļūdu apstrāde

Biežāk sastopamās kļūdas

HTTP kodsCēlonisDarbība
401Nederīga API atslēgaPārbaudi atslēgu
429Sasniegts ātruma limitsMēģini vēlreiz ar eksponenciālu pauzi
500xAI servera kļūdaMēģini vēlreiz pēc dažām sekundēm
503Pakalpojums nav pieejamsMēģini vēlreiz pēc 30 sekundēm
Laika limitsPieprasījums pārāk garšPalielini laika limitu vai vienkāršo uzdevumu

Atkārtošanas shēma ar eksponenciālu pauzi

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)

Ātruma ierobežošana

xAI piemēro ātruma ierobežojumus atkarībā no tava tarifa plāna. Implementē klienta puses ātruma ierobežotāju:

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()
        # Dzēš laika zīmogus, kas vecāki par vienu minūti
        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())

Asinhrona arhitektūra

Tīmekļa lietotnēm nebloķē galveno pavedienu uz 3600 sekundēm. Izmanto asinhronu arhitektū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

Straumēšana ir labākā pieeja interaktīvām lietotnēm: lietotāji redz pirmos tokenus dažu sekunžu laikā, pat ja pilnīga ģenerēšana aizņem ilgāku laiku.

Ķēdes pārtraucējs (Circuit Breaker)

Lai pasargātu savu lietotni no xAI API pārtraukumiem:

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

Galvenās atziņas

  • Konfigurē minimālo laika limitu 3600 sekundēm spriešanas modeļiem
  • Implementē atkārtošanu ar eksponenciālu pauzi 429 un 500 kļūdām
  • Izmanto straumēšanu interaktīvām lietotnēm — lietotāji uzreiz redz tokenus
  • Apstrādā ātruma ierobežojumus klienta pusē, lai izvairītos no 429 kļūdām
  • Apsver ķēdes pārtraucēja izmantošanu, lai pasargātu lietotni no API pārtraukumiem