Retry, Exponential Backoff och Circuit Breaker
På denna sida
Retry, Exponential Backoff och Circuit Breaker
Övergående fel är normala i produktion. OpenAI SDK hanterar automatiskt två försök, men för maximal robusthet bör du implementera dina egna strategier. Föregående lektion lärde dig att känna igen fel som går att försöka igen; denna lär dig att göra det intelligent – utan att förvärra situationen du försöker lösa.
Exponential Backoff
Principen är enkel: varje nytt försök väntar längre än det föregående. Detta förhindrar att API:t överbelastas när det redan är pressat. Jitter förtjänar särskild uppmärksamhet eftersom avsaknaden av detta leder till ett klassiskt felmode: femtio instanser av din tjänst får en 429 vid samma sekund, alla väntar exakt en sekund, startar sedan om samtidigt och blir återigen avvisade som en grupp. Genom att lägga till en slumpmässig fördröjning sprider du ut denna omstart – det är botemedlet mot »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-anrop med exponential backoff och 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 # Sista försöket, propagera felet
# Exponential backoff: 1s, 2s, 4s, 8s, 16s
base_delay = 2 ** attempt
# Slumpmässig jitter för att undvika thundering herd
jitter = random.uniform(0, base_delay * 0.5)
delay = base_delay + jitter
print(f"Försök {attempt + 1}/{max_retries} misslyckades. "
f"Försöker igen om {delay:.1f}s...")
time.sleep(delay)
raise RuntimeError("Bör aldrig nås")
# Användning
result = call_with_backoff("Förklara exponential backoff.")
print(result)
Lägg märke till det sista försöket: vi propagerar det ursprungliga felet istället för att svälja det. Anroparen får därmed den verkliga diagnosen – 429 eller 500 – och kan själv besluta vad som ska göras.
Använda biblioteket Tenacity
Att skriva denna loop för hand blir snabbt repetitivt när du har fem funktioner att skydda. För mer avancerad hantering av försök är tenacity verktyget att föredra: dekoratorn deklarerar policyn och funktionskroppen innehåller endast affärslogiken. Du får samma ingredienser, men namngivna och konfigurerbara – listan över undantag att försöka igen, exponentiell väntetid capad vid sextio sekunder, stopp efter fem försök och automatisk loggning före varje paus.
# 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-anrop med automatiskt försök via tenacity."""
response = client.responses.create(
model=model,
input=prompt
)
return response.output_text
# Användning – försöken är transparenta
result = resilient_call("Hej!")
print(result)
Circuit Breaker-mönstret
Retry löser incidenter som varar i några sekunder. Det blir skadligt när avbrottet varar längre: varje användarförfrågan konsumerar då fem försök och trettio sekunders väntan innan det misslyckas, dina trådar hopar sig och det är din egen tjänst som kraschar. Circuit breakern förhindrar att din applikation fortsätter anropa ett API som inte fungerar.
Den fungerar som en elektrisk säkring med tre tillstånd. Closed (stängd): allt fungerar normalt och anrop passerar. Open (öppen): API:t anses vara nere och anrop blockeras omedelbart, utan att ens försöka nå nätverket – användaren får ett fel på millisekunder istället för efter en timeout. Half-open (halvöppen): när viloperioden har löpt skickas ett testanrop för att kontrollera om API:t är tillbaka: lyckas det stängs kretsen; misslyckas den öppnas den igen för en ny cykel.
import time
from enum import Enum
class CircuitState(Enum):
CLOSED = "closed"
OPEN = "open"
HALF_OPEN = "half_open"
class CircuitBreaker:
"""Circuit breaker för API-anrop."""
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:
"""Kontrollerar om ett anrop är tillåtet."""
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 # Ett testanrop
return False
# Half-open: endast ett anrop tillåtet
return True
def record_success(self):
"""Registrerar ett lyckat anrop."""
self.consecutive_errors = 0
self.state = CircuitState.CLOSED
def record_error(self):
"""Registrerar ett misslyckande."""
self.consecutive_errors += 1
self.last_error_time = time.monotonic()
if self.consecutive_errors >= self.threshold:
self.state = CircuitState.OPEN
print(f"Kretsen ÖPPEN efter {self.threshold} på varandra följande fel")
Felräknaren nollställs så snart ett anrop lyckas: det är på varandra följande fel som öppnar kretsen, inte en historisk kumulativ summa. Integrationen på klientsidan reduceras sedan till tre steg – be om tillstånd, signalera framgång, signalera misslyckande.
# Integration med OpenAI-klienten
circuit = CircuitBreaker(error_threshold=3, reset_timeout=30.0)
def call_with_circuit_breaker(prompt: str) -> str:
"""API-anrop skyddat av en circuit breaker."""
if not circuit.can_call():
raise RuntimeError(
f"Kretsen öppen — API:t ej tillgängligt. "
f"Försök 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
# Användning
try:
result = call_with_circuit_breaker("Hej!")
print(result)
except RuntimeError as e:
print(f"Fel: {e}")
Kombinera de tre mönstren
I produktion kombinerar du backoff, circuit breaker och timeout. Lägg märke till konstruktorn: klienten skapas med max_retries=0, vilket inaktiverar SDK:ts interna försök. Utan detta skulle dina tre försök multipliceras med SDK:ts två, och du skulle vänta mycket längre än förväntat. Trettio sekunders timeout begränsar varje enskilt anrop, loopen hanterar försöken och circuit breakern övervakar tjänstens övergripande hälsa.
class APIClient:
"""Robust API-klient som kombinerar alla mönster."""
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("Tjänsten tillfälligt ej tillgänglig")
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("Misslyckades efter alla försök")
# Användning
api = APIClient()
print(api.call("Förklara robusthet inom mjukvaruutveckling."))
Innan du går vidare, testa denna klient genom att simulera ett avbrott: bryt nätverket, starta ett dussin anrop och verifiera att de sista misslyckas omedelbart istället för att vänta. Om så inte är fallet är din tröskel för hög för den volym som bearbetas.
Viktiga punkter
- SDK hanterar 2 försök som standard – justera med
max_retries - Exponential backoff med jitter undviker »thundering herd«
- Circuit breakern skyddar din applikation mot långvariga avbrott
- Använd
tenacityför deklarativ hantering av försök i produktion - Kombinera alla tre mönstren för maximal robusthet
- Försök aldrig igen vid 400/401/403-fel (klientfel)