Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Eksponentinis atsitraukimas gavus HTTP 429 klaidą

Paskaita 6 iš 12 Atnaujinta 2026 m. liepos 30 d. Pažengusiems
Šiame puslapyje
  1. 429 klaidos supratimas
  2. Kaip veikia eksponentinis atsitraukimas
  3. Rankinis įgyvendinimas
  4. „tenacity“ bibliotekos naudojimas
  5. Atsitraukimo ir semaforo derinimas
  6. Atsitraukimo pritaikymas pagal klaidos tipą
  7. Svarbiausi punktai

429 klaidos supratimas

HTTP 429 klaida reiškia, kad viršijai API užklausų dažnio ribas. xAI serveris laikinai atmeta tavo užklausas, kad apsaugotų infrastruktūrą. Ši klaida yra normali vykdant grupinį duomenų apdorojimą: ji tiesiog signalizuoja, kad siunči užklausas per greitai.

Tinkama reakcija – ne pasiduoti, o palaukti prieš bandant iš naujo. Eksponentinis atsitraukimas (angl. exponential backoff) yra standartinė strategija tokiai situacijai valdyti.

Kaip veikia eksponentinis atsitraukimas

Užuot bandžius iš karto (kas sukeltų dar vieną 429 klaidą), tarp kiekvieno bandymo laukiama vis ilgiau:

  • 1-as nesėkmės atvejis: laukiama 1 sekundę
  • 2-as nesėkmės atvejis: laukiama 2 sekundes
  • 3-ias nesėkmės atvejis: laukiama 4 sekundes
  • 4-as nesėkmės atvejis: laukiama 8 sekundes
  • 5-as nesėkmės atvejis: pasiduodama

Delsa su kiekvienu bandymu dvigubėja, todėl ir vadinama „eksponentine“. Tai suteikia serveriui laiko atkurti pajėgumus.

Rankinis įgyvendinimas

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)

„Jitter“ (atsitiktinė variacija) yra labai svarbus. Jei kelios korutinos vienu metu gauna 429 klaidą, be „jitter“ jos visos bandytų iš naujo tiksliai tuo pačiu momentu ir vėl gautų 429 klaidą. „Jitter“ desinchronizuoja bandymus.

„tenacity“ bibliotekos naudojimas

Naudojimui gamybinėje aplinkoje, tenacity biblioteka supaprastina įgyvendinimą:

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

Dekoratorius @retry perima RateLimitError klaidą, palaukia eksponentinę delsą (tarp 1 ir 60 sekundžių) ir bando iš naujo iki 5 kartų. Funkcijos kodas lieka švarus ir lengvai skaitomas.

Atsitraukimo ir semaforo derinimas

Praktiškai atsitraukimą derini su semaforu, kad gautumėte visišką 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)

Semaforas neleidžia perkrauti API, o atsitraukimas tvarko likusias 429 klaidas. Ši dviguba apsauga yra rekomenduojama konfigūracija gamybinėms sistemoms.

Atsitraukimo pritaikymas pagal klaidos tipą

Ne visos klaidos pateisina kartojimą. Štai jų klasifikacija:

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

429 klaidos (dažnio riba), laiko limito viršijimai ir ryšio klaidos nusipelno kartojimo. Tačiau BadRequestError (netinkama užklausa) kartojant neišsispręs.

Svarbiausi punktai

  • 429 klaida yra normali ir tikėtina vykdant grupinį apdorojimą
  • Eksponentinis atsitraukimas dvigubina delsą tarp kiekvieno bandymo (1 s, 2 s, 4 s, 8 s…)
  • „Jitter“ desinchronizuoja naujus bandymus, kad išvengtumėte susidūrimų
  • tenacity biblioteka supaprastina įgyvendinimą gamybinėje aplinkoje
  • Visada derink semaforą ir atsitraukimą, kad pasiektum maksimalų atsparumą
  • Nekartok užklausų, jei gauni netinkamos užklausos klaidas (BadRequestError)