Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Timeout og robusthed i produktion

Lektion 15 af 16 Opdateret 30. juli 2026 Udvikler
På denne side
  1. Forbered din applikation til den virkelige verden
  2. Timeout på 3600 sekunder
  3. Fejlhåndtering
  4. Asynkron arkitektur
  5. Circuit Breaker
  6. Vigtige pointer

Forbered din applikation til den virkelige verden

I produktion kan anmodninger til Responses API tage tid – især med ræsonnementsmodeller, der tænker grundigt, før de svarer. Dårlig håndtering af timeout kan føre til stille fejl eller en forringet brugeroplevelse.

Timeout på 3600 sekunder

xAI anbefaler en minimumstimeout på 3600 sekunder (1 time) for anmodninger til ræsonnementsmodeller. Dette er væsentligt længere end for standard-API’er, hvilket påvirker din arkitektur.

Hvorfor så længe?

Grok-4.5 ræsonnementsmodeller kan bruge hundredtusindvis af interne ræsonnementstokens, før de producerer et svar. Ved komplekse problemer (avanceret matematik, kodeanalyse, flertrins-ræsonnement) kan modellen tænke i flere minutter.

Klient-side konfiguration

import httpx
from openai import OpenAI

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

I curl:

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

Fejlhåndtering

Almindelige fejl

HTTP-kodeÅrsagHandling
401Ugyldig API-nøgleVerificér nøglen
429Rate-grænse nåetGenforsøg med eksponentiel backoff
500xAI-serverfejlGenforsøg efter få sekunder
503Tjenesten utilgængeligGenforsøg efter 30 sekunder
TimeoutAnmodning for langØg timeout eller forenkl prompten

Genforsøgsmønster med backoff

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)

Rate-begrænsning

xAI håndhæver rate-grænser baseret på din plan. Implementér en rate-begrænser på klientsiden:

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()
        # Fjern tidsstempler ældre end ét minut
        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())

Asynkron arkitektur

Til webapplikationer må du ikke blokere hovedtråden i 3600 sekunder. Brug en asynkron arkitektur:

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

Streaming er den bedste tilgang til interaktive applikationer: brugere ser de første tokens inden for få sekunder, selvom den fulde generering tager længere tid.

Circuit Breaker

For at beskytte din applikation mod nedetid hos xAI API:

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

Vigtige pointer

  • Konfigurér en minimumstimeout på 3600 sekunder til ræsonnementsmodeller
  • Implementér genforsøg med eksponentiel backoff for 429- og 500-fejl
  • Brug streaming til interaktive applikationer – brugere ser tokens med det samme
  • Håndtér rate-begrænsning på klientsiden for at undgå 429-fejl
  • Overvej en circuit breaker for at beskytte din applikation mod API-nedtid