Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Exponenciális visszalépés HTTP 429 hiba esetén

6. lecke 12 közül Frissítve 2026. július 30. Haladó
Ezen az oldalon
  1. A 429-es hiba megértése
  2. Hogyan működik az exponenciális visszalépés
  3. Kézi implementáció
  4. A tenacity könyvtár használata
  5. Visszalépés és szemafor kombinálása
  6. A visszalépés igazítása a hiba típusához
  7. Főbb megállapítások

A 429-es hiba megértése

A HTTP 429-es hiba azt jelenti, hogy túllépted az API sebességkorlátait. Az xAI szervere ideiglenesen elutasítja a kéréseidet az infrastruktúra védelme érdekében. Ez a hiba normális kötegelt feldolgozás (batch processing) esetén: egyszerűen azt jelzi, hogy túl gyorsan küldöd a kéréseket.

A megfelelő reakció nem a feladás, hanem a várakozás az újrapróbálkozás előtt. Az exponenciális visszalépés (exponential backoff) a szabványos stratégia ilyen helyzetek kezelésére.

Hogyan működik az exponenciális visszalépés

Ahelyett, hogy azonnal újrapróbálnád (ami egy újabb 429-es hibát váltana ki), minden próbálkozás között növekvő ideig vársz:

    1. hiba: várakozás 1 másodpercig
    1. hiba: várakozás 2 másodpercig
    1. hiba: várakozás 4 másodpercig
    1. hiba: várakozás 8 másodpercig
    1. hiba: feladás

A várakozási idő minden próbálkozással megduplázódik, innen az „exponenciális“ elnevezés. Ez időt ad a szervernek a kapacitás helyreállítására.

Kézi implementáció

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  # utolsó próbálkozás, továbbítjuk a hibát

            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)

A jitter (véletlenszerű variáció) fontos. Ha több korutin egyszerre kap 429-es hibát, jitter nélkül mindannyian pontosan ugyanabban a pillanatban próbálnák újra, ami ismét 429-es hibát eredményezne. A jitter deszinkronizálja a próbálkozásokat.

A tenacity könyvtár használata

Éles környezetben a tenacity könyvtár leegyszerűsíti a megvalósítást:

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

A @retry dekorátor elfogja a RateLimitError kivételt, vár egy exponenciális ideig (1 és 60 másodperc között), és legfeljebb 5-ször próbálkozik újra. A függvény kódja tiszta és olvasható marad.

Visszalépés és szemafor kombinálása

A gyakorlatban a visszalépést szemaforral kombinálod a teljes kontroll érdekében:

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)

A szemafor megakadályozza az API túlterhelését, a visszalépés pedig kezeli a megmaradó 429-es hibákat. Ez a kettős védelem az ajánlott konfiguráció éles környezetben.

A visszalépés igazítása a hiba típusához

Nem minden hiba indokol újrapróbálkozást. Íme egy osztályozás:

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  # hiba a promptban, az újrapróbálkozás haszontalan

A 429-es hibák (sebességkorlát), az időtúllépések és a kapcsolati hibák megérdemlik az újrapróbálkozást. Ezzel szemben a BadRequestError (érvénytelen prompt) nem oldódik meg újrapróbálkozással.

Főbb megállapítások

  • A 429-es hiba normális és várható kötegelt feldolgozás során
  • Az exponenciális visszalépés megduplázza a várakozási időt minden próbálkozás között (1 mp, 2 mp, 4 mp, 8 mp…)
  • A jitter deszinkronizálja az új próbálkozásokat az ütközések elkerülése érdekében
  • A tenacity könyvtár leegyszerűsíti a megvalósítást éles környezetben
  • A maximális rugalmasság érdekében mindig kombináld a szemafort és a visszalépést
  • Ne próbáld újra az érvénytelen kérések hibáit (BadRequestError)