Ponovni pokušaji, eksponencijalno povlačenje i prekidač kruga
Na ovoj stranici
Ponovni pokušaji, eksponencijalno povlačenje i prekidač kruga
Prolazne greške su u produkciji sasvim normalne. OpenAI SDK automatski obrađuje dva ponovna pokušaja, no za maksimalnu otpornost trebao bi implementirati vlastite strategije. Prethodna lekcija naučila te je prepoznavati greške koje valja ponoviti; ova te uči kako to učiniti pametno—bez pogoršavanja situacije koju pokušavaš popraviti.
Eksponencijalno povlačenje (Exponential Backoff)
Princip je jednostavan: svaki ponovni pokušaj čeka dulje od prethodnog. Time se sprječava preopterećenje API-ja kada je pod pritiskom. Jitter (nasumično kašnjenje) zaslužuje posebnu pozornost jer njegovo odsustvo uzrokuje klasični način otkaza: pedeset instanci tvoje usluge primi kod 429 u istoj sekundi, sve čekaju točno jednu sekundu, zatim se sve zajedno ponovno pokrenu i budu odbijene kao grupa. Dodavanjem nasumičnog kašnjenja raspoređuješ ta ponovna pokretanja—to je lijek za efekt „grmljavinskog krda“ (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 call with exponential backoff and 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 # Last attempt, propagate the error
# Exponential backoff: 1s, 2s, 4s, 8s, 16s
base_delay = 2 ** attempt
# Random jitter to avoid thundering herd
jitter = random.uniform(0, base_delay * 0.5)
delay = base_delay + jitter
print(f"Attempt {attempt + 1}/{max_retries} failed. "
f"Retrying in {delay:.1f}s...")
time.sleep(delay)
raise RuntimeError("Should never reach here")
# Usage
result = call_with_backoff("Explain exponential backoff.")
print(result)
Obrati pažnju na konačni pokušaj: prosljeđujemo izvornu grešku umjesto da je progutamo. Pozivatelj tako dobiva pravu dijagnostiku—429 ili 500—i može odlučiti što učiniti s njom.
Korištenje biblioteke Tenacity
Ručno pisanje ove petlje brzo postaje repetitivno čim imaš pet funkcija koje trebaš zaštititi. Za naprednije upravljanje ponovnim pokušajima, tenacity je alat po izboru: dekorator deklarira politiku, a tijelo funkcije sadrži samo poziv poslovne logike. Dobivaš iste sastojke, ali imenovane i konfigurabilne—popis iznimki za ponovni pokušaj, eksponencijalno čekanje ograničeno na šezdeset sekundi, zaustavljanje nakon pet pokušaja i automatsko bilježenje prije svake pauze.
# 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 call with automatic retry via tenacity."""
response = client.responses.create(
model=model,
input=prompt
)
return response.output_text
# Usage — retries are transparent
result = resilient_call("Hello!")
print(result)
Uzorak prekidača kruga (Circuit Breaker)
Ponovni pokušaji rješavaju incidente koji traju nekoliko sekundi. Postaju štetni kada prekid traje dulje: svaki korisnički zahtjev tada troši pet pokušaja i trideset sekundi čekanja prije neuspjeha, tvoji threadovi se gomilaju i na kraju pada tvoja vlastita usluga. Prekidač kruga sprječava tvoju aplikaciju da nastavi zvati API koji ne radi.
Radi poput električnog prekidača kruga, s tri stanja. Zatvoreno (Closed), sve radi normalno i pozivi prolaze. Otvoreno (Open), API se smatra nedostupnim i pozivi se odmah blokiraju, bez pokušaja mrežnog poziva—korisnik prima grešku u milisekundama umjesto nakon isteka vremena. Poluotvoreno (Half-open), nakon što protekne razdoblje odmora, šalje se testni poziv kako bi se provjerilo je li API ponovno dostupan: ako uspije, krug se zatvara; ako ne uspije, ponovno se otvara za novi ciklus.
import time
from enum import Enum
class CircuitState(Enum):
CLOSED = "closed"
OPEN = "open"
HALF_OPEN = "half_open"
class CircuitBreaker:
"""Circuit breaker for API calls."""
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:
"""Checks if a call is allowed."""
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 # One test call
return False
# Half-open: only one call allowed
return True
def record_success(self):
"""Records a successful call."""
self.consecutive_errors = 0
self.state = CircuitState.CLOSED
def record_error(self):
"""Records a failure."""
self.consecutive_errors += 1
self.last_error_time = time.monotonic()
if self.consecutive_errors >= self.threshold:
self.state = CircuitState.OPEN
print(f"Circuit OPEN after {self.threshold} consecutive errors")
Brojač greški resetira se na nulu čim poziv uspije: krug otvaraju uzastopni neuspjesi, a ne povijesni kumulativni zbroj. Integracija na strani klijenta svodi se na tri koraka—zatraži dopuštenje, signaliziraj uspjeh, signaliziraj neuspjeh.
# Integration with the OpenAI client
circuit = CircuitBreaker(error_threshold=3, reset_timeout=30.0)
def call_with_circuit_breaker(prompt: str) -> str:
"""API call protected by a circuit breaker."""
if not circuit.can_call():
raise RuntimeError(
f"Circuit open — API unavailable. "
f"Retry 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
# Usage
try:
result = call_with_circuit_breaker("Hello!")
print(result)
except RuntimeError as e:
print(f"Error: {e}")
Kombiniranje triju uzoraka
U produkciji kombiniraj povlačenje, prekidač kruga i vremensko ograničenje (timeout). Obrati pažnju na konstruktor: klijent se stvara s max_retries=0, što onemogućuje interne ponovne pokušaje SDK-a. Bez ovoga, tvoja tri pokušaja bi se pomnožila s dva iz SDK-a i čekao bi mnogo dulje nego što očekuješ. Vremensko ograničenje od trideset sekundi ograničava svaki pojedinačni poziv, petlja obrađuje ponovne pokušaje, a prekidač kruga prati opće zdravstveno stanje usluge.
class APIClient:
"""Resilient API client combining all patterns."""
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("Service temporarily unavailable")
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("Failed after all attempts")
# Usage
api = APIClient()
print(api.call("Explain resilience in software engineering."))
Prije nego što nastaviš, testiraj ovog klijenta simuliranjem prekida: isključi mrežu, pokreni desetak poziva i provjeri da posljednji ne uspiju trenutno umjesto da čekaju. Ako to nije slučaj, tvoj prag je previsok za volumen koji se obrađuje.
Ključne točke
- SDK prema zadanim postavkama obrađuje 2 ponovna pokušaja — prilagodi s
max_retries - Eksponencijalno povlačenje s jitterom izbjegava efekt grmljavinskog krda
- Prekidač kruga štiti tvoju aplikaciju od dugotrajnih prekida
- Koristi
tenacityza deklarativno upravljanje ponovnim pokušajima u produkciji - Kombiniraj sva tri uzorka za maksimalnu otpornost
- Nikada ne ponavljaj greške 400/401/403 (greške klijenta)