Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Exponentiell backoff vid HTTP 429

Lektion 6 av 12 Uppdaterad 30 juli 2026 Avancerad
På denna sida
  1. Förståelse för felkoden 429
  2. Hur exponentiell backoff fungerar
  3. Manuell implementering
  4. Användning av biblioteket tenacity
  5. Kombinera backoff och semafor
  6. Anpassa backoff efter feltyp
  7. Viktiga punkter

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 tenacity fö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)