Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Retry, eksponentiel backoff og circuit breaker

Lektion 14 af 22 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Retry, eksponentiel backoff og circuit breaker
  2. Eksponentiel backoff
  3. Brug af Tenacity-biblioteket
  4. Circuit Breaker-mønsteret
  5. Kombination af de tre mønstre
  6. Vigtige pointer

Retry, eksponentiel backoff og circuit breaker

Forbigående fejl er normale i produktion. OpenAI SDK håndterer automatisk to genforsøg, men for maksimal robusthed bør du implementere dine egne strategier. Den forrige lektion lærte dig at genkende fejl, der kan genforsøges; denne lærer dig at genforsøge intelligent – uden at gøre situationen, du forsøger at løse, værre.

Eksponentiel backoff

Princippet er simpelt: hvert genforsøg venter længere end det foregående. Dette forhindrer overbelastning af API’en, når den er under pres. Jitter fortjener særlig opmærksomhed, fordi fraværet heraf skaber en klassisk fejlmåde: halvtreds instanser af din tjeneste modtager en 429 på samme sekund, venter alle præcis ét sekund, genstarter derefter sammen og bliver igen afvist som en gruppe. Ved at tilføje en tilfældig forsinkelse spreder du denne genstart – det er kuren mod „thundering herd”-problemet.

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-kald med eksponentiel backoff og 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  # Sidste forsøg, propager fejlen

            # Eksponentiel backoff: 1s, 2s, 4s, 8s, 16s
            base_delay = 2 ** attempt

            # Tilfældig jitter for at undgå thundering herd
            jitter = random.uniform(0, base_delay * 0.5)
            delay = base_delay + jitter

            print(f"Forsøg {attempt + 1}/{max_retries} mislykkedes. "
                  f"Prøver igen om {delay:.1f}s...")
            time.sleep(delay)

    raise RuntimeError("Bør aldrig nå hertil")

# Brug
result = call_with_backoff("Forklar eksponentiel backoff.")
print(result)

Bemærk det sidste forsøg: vi propagerer den oprindelige fejl i stedet for at sluge den. Kalderen modtager dermed den rigtige diagnose – 429 eller 500 – og kan selv beslutte, hvad der skal gøres ved den.

Brug af Tenacity-biblioteket

At skrive denne løkke i hånden bliver hurtigt repetitivt, når du har fem funktioner, der skal beskyttes. Til mere avanceret styring af genforsøg er tenacity værktøjet af valg: dekoratøren erklærer politikken, og funktionskroppen indeholder kun kaldet til forretningslogikken. Du får de samme ingredienser, men navngivne og konfigurerbare – listen over undtagelser, der skal genforsøges, eksponentiel ventetid begrænset til tres sekunder, stop efter fem forsøg og automatisk logning før hver 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-kald med automatisk genforsøg via tenacity."""
    response = client.responses.create(
        model=model,
        input=prompt
    )
    return response.output_text

# Brug – genforsøg er transparente
result = resilient_call("Hej!")
print(result)

Circuit Breaker-mønsteret

Retry løser hændelser, der varer få sekunder. Det bliver skadeligt, når nedetiden varer længere: hver brugeranmodning bruger derefter fem forsøg og tredive sekunders ventetid før fejl, dine threads hobes op, og det er din egen tjeneste, der går ned. Circuit breaker forhindrer din applikation i fortsat at kalde en fejlramt API.

Den fungerer som en elektrisk afbryder med tre tilstande. Lukket (Closed): alt fungerer normalt, og kald går igennem. Åben (Open): API’en betragtes som nede, og kald blokeres øjeblikkeligt uden selv at forsøge netværket – brugeren modtager en fejl på millisekunder i stedet for efter en timeout. Halvåben (Half-open): når hvileperioden er udløbet, sendes et testkald for at tjekke, om API’en er tilbage: hvis det lykkes, lukkes kredsløbet; hvis det mislykkes, åbnes det igen for en ny cyklus.

import time
from enum import Enum

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

class CircuitBreaker:
    """Circuit breaker til API-kald."""

    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:
        """Tjekker om et kald er tilladt."""
        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  # Ét testkald
            return False

        # Half-open: kun ét kald tilladt
        return True

    def record_success(self):
        """Registrerer et succesfuldt kald."""
        self.consecutive_errors = 0
        self.state = CircuitState.CLOSED

    def record_error(self):
        """Registrerer en fejl."""
        self.consecutive_errors += 1
        self.last_error_time = time.monotonic()

        if self.consecutive_errors >= self.threshold:
            self.state = CircuitState.OPEN
            print(f"Kredsløb ÅBENT efter {self.threshold} på hinanden følgende fejl")

Fejltælleren nulstilles til nul, så snart et kald lykkes: det er på hinanden følgende fejl, der åbner kredsløbet, ikke en historisk kumulativ tælling. Integration på klientsiden reduceres derefter til tre trin – spørg om tilladelse, signalér succes, signalér fejl.

# Integration med OpenAI-klienten
circuit = CircuitBreaker(error_threshold=3, reset_timeout=30.0)

def call_with_circuit_breaker(prompt: str) -> str:
    """API-kald beskyttet af en circuit breaker."""
    if not circuit.can_call():
        raise RuntimeError(
            f"Kredsløb åbent – API utilgængelig. "
            f"Prøv igen om {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

# Brug
try:
    result = call_with_circuit_breaker("Hej!")
    print(result)
except RuntimeError as e:
    print(f"Fejl: {e}")

Kombination af de tre mønstre

I produktion kombinerer du backoff, circuit breaker og timeout. Bemærk konstruktøren: klienten oprettes med max_retries=0, hvilket deaktiverer SDK’ets interne genforsøg. Uden dette ville dine tre forsøg gange med SDK’ets to, og du ville vente meget længere end forventet. Timeout’en på tredive sekunder begrænser hvert enkelt kald, løkken håndterer genforsøg, og circuit breaker overvåger tjenestens samlede helbredstilstand.

class APIClient:
    """Robust API-klient, der kombinerer alle mønstre."""

    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("Tjeneste midlertidigt utilgængelig")

        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("Mislykkedes efter alle forsøg")

# Brug
api = APIClient()
print(api.call("Forklar robusthed i softwareudvikling."))

Før du går videre, skal du teste denne klient ved at simulere et nedbrud: afbryd netværket, start et dusin kald, og verificér, at de sidste fejler øjeblikkeligt i stedet for at vente. Hvis det ikke er tilfældet, er din tærskel for høj i forhold til det volumen, der behandles.

Vigtige pointer

  • SDK håndterer standardmæssigt 2 genforsøg – juster med max_retries
  • Eksponentiel backoff med jitter undgår „thundering herd”
  • Circuit breaker beskytter din applikation mod langvarige nedbrud
  • Brug tenacity til deklarativ styring af genforsøg i produktion
  • Kombinér alle tre mønstre for maksimal robusthed
  • Genforsøg aldrig 400/401/403-fejl (klientfejl)