Przejdź do głównej treści
Polski— Wybierz język
Menu

Czas oczekiwania i odporność w środowisku produkcyjnym

Lekcja 15 z 16 Zaktualizowano 30 lipca 2026 Programista
Na tej stronie
  1. Przygotuj swoją aplikację do świata rzeczywistego
  2. Limit czasu 3600 sekund
  3. Obsługa błędów
  4. Architektura asynchroniczna
  5. Wyłącznik awaryjny (Circuit Breaker)
  6. Kluczowe wnioski

Przygotuj swoją aplikację do świata rzeczywistego

W środowisku produkcyjnym żądania wysyłane do API Responses mogą trwać długo – zwłaszcza w przypadku modeli rozumujących, które poświęcają dużo czasu na analizę przed udzieleniem odpowiedzi. Nieprawidłowe obsługiwanie limitów czasu może prowadzić do cichych awarii lub pogorszenia doświadczeń użytkownika.

Limit czasu 3600 sekund

xAI zaleca ustawienie minimalnego limitu czasu na 3600 sekund (1 godzina) dla żądań kierowanych do modeli rozumujących. Jest to wartość znacznie wyższa niż w przypadku standardowych API, co ma istotny wpływ na architekturę Twojego systemu.

Dlaczego aż tak długo?

Modele rozumujące Grok-4.5 mogą zużyć setki tysięcy wewnętrznych tokenów rozumowania przed wygenerowaniem odpowiedzi. Przy złożonych problemach (zaawansowana matematyka, analiza kodu, rozumowanie wieloetapowe) model może „myśleć“ przez kilka minut.

Konfiguracja po stronie klienta

import httpx
from openai import OpenAI

# OpenAI SDK z wydłużonym limitem czasu
client = OpenAI(
    api_key="xai-...",
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0, connect=10.0)
)

W przypadku curl:

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

Obsługa błędów

Typowe błędy

Kod HTTPPrzyczynaDziałanie
401Nieprawidłowy klucz APIZweryfikuj klucz
429Osiągnięto limit szybkościPonów próbę z wykładniczym opóźnieniem
500Błąd serwera xAIPonów próbę po kilku sekundach
503Usługa niedostępnaPonów próbę po 30 sekundach
TimeoutŻądanie trwa zbyt długoZwiększ limit czasu lub uprość prompt

Wzorzec ponawiania z wykładniczym opóźnieniem

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"Błąd: {e}. Ponawiam za {wait}s...")
            time.sleep(wait)

Limitowanie szybkości (Rate Limiting)

xAI egzekwuje limity szybkości w zależności od Twojego planu. Zaimplementuj mechanizm limitowania po stronie klienta:

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()
        # Usuń znaczniki czasu starsze niż jedna minuta
        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())

Architektura asynchroniczna

W aplikacjach internetowych nie blokuj głównego wątku przez 3600 sekund. Wykorzystaj architekturę asynchroniczną:

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

Strumieniowanie to najlepsze podejście dla aplikacji interaktywnych: użytkownicy widzą pierwsze tokeny w ciągu kilku sekund, nawet jeśli pełne generowanie zajmuje więcej czasu.

Wyłącznik awaryjny (Circuit Breaker)

Aby chronić swoją aplikację przed przerwami w działaniu API 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("Obwód otwarty — API niedostępne")

        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

Kluczowe wnioski

  • Skonfiguruj minimalny limit czasu na 3600 sekund dla modeli rozumujących
  • Wdróż mechanizm ponawiania z wykładniczym opóźnieniem dla błędów 429 i 500
  • Używaj strumieniowania w aplikacjach interaktywnych – użytkownicy natychmiast widzą tokeny
  • Obsługuj limitowanie szybkości po stronie klienta, aby unikać błędów 429
  • Rozważ wdrożenie wyłącznika awaryjnego, aby chronić aplikację przed przerwami w działaniu API