Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Eksponenciālā atkāpšanās pie HTTP 429 kļūdas

Nodarbība 6 no 12 Atjaunota 2026. gada 30. jūlijs Augstākais
Šajā lapā
  1. 429. kļūdas izpratne
  2. Kā darbojas eksponenciālā atkāpšanās
  3. Manuāla implementācija
  4. Bibliotēkas tenacity izmantošana
  5. Atkāpšanās un semafora kombinēšana
  6. Atkāpšanās pielāgošana kļūdas tipam
  7. Galvenās atziņas

429. kļūdas izpratne

HTTP 429 kļūda nozīmē, ka esi pārsniedzis API ātruma ierobežojumus. xAI serveris uz laiku noraida tavus pieprasījumus, lai aizsargātu infrastruktūru. Šī kļūda ir normāla partijas apstrādes kontekstā: tā vienkārši norāda, ka sūti pieprasījumus pārāk ātri.

Pareizā reakcija nav padoties, bet gan pagaidīt pirms atkārtota mēģinājuma. Eksponenciālā atkāpšanās ir standarta stratēģija šīs situācijas risināšanai.

Kā darbojas eksponenciālā atkāpšanās

Tā vietā, lai mēģinātu uzreiz atkārtot (kas izraisītu vēl vienu 429. kļūdu), tu gaidi arvien ilgāku laiku starp katru mēģinājumu:

    1. neveiksme: gaidi 1 sekundi
    1. neveiksme: gaidi 2 sekundes
    1. neveiksme: gaidi 4 sekundes
    1. neveiksme: gaidi 8 sekundes
    1. neveiksme: atsakies

Aizture dubultojas ar katru mēģinājumu, no kā cēlies termins „eksponenciāla”. Tas dod serverim laiku atjaunot kapacitāti.

Manuāla implementācija

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” (nejauša variācija) ir svarīgs. Ja vairākas korutīnes vienlaikus saņem 429. kļūdu, bez jitter tās visas mēģinātu atkārtoti tieši vienlaicīgi, izraisot jaunu 429. kļūdu. Jitter desinhronizē mēģinājumus.

Bibliotēkas tenacity izmantošana

Lietošanai produkcijā bibliotēka tenacity vienkāršo implementāciju:

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

Dekorators @retry pārtver RateLimitError, gaida eksponenciālu aizturi (starp 1 un 60 sekundēm) un atkārto līdz 5 reizēm. Funkcijas kods paliek tīrs un lasāms.

Atkāpšanās un semafora kombinēšana

Praksē tu apvieno atkāpšanos ar semaforu pilnīgai kontrolei:

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)

Semafors novērš API pārslodzi, bet atkāpšanās tiek galā ar atlikušajām 429. kļūdām. Šī dubultā aizsardzība ir ieteicamā konfigurācija produkcijai.

Atkāpšanās pielāgošana kļūdas tipam

Ne visas kļūdas attaisno atkārtotu mēģinājumu. Lūk klasifikācija:

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
  1. kļūdas (ātruma ierobežojums), noilgumi un savienojuma kļūdas ir pelnījušas atkārtotu mēģinājumu. Tomēr BadRequestError (nederīgs uzvednis) netiks atrisināts, atkārtojot pieprasījumu.

Galvenās atziņas

    1. kļūda ir normāla un sagaidāma partijas apstrādes laikā
  • Eksponenciālā atkāpšanās dubulto aizturi starp katru mēģinājumu (1 s, 2 s, 4 s, 8 s…)
  • Jitter desinhronizē jaunus mēģinājumus, lai izvairītos no sadursmēm
  • Bibliotēka tenacity vienkāršo implementāciju produkcijā
  • Vienmēr apvieno semaforu un atkāpšanos maksimālai noturībai
  • Neatkārto nederīgu pieprasījumu kļūdas (BadRequestError)