Eksponentiel backoff ved HTTP 429
På denne side
Forståelse af 429-fejlen
En HTTP 429-fejl betyder, at du har overskredet API’ets hastighedsbegrænsninger (rate limits). xAI-serveren nægter midlertidigt dine anmodninger for at beskytte infrastrukturen. Denne fejl er normal i en kontekst med batchbehandling: den indikerer blot, at du sender anmodninger for hurtigt.
Den rette reaktion er ikke at give op, men at vente før genforsøg. Eksponentiel backoff er standardstrategien til at håndtere denne situation.
Hvordan eksponentiel backoff fungerer
I stedet for at forsøge med det samme (hvilket ville udløse endnu en 429), venter du en stigende forsinkelse mellem hvert forsøg:
-
- fejl: vent 1 sekund
-
- fejl: vent 2 sekunder
-
- fejl: vent 4 sekunder
-
- fejl: vent 8 sekunder
-
- fejl: giv op
Forsinkelsen fordobles ved hvert forsøg, heraf betegnelsen “eksponentiel”. Dette giver serveren tid til at genvinde kapacitet.
Manuel implementering
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 (tilfældig variation) er vigtig. Hvis flere koroutiner modtager en 429 på samme tid, vil de uden jitter alle forsøge igen præcis samme øjeblik, hvilket udløser endnu en 429. Jitter desynkroniserer forsøgene.
Brug af biblioteket tenacity
Til produktionsbrug forenkler biblioteket tenacity implementeringen:
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
Dekoratøren @retry opfanger RateLimitError, venter en eksponentiel forsinkelse (mellem 1 og 60 sekunder) og forsøger op til 5 gange. Funktionskoden forbliver ren og læsbar.
Kombination af backoff og semaphore
I praksis kombinerer du backoff med en semaphore for fuld kontrol:
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)
Semaphoren forhindrer overbelastning af API’et, og backoff håndterer resterende 429-fejl. Denne dobbelte beskyttelse er den anbefalede konfiguration til produktion.
Tilpasning af backoff til fejltype
Ikke alle fejl berettiger til et genforsøg. Her er en klassificering:
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
429-fejl (hastighedsbegrænsning), timeouts og forbindelsesfejl fortjener et genforsøg. En BadRequestError (ugyldig prompt) løses derimod ikke ved at forsøge igen.
Vigtige pointer
- En 429-fejl er normal og forventet under batchbehandling
- Eksponentiel backoff fordobler forsinkelsen mellem hvert forsøg (1 s, 2 s, 4 s, 8 s…)
- Jitter desynkroniserer nye forsøg for at undgå kollisioner
- Biblioteket
tenacityforenkler implementeringen i produktion - Kombiner altid semaphore og backoff for maksimal robusthed
- Undgå at gentage anmodninger med ugyldige fejl (
BadRequestError)