Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Exponenciální backoff při chybě HTTP 429

Lekce 6 z 12 Aktualizováno 30. července 2026 Pokročilý
Na této stránce
  1. Pochopení chyby 429
  2. Jak funguje exponenciální backoff
  3. Ruční implementace
  4. Využití knihovny tenacity
  5. Kombinace backoffu a semaforu
  6. Přizpůsobení backoffu typu chyby
  7. Klíčové poznatky

Pochopení chyby 429

Chyba HTTP 429 znamená, že jsi překročil limit počtu požadavků API (rate limit). Server xAI dočasně odmítá tvé požadavky, aby chránil svou infrastrukturu. Tato chyba je v kontextu dávkového zpracování běžná: jednoduše signalizuje, že odesíláš požadavky příliš rychle.

Správnou reakcí není vzdát se, ale před dalším pokusem počkat. Exponenciální backoff je standardní strategií pro řešení této situace.

Jak funguje exponenciální backoff

Místo okamžitého opakování (což by vyvolalo další chybu 429) čekáš mezi jednotlivými pokusy stále delší dobu:

    1. selhání: čekání 1 sekunda
    1. selhání: čekání 2 sekundy
    1. selhání: čekání 4 sekundy
    1. selhání: čekání 8 sekund
    1. selhání: vzdát se

Doba čekání se s každým pokusem zdvojnásobí, odtud název „exponenciální“. Tím získá server čas na obnovení kapacity.

Ruční implementace

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  # last attempt, propagate the error

            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)

Hodnota jitter (náhodná variace) je důležitá. Pokud více koutin obdrží chybu 429 ve stejný okamžik, bez jitteru by všechny opakovaly pokus přesně ve stejnou chvíli, což by vyvolalo další chybu 429. Jitter desynchronizuje jednotlivé pokusy.

Využití knihovny tenacity

Pro nasazení v produkčním prostředí zjednodušuje implementaci knihovna tenacity:

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

Dekorátor @retry zachytí výjimku RateLimitError, počká exponenciálně dlouhou dobu (mezi 1 a 60 sekundami) a zopakuje pokus až 5krát. Kód funkce zůstává čistý a čitelný.

Kombinace backoffu a semaforu

V praxi kombinuješ backoff se semaforem pro úplnou kontrolu:

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 zabraňuje přetížení API a backoff řeší zbytkové chyby 429. Tato dvojitá ochrana je doporučenou konfigurací pro produkční prostředí.

Přizpůsobení backoffu typu chyby

Ne všechny chyby ospravedlňují opakování. Zde je jejich klasifikace:

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  # error in prompt, retry useless

Chyby 429 (limit počtu požadavků), časové limity a chyby připojení si zaslouží opakování. Naproti tomu BadRequestError (neplatný prompt) se opakováním nevyřeší.

Klíčové poznatky

  • Chyba 429 je při dávkovém zpracování běžná a očekávaná
  • Exponenciální backoff zdvojnásobuje dobu čekání mezi jednotlivými pokusy (1 s, 2 s, 4 s, 8 s…)
  • Jitter desynchronizuje nové pokusy, aby se předešlo kolizím
  • Knihovna tenacity zjednodušuje implementaci v produkčním prostředí
  • Pro maximální odolnost vždy kombinuj semafor a backoff
  • Neopakuj chyby neplatných požadavků (BadRequestError)