Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Ajalõpp ja töökindlus tootmiskeskkonnas

Õppetund 15 / 16 Värskendatud 30. juuli 2026 Arendajatele
Sellel lehel
  1. Valmista oma rakendus ette reaalseks maailmaks
  2. 3600-sekundiline ajalõpp
  3. Kliendipoolne konfiguratsioon
  4. Veahaldus
  5. Asünkroonne arhitektuur
  6. Voolukatkesti
  7. Peamised punktid

Valmista oma rakendus ette reaalseks maailmaks

Tootmiskeskkonnas võivad Responses API päringud aega võtta – eriti põhjendusmudelite puhul, mis mõtlevad enne vastuse andmist põhjalikult läbi. Halvasti hallatud ajalõpp võib põhjustada vaikseid tõrkeid või kasutajakogemuse halvenemist.

3600-sekundiline ajalõpp

xAI soovitab põhjendusmudelitele saadetavate päringute minimaalseks ajalõpuks 3600 sekundit (1 tund). See on tavapäraste API-dega võrreldes oluliselt pikem, mis mõjutab sinu arhitektuuri.

Miks nii kaua?

Grok-4.5 põhjendusmudelid võivad enne vastuse genereerimist kasutada sadu tuhandeid sisemisi põhjendustokeneid. Kompleksete ülesannete (kõrgem matemaatika, koodianalüüs, mitmeastmeline arutluskäik) puhul võib mudel mõelda mitu minutit.

Kliendipoolne konfiguratsioon

import httpx
from openai import OpenAI

# OpenAI SDK pikendatud ajalõpuga
client = OpenAI(
    api_key="xai-...",
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0, connect=10.0)
)

Curlis:

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

Veahaldus

Levinud vead

HTTP koodPõhjusTegevus
401Vigane API võtiKontrolli võtit
429Kiirusepiirang saavutatudProovi uuesti eksponentsiaalse taganemisega
500xAI serveri vigaProovi mõne sekundi pärast uuesti
503Teenus pole saadavalProovi 30 sekundi pärast uuesti
AjalõppPäring liiga pikkSuurenda ajalõppu või lihtsusta sisendit

Uuestiproovimise muster taganemisega

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)

Kiirusepiirangud

xAI rakendab kiirusepiiranguid vastavalt sinu paketile. Rakenda kliendipoolne kiirusepiiraja:

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()
        # Eemalda üle minuti vanused ajatemplid
        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())

Asünkroonne arhitektuur

Veebirakendustes ära blokeeri peamist lõngu 3600 sekundiks. Kasuta asünkroonset arhitektuuri:

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

Voogedastus on interaktiivsete rakenduste jaoks parim lähenemine: kasutajad näevad esimesi tokeneid mõne sekundi jooksul, isegi kui täielik genereerimine võtab kauem aega.

Voolukatkesti

Et kaitsta oma rakendust xAI API katkestuste eest:

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

Peamised punktid

  • Seadista põhjendusmudelitele minimaalne ajalõpp 3600 sekundit
  • Rakenda 429 ja 500 vigade korral uuestiproovimine eksponentsiaalse taganemisega
  • Kasuta interaktiivsetes rakendustes voogedastust – kasutajad näevad tokeneid koheselt
  • Hallake kiirusepiiranguid kliendipoolselt, et vältida 429 vigu
  • Kaalu voolukatkesti kasutamist, et kaitsta rakendust API katkestuste eest