Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Exponentieller Backoff bei HTTP 429

Lektion 6 von 12 Aktualisiert am 30. Juli 2026 Fortgeschritten
Auf dieser Seite
  1. Verständnis des 429-Fehlers
  2. Funktionsweise des exponentiellen Backoffs
  3. Manuelle Implementierung
  4. Nutzung der tenacity-Bibliothek
  5. Kombination von Backoff und Semaphore
  6. Anpassung des Backoffs an den Fehlertyp
  7. Kernaussagen

Verständnis des 429-Fehlers

Ein HTTP 429-Fehler bedeutet, dass Sie die Rate-Limits der API überschritten haben. Der xAI-Server lehnt Ihre Anfragen vorübergehend ab, um die Infrastruktur zu schützen. Dieser Fehler ist im Kontext der Batch-Verarbeitung normal: Er zeigt lediglich an, dass Sie Anfragen zu schnell senden.

Die angemessene Reaktion besteht nicht darin, aufzugeben, sondern vor dem erneuten Versuch zu warten. Der exponentielle Backoff ist die Standardstrategie zur Handhabung dieser Situation.

Funktionsweise des exponentiellen Backoffs

Statt sofort erneut zu versuchen (was einen weiteren 429-Fehler auslösen würde), warten Sie zwischen jedem Versuch eine zunehmende Verzögerung:

    1. Misserfolg: 1 Sekunde warten
    1. Misserfolg: 2 Sekunden warten
    1. Misserfolg: 4 Sekunden warten
    1. Misserfolg: 8 Sekunden warten
    1. Misserfolg: Aufgabe

Die Verzögerung verdoppelt sich bei jedem Versuch, daher der Begriff „exponentiell”. Dies gibt dem Server Zeit, seine Kapazität wiederherzustellen.

Manuelle Implementierung

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  # letzter Versuch, Fehler weitergeben

            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"Warten {wait_time:.1f}s")
            await asyncio.sleep(wait_time)

Der jitter (zufällige Variation) ist wichtig. Wenn mehrere Koroutinen gleichzeitig einen 429-Fehler erhalten, würden sie ohne Jitter exakt zum selben Zeitpunkt erneut versuchen und einen weiteren 429 auslösen. Der Jitter desynchronisiert die Versuche.

Nutzung der tenacity-Bibliothek

Für den produktiven Einsatz vereinfacht die tenacity-Bibliothek die Implementierung:

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

Der @retry-Decorator fängt RateLimitError ab, wartet eine exponentielle Verzögerung (zwischen 1 und 60 Sekunden) und versucht bis zu 5 Mal erneut. Der Funktionscode bleibt dabei sauber und lesbar.

Kombination von Backoff und Semaphore

In der Praxis kombinieren Sie Backoff mit einem Semaphore für vollständige Kontrolle:

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)

Der Semaphore verhindert eine Überlastung der API, und der Backoff behandelt verbleibende 429-Fehler. Diese doppelte Absicherung ist die empfohlene Konfiguration für die Produktion.

Anpassung des Backoffs an den Fehlertyp

Nicht alle Fehler rechtfertigen einen erneuten Versuch. Hier ist eine Klassifizierung:

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  # Fehler im Prompt, erneuter Versuch sinnlos

429-Fehler (Rate Limit), Timeouts und Verbindungsfehler verdienen einen erneuten Versuch. Ein BadRequestError (ungültiger Prompt) wird jedoch durch erneutes Versuchen nicht behoben.

Kernaussagen

  • Ein 429-Fehler ist im Rahmen der Batch-Verarbeitung normal und zu erwarten
  • Der exponentielle Backoff verdoppelt die Verzögerung zwischen jedem Versuch (1s, 2s, 4s, 8s…)
  • Der Jitter desynchronisiert neue Versuche, um Kollisionen zu vermeiden
  • Die tenacity-Bibliothek vereinfacht die Implementierung in der Produktion
  • Kombinieren Sie immer Semaphore und Backoff für maximale Resilienz
  • Wiederholen Sie ungültige Anfragefehler (BadRequestError) nicht