Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Eksponentsiaalne tagasiminek HTTP 429 korral

Õppetund 6 / 12 Värskendatud 30. juuli 2026 Edasijõudnutele
Sellel lehel
  1. 429 vea mõistmine
  2. Kuidas eksponentsiaalne tagasiminek töötab
  3. Manuaalne teostus
  4. Teegi tenacity kasutamine
  5. Tagasimineku ja semafori kombineerimine
  6. Tagasimineku kohandamine vea tüübi järgi
  7. Peamised punktid

429 vea mõistmine

HTTP 429 viga tähendab, et oled ületanud API kiirusepiiranguid. xAI server keeldub ajutiselt sinu päringuid täitmast, et kaitsta taristut. See viga on partii-töötluse kontekstis normaalne: see näitab lihtsalt, et saadad päringuid liiga kiiresti.

Õige reaktsioon pole loobumine, vaid ootamine enne uuesti proovimist. Eksponentsiaalne tagasiminek on selle olukorra lahendamise standardstrateegia.

Kuidas eksponentsiaalne tagasiminek töötab

Selle asemel, et kohe uuesti proovida (mis käivitaks uue 429 vea), ootad iga katse vahel kasvavat viidet:

    1. ebaõnnestumine: oota 1 sekund
    1. ebaõnnestumine: oota 2 sekundit
    1. ebaõnnestumine: oota 4 sekundit
    1. ebaõnnestumine: oota 8 sekundit
    1. ebaõnnestumine: loobu

Viide kahekordistub iga katsega, seega ka termin „eksponentsiaalne“. See annab serverile aega võimsuse taastamiseks.

Manuaalne teostus

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  # viimane katse, edasta viga

            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 (juhuslik variatsioon) on oluline. Kui mitu korutiini saavad samaaegselt 429 vea, prooviksid nad ilma jitterita kõik täpselt samal hetkel uuesti, käivitades uue 429 vea. Jitter desünkroniseerib katsed.

Teegi tenacity kasutamine

Tootmiskeskkonnas lihtsustab teek tenacity teostust:

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

Dekoraator @retry püüab kinni RateLimitError, ootab eksponentsiaalset viidet (1 ja 60 sekundi vahel) ja proovib kuni 5 korda uuesti. Funktsiooni kood jääb puhtaks ja loetavaks.

Tagasimineku ja semafori kombineerimine

Praktikas kombineerid tagasimineku semaforiga täieliku kontrolli saavutamiseks:

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 hoiab ära API ülekoormamise ja tagasiminek haldab ülejäänud 429 vigu. See topeltkaitse on tootmiskeskkonnas soovitatud konfiguratsioon.

Tagasimineku kohandamine vea tüübi järgi

Mitte kõik vead ei õigusta uuesti proovimist. Siin on klassifikatsioon:

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  # viga päringus, uuesti proovimine on kasutu

429 vead (kiirusepiirang), ajalõpumised ja ühendusvead väärivad uuesti proovimist. Seevastu BadRequestError (vigane päring) ei lahene uuesti proovimisega.

Peamised punktid

  • 429 viga on partii-töötluse ajal normaalne ja oodatav
  • Eksponentsiaalne tagasiminek kahekordistab iga katse vahelist viidet (1 s, 2 s, 4 s, 8 s…)
  • Jitter desünkroniseerib uusi katseid, et vältida kokkupõrkeid
  • Teek tenacity lihtsustab teostust tootmiskeskkonnas
  • Kombineeri alati semafor ja tagasiminek maksimaalse vastupidavuse saavutamiseks
  • Ära proovi uuesti vigaste päringute vigu (BadRequestError)