Exponentiell backoff vid HTTP 429
På denna sida
Förståelse för felkoden 429
Ett HTTP 429-fel innebär att du har överskridit API:ets hastighetsbegränsningar. xAI-servern vägrar tillfälligt dina förfrågningar för att skydda infrastrukturen. Detta fel är normalt i ett batchbearbetningssammanhang: det indikerar helt enkelt att du skickar förfrågningar för snabbt.
Det lämpliga svaret är inte att ge upp, utan att vänta innan du försöker igen. Exponentiell backoff är standardstrategin för att hantera denna situation.
Hur exponentiell backoff fungerar
Istället för att försöka igen omedelbart (vilket skulle utlösa ytterligare ett 429-fel), väntar du en ökande fördröjning mellan varje försök:
- 1:a misslyckandet: vänta 1 sekund
- 2:a misslyckandet: vänta 2 sekunder
- 3:e misslyckandet: vänta 4 sekunder
- 4:e misslyckandet: vänta 8 sekunder
- 5:e misslyckandet: ge upp
Fördröjningen fördubblas vid varje försök, därav termen “exponentiell”. Detta ger servern tid att återhämta kapacitet.
Manuell 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 (slumpmässig variation) är viktigt. Om flera korutiner får ett 429-fel samtidigt skulle de, utan jitter, alla försöka igen vid exakt samma tidpunkt, vilket utlöser ett nytt 429-fel. Jitter desynkroniserar försöken.
Användning av biblioteket tenacity
För produktionsmiljöer förenklar 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
Dekoreraren @retry fångar RateLimitError, väntar en exponentiell fördröjning (mellan 1 och 60 sekunder) och försöker upp till 5 gånger. Funktionskoden förblir ren och läsbar.
Kombinera backoff och semafor
I praktiken kombinerar du backoff med en semafor för fullständig kontroll:
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)
Semaforen förhindrar överbelastning av API:t, och backoff hanterar återstående 429-fel. Denna dubbla skyddsmekanism är den rekommenderade konfigurationen för produktion.
Anpassa backoff efter feltyp
Inte alla fel motiverar ett nytt försök. Här är 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-fel (hastighetsbegränsning), tidsöverskridanden och anslutningsfel förtjänar ett nytt försök. Ett BadRequestError (ogiltig prompt) löses dock inte genom att försöka igen.
Viktiga punkter
- Ett 429-fel är normalt och förväntat vid batchbearbetning
- Exponentiell backoff fördubblar fördröjningen mellan varje försök (1 s, 2 s, 4 s, 8 s…)
- Jitter desynkroniserar nya försök för att undvika kollisioner
- Biblioteket
tenacityförenklar implementeringen i produktion - Kombinera alltid semafor och backoff för maximal motståndskraft
- Försök inte igen vid felaktiga förfrågningsfel (
BadRequestError)