Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Eksponentiel backoff ved HTTP 429

Lektion 6 af 12 Opdateret 30. juli 2026 Avanceret
På denne side
  1. Forståelse af 429-fejlen
  2. Hvordan eksponentiel backoff fungerer
  3. Manuel implementering
  4. Brug af biblioteket tenacity
  5. Kombination af backoff og semaphore
  6. Tilpasning af backoff til fejltype
  7. Vigtige pointer

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:

    1. fejl: vent 1 sekund
    1. fejl: vent 2 sekunder
    1. fejl: vent 4 sekunder
    1. fejl: vent 8 sekunder
    1. 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 tenacity forenkler implementeringen i produktion
  • Kombiner altid semaphore og backoff for maksimal robusthed
  • Undgå at gentage anmodninger med ugyldige fejl (BadRequestError)