Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Eksponencijalno povlačenje kod HTTP 429 pogreške

Lekcija 6 od 12 Ažurirano 30. srpnja 2026. Napredno
Na ovoj stranici
  1. Razumijevanje pogreške 429
  2. Kako funkcionira eksponencijalno povlačenje
  3. Ručna implementacija
  4. Korištenje biblioteke tenacity
  5. Kombiniranje povlačenja i semafora
  6. Prilagodba povlačenja vrsti pogreške
  7. Ključne točke

Razumijevanje pogreške 429

HTTP 429 pogreška znači da si premašio ograničenja brzine (rate limits) API-ja. xAI poslužitelj privremeno odbija tvoje zahtjeve kako bi zaštitio infrastrukturu. Ova je pogreška normalna u kontekstu serijske obrade: jednostavno ukazuje na to da šalješ zahtjeve prebrzo.

Prikladan odgovor nije odustajanje, već čekanje prije ponovnog pokušaja. Eksponencijalno povlačenje (exponential backoff) standardna je strategija za rješavanje ove situacije.

Kako funkcionira eksponencijalno povlačenje

Umjesto trenutnog ponovnog pokušaja (što bi izazvalo novu 429 pogrešku), čekaš sve dulje između svakog pokušaja:

    1. neuspjeh: čekaj 1 sekundu
    1. neuspjeh: čekaj 2 sekunde
    1. neuspjeh: čekaj 4 sekunde
    1. neuspjeh: čekaj 8 sekundi
    1. neuspjeh: odustani

Kašnjenje se udvostručuje sa svakim pokušajem, otuda i naziv „eksponencijalno“. To daje poslužitelju vremena da oporavi kapacitet.

Ručna implementacija

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 (slučajna varijacija) ključan je. Ako više korutina istovremeno primi 429 pogrešku, bez jittera sve bi ponovno pokušale točno u isti trenutak, što bi izazvalo novu 429 pogrešku. Jitter desinkronizira pokušaje.

Korištenje biblioteke tenacity

Za produkcijsku upotrebu, biblioteka tenacity pojednostavljuje implementaciju:

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

Dekorator @retry presreće RateLimitError, čeka eksponencijalno kašnjenje (između 1 i 60 sekundi) i ponovno pokušava do 5 puta. Kod funkcije ostaje čist i čitljiv.

Kombiniranje povlačenja i semafora

U praksi kombiniraš povlačenje sa semaforom za potpunu 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 sprječava preopterećenje API-ja, a povlačenje rješava preostale 429 pogreške. Ova dvostruka zaštita preporučena je konfiguracija za produkciju.

Prilagodba povlačenja vrsti pogreške

Nisu sve pogreške opravdanje za ponovni pokušaj. Evo klasifikacije:

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

Pogreške 429 (ograničenje brzine), isteci vremena veze i pogreške povezivanja zaslužuju ponovni pokušaj. Međutim, BadRequestError (neispravan upit) neće se riješiti ponovnim pokušajem.

Ključne točke

  • Pogreška 429 normalna je i očekivana tijekom serijske obrade
  • Eksponencijalno povlačenje udvostručuje kašnjenje između svakog pokušaja (1 s, 2 s, 4 s, 8 s…)
  • Jitter desinkronizira nove pokušaje kako bi se izbjegli sudari
  • Biblioteka tenacity pojednostavljuje implementaciju u produkciji
  • Uvijek kombiniraj semafor i povlačenje za maksimalnu otpornost
  • Ne ponavljaj zahtjeve s pogreškama neispravnog zahtjeva (BadRequestError)