Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Aikakatkaisu ja luotettavuus tuotantoympäristössä

Oppitunti 15 / 16 Päivitetty 30. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. Valmistele sovelluksesi todellista maailmaa varten
  2. 3600 sekunnin aikakatkaisu
  3. Virheenkäsittely
  4. Asynkroninen arkkitehtuuri
  5. Piirikatkaisin
  6. Keskeiset asiat

Valmistele sovelluksesi todellista maailmaa varten

Tuotantoympäristössä pyynnöt Responses API:lle voivat kestää kauan – erityisesti päättelymallien kohdalla, jotka miettivät laajasti ennen vastaamista. Huono aikakatkaisujen käsittely voi aiheuttaa hiljaisia virheitä tai heikentää käyttäjäkokemusta.

3600 sekunnin aikakatkaisu

xAI suosittelee vähintään 3600 sekunnin (1 tunti) aikakatkaisua pyynnöille päättelymalleille. Tämä on huomattavasti pidempi kuin tavallisissa API-rajapinnoissa, mikä vaikuttaa arkkitehtuuriisi.

Miksi näin kauan?

Grok-4.5-päättelymallit voivat käyttää satojatuhansia sisäisiä päättelytokeneita ennen vastauksen tuottamista. Monimutkaisissa tehtävissä (edistynyt matematiikka, koodianalyysi, monivaiheinen päättely) malli voi miettiä useita minuutteja.

Asiakaspuolen konfiguraatio

import httpx
from openai import OpenAI

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

Curlissa:

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

Virheenkäsittely

Yleiset virheet

HTTP-koodiSyyToimenpide
401Virheellinen API-avainTarkista avain
429Nopeusrajoitus saavutettuYritä uudelleen eksponentiaalisella viiveellä
500xAI-palvelinvirheYritä uudelleen muutaman sekunnin kuluttua
503Palvelu ei saatavillaYritä uudelleen 30 sekunnin kuluttua
AikakatkaisuPyyntö liian pitkäKasvata aikakatkaisua tai yksinkertaista kehote

Uudelleenyritysmalli viiveellä

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)

Nopeusrajoitus

xAI valvoo nopeusrajoituksia tilauksesi perusteella. Toteuta asiakaspuolen nopeusrajoitin:

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()
        # Poista yli minuutin vanhat aikaleimat
        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())

Asynkroninen arkkitehtuuri

Verkkosovelluksissa älä estä pääsäiettä 3600 sekunniksi. Käytä asynkronista arkkitehtuuria:

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

Striimaus on paras lähestymistapa vuorovaikutteisiin sovelluksiin: käyttäjät näkevät ensimmäiset tokenit sekunneissa, vaikka koko generointi kestääkin kauemmin.

Piirikatkaisin

Suojataksesi sovelluksesi xAI API:n katkoilta:

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

Keskeiset asiat

  • Määritä vähintään 3600 sekunnin aikakatkaisu päättelymalleille
  • Toteuta uudelleenyritys eksponentiaalisella viiveellä 429- ja 500-virheille
  • Käytä striimausta vuorovaikutteisiin sovelluksiin – käyttäjät näkevät tokenit välittömästi
  • Käsittele nopeusrajoitukset asiakaspuolella 429-virheiden välttämiseksi
  • Harkitse piirikatkaisimen käyttöä suojataksesi sovellustasi API-katkoilta