Retry, eksponentiel backoff og circuit breaker
På denne side
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
tenacitytil deklarativ styring af genforsøg i produktion - Kombinér alle tre mønstre for maksimal robusthed
- Genforsøg aldrig 400/401/403-fejl (klientfejl)