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

Wycofywanie wykładnicze przy błędzie HTTP 429

Lekcja 6 z 12 Zaktualizowano 30 lipca 2026 Zaawansowany
Na tej stronie
  1. Zrozumienie błędu 429
  2. Jak działa wycofywanie wykładnicze
  3. Implementacja ręczna
  4. Wykorzystanie biblioteki tenacity
  5. Łączenie wycofywania z semaforem
  6. Dostosowanie wycofywania do typu błędu
  7. Kluczowe wnioski

Zrozumienie błędu 429

Błąd HTTP 429 oznacza, że przekroczyłeś limity częstotliwości zapytań (rate limits) API. Serwer xAI tymczasowo odrzuca Twoje żądania, aby chronić infrastrukturę. Błąd ten jest normalny w kontekście przetwarzania wsadowego: wskazuje po prostu, że wysyłasz żądania zbyt szybko.

Właściwą reakcją nie jest rezygnacja, lecz odczekanie przed ponowną próbą. Wycofywanie wykładnicze (exponential backoff) to standardowa strategia radzenia sobie z taką sytuacją.

Jak działa wycofywanie wykładnicze

Zamiast podejmować próbę natychmiast (co wywołałoby kolejny błąd 429), odczekujesz coraz dłużej między każdą próbą:

    1. niepowodzenie: czekaj 1 sekundę
    1. niepowodzenie: czekaj 2 sekundy
    1. niepowodzenie: czekaj 4 sekundy
    1. niepowodzenie: czekaj 8 sekund
    1. niepowodzenie: poddaj się

Czas oczekiwania podwaja się przy każdej próbie, stąd nazwa „wykładnicze“. Daje to serwerowi czas na odzyskanie dostępnych zasobów.

Implementacja ręczna

import asyncio
import random
from openai import RateLimitError

async def request_with_backoff(
    prompt: str,
    max_retries: int = 5,
    base_delay: float = 1.0
) -> str:
    for attempt in range(max_retries):
        try:
            response = await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
            return response.choices[0].message.content

        except RateLimitError:
            if attempt == max_retries - 1:
                raise  # ostatnia próba, propaguj błąd

            delay = base_delay * (2 ** attempt)
            jitter = random.uniform(0, delay * 0.1)
            wait_time = delay + jitter

            print(f"Rate limit hit, attempt {attempt + 1}/{max_retries}. "
                  f"Waiting {wait_time:.1f}s")
            await asyncio.sleep(wait_time)

Element jitter (losowa wariancja) jest kluczowy. Jeśli wiele korutyn otrzyma błąd 429 w tym samym momencie, bez jittera wszystkie ponowiłyby próbę dokładnie w tej samej chwili, wywołując kolejny błąd 429. Jitter desynchronizuje próby.

Wykorzystanie biblioteki tenacity

Do zastosowań produkcyjnych biblioteka tenacity upraszcza implementację:

from tenacity import (
    retry,
    stop_after_attempt,
    wait_exponential,
    retry_if_exception_type
)
from openai import RateLimitError

@retry(
    stop=stop_after_attempt(5),
    wait=wait_exponential(multiplier=1, min=1, max=60),
    retry=retry_if_exception_type(RateLimitError)
)
async def robust_request(prompt: str) -> str:
    response = await client.chat.completions.create(
        model="grok-4.5",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

Dekorator @retry перехwytuje RateLimitError, czeka wykładniczo (od 1 do 60 sekund) i ponawia próbę do 5 razy. Kod funkcji pozostaje czysty i czytelny.

Łączenie wycofywania z semaforem

W praktyce łączysz wycofywanie z semaforem, aby uzyskać pełną kontrolę:

async def resilient_batch(prompts: list[str], max_concurrent: int = 5) -> list[str]:
    sem = Semaphore(max_concurrent)

    async def single_request(prompt: str) -> str:
        async with sem:
            return await request_with_backoff(prompt)

    tasks = [single_request(p) for p in prompts]
    return await asyncio.gather(*tasks, return_exceptions=True)

Semafor zapobiega przeciążeniu API, a mechanizm wycofywania obsługuje pozostałe błędy 429. Ta podwójna ochrona to zalecana konfiguracja dla środowisk produkcyjnych.

Dostosowanie wycofywania do typu błędu

Nie wszystkie błędy uzasadniają ponowienie próby. Oto klasyfikacja:

from openai import RateLimitError, APITimeoutError, APIConnectionError, BadRequestError

async def smart_retry(prompt: str, max_retries: int = 5) -> str:
    for attempt in range(max_retries):
        try:
            return await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
        except RateLimitError:
            delay = 2 ** attempt
            await asyncio.sleep(delay)
        except (APITimeoutError, APIConnectionError):
            delay = 2 ** attempt
            await asyncio.sleep(delay)
        except BadRequestError:
            raise  # błąd w prompcie, ponawianie bezcelowe

Błędy 429 (limit częstotliwości), timeouty i błędy połączenia zasługują na ponowienie próby. Jednak BadRequestError (nieprawidłowy prompt) nie zostanie rozwiązany przez ponowienie.

Kluczowe wnioski

  • Błąd 429 jest normalny i oczekiwany podczas przetwarzania wsadowego
  • Wycofywanie wykładnicze podwaja czas oczekiwania między próbami (1 s, 2 s, 4 s, 8 s…)
  • Jitter desynchronizuje nowe próby, aby uniknąć kolizji
  • Biblioteka tenacity upraszcza implementację w środowisku produkcyjnym
  • Zawsze łącz semafor z wycofywaniem, aby osiągnąć maksymalną odporność
  • Nie ponawiaj prób przy błędach nieprawidłowych żądań (BadRequestError)