Spring til hovedindhold
Dansk— Vælg et sprog
Menu

HTTP 429 og eksponentiel backoff

Lektion 3 af 14 Opdateret 29. juli 2026 Avanceret
På denne side
  1. Håndtering af overskridelse af grænser
  2. Hvad du ikke skal gøre
  3. Eksponentiel backoff
  4. Skalering: Regulér før du fejler
  5. Behandl 429 som en metrik
  6. Vigtige pointer

Håndtering af overskridelse af grænser

Så snart din applikation rammer sine grænser for RPM (forespørgsler per minut) eller TPM (tokens per minut), svarer Grok API’en med en HTTP 429-statuskode (Too Many Requests). Læs denne kode for det, den er: ikke et nedbrud, men et signal til flowkontrol. API’en siger „bremse farten”, ikke „det er i stykker”. Forskellen på en robust integration og en skrøbelig én afhænger af, hvordan din kode fortolker denne distinktion. En 429-fejl, der håndteres forkert, forbliver aldrig isoleret: den kaskaderer gennem køen, videre til de kaldende tjenester og ender som en hændelse, der er synlig for slutbrugeren.

Hvad du ikke skal gøre

Den instinktive reaktion, når en forespørgsel fejler, er at sende den igen med det samme. Det er præcis det forkerte træk. Du var allerede over din kvote; ved at sende igen øjeblikkeligt bruger du et ekstra kald, der også vil fejle, og du forlænger blokeringsperioden i stedet for at forkorte den. En uendelig gentagelse gør tingene værre ved at binde threads uden formål. Omvendt fratager det din bruger et resultat, der ville være kommet få sekunder senere, hvis du behandler 429 som en permanent fejl og giver op. Den rigtige tilgang ligger mellem de to: prøv igen, men vent, og vent længere hver gang.

Eksponentiel backoff

Princippet er at fordoble ventetiden efter hvert mislykket forsøg og tilføje en tilfældig variation kaldet jitter.

import time
import random

def call_with_retry(request, max_retries=5):
    for attempt in range(max_retries):
        response = send_request(request)

        if response.status_code != 429:
            return response

        base_delay = 2 ** attempt  # 1, 2, 4, 8, 16 seconds
        jitter = random.uniform(0, base_delay * 0.5)
        delay = base_delay + jitter

        time.sleep(delay)

    raise Exception("Retry limit reached")

Jitter fortjener opmærksomhed, fordi det er den linje, der oftest slettes under antagelse af, at den unødigt komplicerer koden. Forestil dig tredive instanser af din tjeneste, der modtager en 429 på samme sekund. Uden jitter beregner de alle den samme ventetid og prøver igen på nøjagtig samme tidspunkt: du har reproduceret belastningsspidsen identisk, ét sekund senere, så to, så fire. Dette er thundering herd-fænomenet. Tilfældiggørelse spreder forsøgene over tid og bryder denne ufrivillige synkronisering. Bemærk også, at basisventetiden starter ved ét sekund: gå aldrig under dette for det første forsøg.

Skalering: Regulér før du fejler

På en applikation med højt volumen er det ikke længere nok at reagere på 429’er; det er bedre at undgå dem. En rate limiter på klientsiden begrænser antallet af samtidige kald og håndhæver en minimumsafstand mellem afsendelser, så den udgående belastning holder sig under loftet i stedet for konstant at teste det.

import asyncio
from asyncio import Semaphore

# Limit to 25 requests/second (margin under the allowed 30 req/s)
semaphore = Semaphore(25)

async def limited_request(payload):
    async with semaphore:
        response = await send_request_async(payload)
        await asyncio.sleep(1.0 / 25)  # minimum spacing
        return response

Bemærk den bevidste margin: 25 forespørgsler per sekund i stedet for de tilladte 30. Denne reserve absorberer netværksuregelmæssigheder og trafikspidser uden nogensinde at ramme loftet.

Circuit breaker-en fuldender opsætningen ved at afbryde kald, når fejl ophobes. Mens den er lukket, passerer forespørgsler normalt. Efter et fastsat antal på hinanden følgende fejl åbner den og nægter lokalt alle forespørgsler i en konfigureret varighed: du holder op med at hamre løs på en API, der afviser dig, og dine threads forbliver tilgængelige for resten af applikationen. Når forsinkelsen udløber, skifter den til halvåben og lader én enkelt testforespørgsel passere; hvis den lykkes, genoptages normal trafik, ellers nulstilles tælleren. Denne mekanisme beskytter din tjeneste lige så meget som API’en i den anden ende.

Behandl 429 som en metrik

Én sidste refleks, der ofte mangler i integrationer: instrumentér 429-raten. Dette tal måler ikke kvaliteten af din gentagelseskode; det måler pasformen mellem dit abonnement og din faktiske trafik. En kurve, der stiger uge efter uge, signalerer underdimensionering længe før brugerne klager, og giver dig tid til at handle roligt – fordele belastningen, budgettere en opgradering af abonnementet – i stedet for at improvisere en fredag aften.

Vigtige pointer

  • HTTP 429-koden signalerer en overskridelse af grænser for RPM eller TPM
  • Eksponentiel backoff med jitter er den strategi, der anbefales af xAI
  • I produktion skal du supplere backoff med en rate limiter på klientsiden og en circuit breaker
  • Prøv aldrig igen med det samme: vent mindst 1 sekund før første gentagelse
  • Overvåg 429-raten i dine metrikker som en indikator på underdimensionering