Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Exponenciálne oneskorenie pri chybe HTTP 429

Lekcia 6 z 12 Aktualizované 30. júla 2026 Pokročilý
Na tejto strane
  1. Pochopenie chyby 429
  2. Ako funguje exponenciálne oneskorenie
  3. Manuálna implementácia
  4. Použitie knižnice tenacity
  5. Kombinácia oneskorenia a semafóru
  6. Prispôsobenie oneskorenia typu chyby
  7. Kľúčové poznatky

Pochopenie chyby 429

Chyba HTTP 429 znamená, že si prekročil limit počtu požiadaviek (rate limit) API. Server xAI dočasne odmieta tvoje požiadavky, aby chránil svoju infraštruktúru. Táto chyba je v kontexte dávkového spracovania bežná: jednoducho signalizuje, že odosielaš požiadavky príliš rýchlo.

Správnou reakciou nie je vzdať to, ale počkať pred ďalším pokusom. Exponenciálne oneskorenie (exponential backoff) je štandardná stratégia na riešenie tejto situácie.

Ako funguje exponenciálne oneskorenie

Namiesto okamžitého opakovania (čo by vyvolalo ďalšiu chybu 429) čakáš medzi jednotlivými pokusmi čoraz dlhšie:

    1. zlyhanie: čakaj 1 sekundu
    1. zlyhanie: čakaj 2 sekundy
    1. zlyhanie: čakaj 4 sekundy
    1. zlyhanie: čakaj 8 sekúnd
    1. zlyhanie: vzdaj to

Oneskorenie sa s každým pokusom zdvojnásobí, odtiaľ názov „exponenciálne“. Tým dávaš serveru čas na obnovenie kapacity.

Manuálna implementácia

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á variácia) je dôležitá. Ak viacero korutín dostane chybu 429 v rovnakom čase, bez jitteru by všetky opakovali pokus presne v rovnakom momente, čo by vyvolalo ďalšiu chybu 429. Jitter desynchronizuje pokusy.

Použitie knižnice tenacity

Pre nasadenie v produkcii knižnica tenacity zjednodušuje implementáciu:

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ýnimku RateLimitError, čaká exponenciálne dlho (medzi 1 a 60 sekundami) a opakuje pokus až 5-krát. Kód funkcie zostáva čistý a čitateľný.

Kombinácia oneskorenia a semafóru

V praxi kombinuješ oneskorenie so semaforom pre úplnú 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 preťaženiu API a oneskorenie rieši zostávajúce chyby 429. Táto dvojitá ochrana je odporúčanou konfiguráciou pre produkčné prostredie.

Prispôsobenie oneskorenia typu chyby

Nie všetky chyby si zaslúžia opakovanie. Tu je ich klasifikácia:

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žiadaviek), časové limity (timeout) a chyby pripojenia si zaslúžia opakovanie. Naproti tomu BadRequestError (neplatný prompt) sa opakovaním nevyrieši.

Kľúčové poznatky

  • Chyba 429 je pri dávkovom spracovaní bežná a očakávaná
  • Exponenciálne oneskorenie zdvojnásobuje pauzu medzi pokusmi (1 s, 2 s, 4 s, 8 s…)
  • Jitter desynchronizuje nové pokusy, aby sa predišlo kolíziám
  • Knižnica tenacity zjednodušuje implementáciu v produkcii
  • Vždy kombinuj semafor a oneskorenie pre maximálnu odolnosť
  • Neopakuj požiadavky s chybami neplatných údajov (BadRequestError)