Salt la conținutul principal
Română— Alege o limbă
Meniu

Backoff exponențial pentru eroarea HTTP 429

Lecția 6 din 12 Actualizată 30 iulie 2026 Avansat
Pe această pagină
  1. Înțelegerea erorii 429
  2. Cum funcționează backoff-ul exponențial
  3. Implementare manuală
  4. Utilizarea bibliotecii tenacity
  5. Combinarea backoff-ului cu Semaphore
  6. Adaptarea backoff-ului în funcție de tipul de eroare
  7. Puncte cheie

Înțelegerea erorii 429

O eroare HTTP 429 înseamnă că ați depășit limitele de rată (rate limits) ale API-ului. Serverul xAI refuză temporar cererile dumneavoastră pentru a proteja infrastructura. Această eroare este normală într-un context de procesare în lot (batch processing): indică pur și simplu că trimiteți cereri prea rapid.

Reacția adecvată nu este să renunțați, ci să așteptați înainte de a reîncerca. Backoff-ul exponențial este strategia standard pentru gestionarea acestei situații.

Cum funcționează backoff-ul exponențial

În loc să reîncercați imediat (ceea ce ar declanșa din nou o eroare 429), așteptați un interval de timp din ce în ce mai mare între fiecare încercare:

  • Eșecul 1: așteptați 1 secundă
  • Eșecul 2: așteptați 2 secunde
  • Eșecul 3: așteptați 4 secunde
  • Eșecul 4: așteptați 8 secunde
  • Eșecul 5: renunțați

Intervalul de așteptare se dublează la fiecare încercare, de aici și termenul de „exponențial“. Acest lucru oferă serverului timp să își recupereze capacitatea.

Implementare manuală

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)

Variabila jitter (variație aleatorie) este importantă. Dacă mai multe coroutine primesc o eroare 429 în același timp, fără jitter, toate ar reîncerca exact în același moment, declanșând din nou o eroare 429. Jitter-ul desincronizează încercările.

Utilizarea bibliotecii tenacity

Pentru utilizarea în producție, biblioteca tenacity simplifică implementarea:

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

Decoratorul @retry interceptează RateLimitError, așteptă un interval exponențial (între 1 și 60 de secunde) și reîncearcă de până la 5 ori. Codul funcției rămâne curat și lizibil.

Combinarea backoff-ului cu Semaphore

În practică, combinați backoff-ul cu un semaphore pentru un control total:

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)

Semaphore-ul previne supraîncărcarea API-ului, iar backoff-ul gestionează erorile 429 reziduale. Această dublă protecție este configurația recomandată pentru mediul de producție.

Adaptarea backoff-ului în funcție de tipul de eroare

Nu toate erorile justifică o reîncercare. Iată o clasificare:

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

Erorile 429 (limită de rată), timeout-urile și erorile de conexiune merită o reîncercare. Totuși, o BadRequestError (prompt invalid) nu va fi rezolvată prin reîncercare.

Puncte cheie

  • O eroare 429 este normală și așteptată în timpul procesării în lot
  • Backoff-ul exponențial dublează intervalul dintre fiecare încercare (1s, 2s, 4s, 8s…)
  • Jitter-ul desincronizează noile încercări pentru a evita coliziunile
  • Biblioteca tenacity simplifică implementarea în producție
  • Combinați întotdeauna semaphore-ul cu backoff-ul pentru o reziliență maximă
  • Nu reîncercați în cazul erorilor de cerere invalidă (BadRequestError)