Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Backoff Esponenzjali fuq HTTP 429

Lezzjoni 6 / 12 Aġġornat 30 ta’ Lulju 2026 Avvanzat
F'din il-paġna
  1. Fehim tal-Iżball 429
  2. Kif Jaħdem il-Backoff Esponenzjali
  3. Implimentazzjoni Manwali
  4. Użu tal-Librerija tenacity
  5. Tagħqid ta’ Backoff u Semaphore
  6. Adattament tal-Backoff skont it-Tip ta’ Żball
  7. Punti Ewlenin

Fehim tal-Iżball 429

Iżball HTTP 429 ifisser li qbiżt il-limiti tar-rata (rate limits) tal-API. Is-server ta’ xAI jirrifjuta temporanjament it-talbiet tiegħek biex jipproteġi l-infrastruttura. Dan l-iżball huwa normali f’kuntest ta’ ipproċessar bil-batches: sempliċiment jindika li qed tibgħat it-talbiet malajr wisq.

Ir-reazzjoni xierqa mhix li tirriżenja, iżda li tistenna qabel ma terġa’ tipprova. Il-backoff esponenzjali huwa l-istrateġija standard biex tittratta din is-sitwazzjoni.

Kif Jaħdem il-Backoff Esponenzjali

Minflok ma terġa’ tipprova immedjatament (li kieku kien iwassal għal 429 ieħor), tistenna dewmien li jiżdied bejn kull tentattiv:

  • 1-il falliment: stenna sekonda waħda
  • 2 falliment: stenna 2 sekondi
  • 3 fallimenti: stenna 4 sekondi
  • 4 fallimenti: stenna 8 sekondi
  • 5 fallimenti: irriżenja

Id-dewmien jirdoppja ma’ kull tentattiv, għalhekk it-terminu “esponenzjali”. Dan jagħti lis-server il-ħin biex jirkupra l-kapaċità tiegħu.

Implimentazzjoni Manwali

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)

Il-jitter (varjazzjoni każwali) huwa importanti. Jekk diversi coroutine jirċievu 429 fl-istess ħin, mingħajr jitter kollha jerġgħu jippruvaw eżattament fl-istess mument, u dan iwassal għal 429 ieħor. Il-jitter jiddesinkronizza t-tentattivi.

Użu tal-Librerija tenacity

Għall-użu fil-produzzjoni, il-librerija tenacity tissimplifika l-implimentazzjoni:

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

Id-dekoratur @retry jinterċetta l-RateLimitError, jistenna dewmien esponenzjali (bejn 1 u 60 sekonda), u jerġa’ jipprova sa 5 darbiet. Il-kodiċi tal-funzjoni jibqa’ nadif u leġibbli.

Tagħqid ta’ Backoff u Semaphore

Fil-prattika, tgħaqqad il-backoff ma’ semaphore għal kontroll sħiħ:

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)

Is-semaphore jipprevjeni li l-API tiġi mgħobbija żejjed, u l-backoff jittratta l-iżbalji 429 residwi. Din il-protezzjoni doppja hija l-konfigurazzjoni rrakkomandata għall-produzzjoni.

Adattament tal-Backoff skont it-Tip ta’ Żball

Mhux l-iżbalji kollha jiġġustifikaw tentattiv mill-ġdid. Hawnhekk hemm klassifikazzjoni:

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

L-iżbalji 429 (limitu tar-rata), it-timeouts, u l-iżbalji tal-konnessjoni jistħoqqilhom tentattiv mill-ġdid. Madankollu, BadRequestError (prompt invalidu) ma jiġix solvut billi terġa’ tipprova.

Punti Ewlenin

  • Żball 429 huwa normali u mistenni waqt l-ipproċessar bil-batches
  • Il-backoff esponenzjali jirdoppja d-dewmien bejn kull tentattiv (1s, 2s, 4s, 8s…)
  • Il-jitter jiddesinkronizza t-tentattivi ġodda biex jevita l-kolliżjonijiet
  • Il-librerija tenacity tissimplifika l-implimentazzjoni fil-produzzjoni
  • Dejjem għaqqad semaphore u backoff għal reżiljenza massima
  • Tippruvax mill-ġdid żbalji ta’ talbiet invalidi (BadRequestError)