Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Časovne omejitve in robustnost v produkcijskem okolju

Lekcija 15 od 16 Posodobljeno 30. julij 2026 Razvijalec
Na tej strani
  1. Pripravi svojo aplikacijo za realni svet
  2. Časovna omejitev 3600 sekund
  3. Obravnava napak
  4. Asinhrona arhitektura
  5. Odklopnik (Circuit Breaker)
  6. Ključne ugotovitve

Pripravi svojo aplikacijo za realni svet

V produkcijskem okolju lahko zahtevki do API-ja Responses trajajo dolgo – še posebej pri modelih za sklepanje, ki pred odgovorom intenzivno razmišljajo. Slabo upravljanje časovnih omejitev lahko povzroči tihe napake ali poslabšano uporabniško izkušnjo.

Časovna omejitev 3600 sekund

xAI priporoča najmanjšo časovno omejitev 3600 sekund (1 ura) za zahtevke do modelov za sklepanje. To je bistveno dlje kot pri standardnih API-jih, kar vpliva na tvojo arhitekturo.

Zakaj tako dolgo?

Modeli za sklepanje Grok-4.5 lahko pred generiranjem odgovora porabijo na stotine tisoč notranjih žetonov za sklepanje. Pri kompleksnih problemih (napredna matematika, analiza kode, večstopenjsko sklepanje) lahko model razmišlja več minut.

Konfiguracija na strani odjemalca

import httpx
from openai import OpenAI

# OpenAI SDK s podaljšano časovno omejitvijo
client = OpenAI(
    api_key="xai-...",
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0, connect=10.0)
)

V curlu:

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

Obravnava napak

Pogoste napake

Koda HTTPVzrokUkrep
401Neveljaven ključ APIPreveri ključ
429Dosežena omejitev hitrostiPoskusi znova z eksponentnim zamikom
500Napaka strežnika xAIPoskusi znova po nekaj sekundah
503Storitev ni na voljoPoskusi znova po 30 sekundah
Časovna omejitevZahtevek predolgPovečaj časovno omejitev ali poenostavi poziv

Vzorec ponovnega poskusa z zamikom

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)

Omejevanje hitrosti

xAI uveljavlja omejitve hitrosti glede na tvoj načrt. Implementiraj omejevalnik hitrosti na strani odjemalca:

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()
        # Odstrani časovne žige, starejše od ene minute
        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 arhitektura

Pri spletnih aplikacijah ne blokiraj glavne niti za 3600 sekund. Uporabi asinhrono arhitekturo:

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

Pretakanje (streaming) je najboljši pristop za interaktivne aplikacije: uporabniki vidijo prve žetone v nekaj sekundah, tudi če celotno generiranje traja dlje.

Odklopnik (Circuit Breaker)

Za zaščito svoje aplikacije pred izpadi API-ja 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

Ključne ugotovitve

  • Nastavi najmanjšo časovno omejitev 3600 sekund za modele za sklepanje
  • Implementiraj ponovne poskuse z eksponentnim zamikom za napaki 429 in 500
  • Uporabi pretakanje za interaktivne aplikacije – uporabniki takoj vidijo žetone
  • Obravnavaj omejevanje hitrosti na strani odjemalca, da se izogneš napakam 429
  • Razmisli o odklopniku za zaščito aplikacije pred izpadi API-ja