Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Wiederholungsversuche, exponentieller Backoff und Circuit Breaker

Lektion 14 von 22 Aktualisiert am 29. Juli 2026 Entwickler
Auf dieser Seite
  1. Wiederholungsversuche, exponentieller Backoff und Circuit Breaker
  2. Exponentieller Backoff
  3. Verwendung der Tenacity-Bibliothek
  4. Das Circuit-Breaker-Muster
  5. Kombination der drei Muster
  6. Kernaussagen

Wiederholungsversuche, exponentieller Backoff und Circuit Breaker

Vorübergehende Fehler sind in der Produktion normal. Das OpenAI SDK behandelt automatisch zwei Wiederholungsversuche, doch für maximale Resilienz sollten Sie eigene Strategien implementieren. Die vorherige Lektion hat Sie darin unterwiesen, wiederholbare Fehler zu erkennen; diese Lektion lehrt Sie, intelligent zu wiederholen – ohne die Situation, die Sie beheben wollen, zu verschlimmern.

Exponentieller Backoff

Das Prinzip ist einfach: Jeder Wiederholungsversuch wartet länger als der vorherige. Dies verhindert, dass die API überlastet wird, wenn sie unter Druck steht. Jitter verdient besondere Aufmerksamkeit, da dessen Fehlen zu einem klassischen Fehlermodus führt: Fünfzig Instanzen Ihres Dienstes erhalten gleichzeitig eine 429, warten alle exakt eine Sekunde und starten dann gemeinsam neu, woraufhin sie als Gruppe erneut abgelehnt werden. Durch das Hinzufügen einer zufälligen Verzögerung verteilen Sie diesen Neustart – das ist das Mittel gegen den „Thundering Herd”.

import time
import random
from openai import OpenAI, RateLimitError, InternalServerError, APIConnectionError

client = OpenAI()

def call_with_backoff(prompt: str, max_retries: int = 5) -> str:
    """API-Aufruf mit exponentiellem Backoff und Jitter."""

    for attempt in range(max_retries):
        try:
            response = client.responses.create(
                model="gpt-5.6-terra",
                input=prompt
            )
            return response.output_text

        except (RateLimitError, InternalServerError, APIConnectionError) as e:
            if attempt == max_retries - 1:
                raise  # Letzter Versuch, Fehler weitergeben

            # Exponentieller Backoff: 1s, 2s, 4s, 8s, 16s
            base_delay = 2 ** attempt

            # Zufälliger Jitter, um den Thundering Herd zu vermeiden
            jitter = random.uniform(0, base_delay * 0.5)
            delay = base_delay + jitter

            print(f"Versuch {attempt + 1}/{max_retries} fehlgeschlagen. "
                  f"Wiederholung in {delay:.1f}s...")
            time.sleep(delay)

    raise RuntimeError("Hier sollte man nie ankommen")

# Verwendung
result = call_with_backoff("Erkläre exponentiellen Backoff.")
print(result)

Beachten Sie den letzten Versuch: Wir geben den ursprünglichen Fehler weiter, statt ihn zu verschlucken. Der Aufrufer erhält somit die echte Diagnose – 429 oder 500 – und kann entscheiden, was er damit tun soll.

Verwendung der Tenacity-Bibliothek

Diesen Schleifen-Code von Hand zu schreiben, wird schnell repetitiv, sobald Sie fünf Funktionen schützen müssen. Für eine fortgeschrittene Wiederholungsmanagement bietet tenacity das Standardwerkzeug: Der Dekorator deklariert die Politik, und der Funktionskörper enthält nur den geschäftlichen Aufruf. Sie erhalten dieselben Zutaten, aber benannt und konfigurierbar – die Liste der auszuführenden Ausnahmen, exponentielle Wartezeit mit einer Obergrenze von 60 Sekunden, Beendigung nach fünf Versuchen und automatische Protokollierung vor jeder Pause.

# pip install tenacity
from tenacity import (
    retry,
    stop_after_attempt,
    wait_exponential,
    retry_if_exception_type,
    before_sleep_log,
)
from openai import RateLimitError, InternalServerError, APIConnectionError
import logging

logger = logging.getLogger(__name__)

@retry(
    retry=retry_if_exception_type(
        (RateLimitError, InternalServerError, APIConnectionError)
    ),
    wait=wait_exponential(multiplier=1, min=1, max=60),
    stop=stop_after_attempt(5),
    before_sleep=before_sleep_log(logger, logging.WARNING),
)
def resilient_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
    """API-Aufruf mit automatischer Wiederholung über tenacity."""
    response = client.responses.create(
        model=model,
        input=prompt
    )
    return response.output_text

# Verwendung – Wiederholungen sind transparent
result = resilient_call("Hallo!")
print(result)

Das Circuit-Breaker-Muster

Wiederholungsversuche lösen Vorfälle, die nur wenige Sekunden dauern. Sie werden schädlich, wenn die Ausfallzeit länger ist: Jeder Benutzeranruf verbraucht dann fünf Versuche und 30 Sekunden Wartezeit, bevor er fehlschlägt, Ihre Threads stapeln sich, und Ihr eigener Dienst geht aus. Der Circuit Breaker verhindert, dass Ihre Anwendung weiterhin einen fehlerhaften API-Dienst aufruft.

Er funktioniert wie ein elektrischer Sicherungsautomat mit drei Zuständen. Geschlossen, alles funktioniert normal und Aufrufe werden durchgelassen. Offen, der API-Dienst gilt als ausgefallen, und Aufrufe werden sofort blockiert, ohne dass das Netzwerk überhaupt versucht wird – der Benutzer erhält einen Fehler in Millisekunden statt nach einem Timeout. Halboffen, sobald die Ruhephase abgelaufen ist, wird ein Testaufruf gesendet, um zu prüfen, ob der API-Dienst zurück ist: Wenn er erfolgreich ist, schließt sich der Circuit; wenn er fehlschlägt, öffnet er sich für einen neuen Zyklus.

import time
from enum import Enum

class CircuitState(Enum):
    CLOSED = "closed"
    OPEN = "open"
    HALF_OPEN = "half_open"

class CircuitBreaker:
    """Circuit Breaker für API-Aufrufe."""

    def __init__(self, error_threshold: int = 5, reset_timeout: float = 30.0):
        self.threshold = error_threshold
        self.reset_timeout = reset_timeout
        self.consecutive_errors = 0
        self.state = CircuitState.CLOSED
        self.last_error_time = 0.0

    def can_call(self) -> bool:
        """Prüft, ob ein Aufruf erlaubt ist."""
        if self.state == CircuitState.CLOSED:
            return True

        if self.state == CircuitState.OPEN:
            if time.monotonic() - self.last_error_time > self.reset_timeout:
                self.state = CircuitState.HALF_OPEN
                return True  # Ein Testaufruf
            return False

        # Halboffen: Nur ein Aufruf erlaubt
        return True

    def record_success(self):
        """Protokolliert einen erfolgreichen Aufruf."""
        self.consecutive_errors = 0
        self.state = CircuitState.CLOSED

    def record_error(self):
        """Protokolliert einen Fehler."""
        self.consecutive_errors += 1
        self.last_error_time = time.monotonic()

        if self.consecutive_errors >= self.threshold:
            self.state = CircuitState.OPEN
            print(f"Circuit OFFEN nach {self.threshold} aufeinanderfolgenden Fehlern")

Der Fehlerzähler wird auf Null zurückgesetzt, sobald ein Aufruf erfolgreich ist: Es sind aufeinanderfolgende Fehler, die den Circuit öffnen, nicht eine historische kumulative Anzahl. Die Integration auf Client-Seite reduziert sich dann auf drei Schritte – um Erlaubnis bitten, Erfolg signalisieren, Fehler signalisieren.

# Integration mit dem OpenAI-Client
circuit = CircuitBreaker(error_threshold=3, reset_timeout=30.0)

def call_with_circuit_breaker(prompt: str) -> str:
    """API-Aufruf, der durch einen Circuit Breaker geschützt ist."""
    if not circuit.can_call():
        raise RuntimeError(
            f"Circuit offen — API nicht verfügbar. "
            f"Wiederholung in {circuit.reset_timeout}s"
        )

    try:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=prompt
        )
        circuit.record_success()
        return response.output_text

    except (RateLimitError, InternalServerError, APIConnectionError) as e:
        circuit.record_error()
        raise

# Verwendung
try:
    result = call_with_circuit_breaker("Hallo!")
    print(result)
except RuntimeError as e:
    print(f"Fehler: {e}")

Kombination der drei Muster

In der Produktion kombinieren Sie Backoff, Circuit Breaker und Timeout. Beachten Sie den Konstruktor: Der Client wird mit max_retries=0 erstellt, was die internen Wiederholungsversuche des SDK deaktiviert. Ohne dies würden Ihre drei Versuche mit den zwei des SDK multipliziert, und Sie würden viel länger als erwartet warten. Die 30-Sekunden-Timeout begrenzt jeden einzelnen Aufruf, die Schleife behandelt die Wiederholungsversuche, und der Circuit Breaker überwacht die allgemeine Gesundheit des Dienstes.

class APIClient:
    """Resilienter API-Client, der alle Muster kombiniert."""

    def __init__(self):
        self.client = OpenAI(timeout=30.0, max_retries=0)
        self.circuit = CircuitBreaker(error_threshold=5, reset_timeout=60.0)

    def call(self, prompt: str, max_retries: int = 3) -> str:
        if not self.circuit.can_call():
            raise RuntimeError("Dienst vorübergehend nicht verfügbar")

        for attempt in range(max_retries):
            try:
                response = self.client.responses.create(
                    model="gpt-5.6-terra",
                    input=prompt
                )
                self.circuit.record_success()
                return response.output_text

            except (RateLimitError, InternalServerError) as e:
                self.circuit.record_error()

                if attempt < max_retries - 1:
                    delay = (2 ** attempt) + random.uniform(0, 1)
                    time.sleep(delay)
                else:
                    raise

        raise RuntimeError("Nach allen Versuchen fehlgeschlagen")

# Verwendung
api = APIClient()
print(api.call("Erkläre Resilienz in der Softwareentwicklung."))

Bevor Sie fortfahren, testen Sie diesen Client, indem Sie einen Ausfall simulieren: Trennen Sie das Netzwerk, starten Sie ein Dutzend Aufrufe und überprüfen Sie, ob die letzten sofort fehlschlagen, anstatt zu warten. Wenn dies nicht der Fall ist, ist Ihre Schwelle für das zu verarbeitende Volumen zu hoch.

Kernaussagen

  • Das SDK behandelt standardmäßig 2 Wiederholungsversuche – passen Sie dies mit max_retries an
  • Exponentieller Backoff mit Jitter vermeidet den Thundering Herd
  • Der Circuit Breaker schützt Ihre Anwendung vor längeren Ausfällen
  • Verwenden Sie tenacity für deklaratives Wiederholungsmanagement in der Produktion
  • Kombinieren Sie alle drei Muster für maximale Resilienz
  • Wiederholen Sie niemals 400/401/403-Fehler (Client-Fehler)