Ponovni poskusi, eksponentno zamikanje in odklopnik tokokroga
Na tej strani
Ponovni poskusi, eksponentno zamikanje in odklopnik tokokroga
Prehodne napake so v proizvodnem okolju običajne. OpenAI SDK samodejno opravi dva ponovna poskusa, toda za največjo odpornost moraš implementirati lastne strategije. Prejšnja lekcija te je naučila prepoznavati napake, ki jih je mogoče ponoviti; ta te bo naučila, kako jih pametno ponoviti – ne da bi poslabšal situacijo, ki jo poskušaš odpraviti.
Eksponentno zamikanje
Načelo je preprosto: vsak ponovni poskus čaka dlje kot prejšnji. To preprečuje preobremenitev API-ja, ko je ta pod pritiskom. Posebno pozornost si zasluži „jitter” (naključni odmik), saj njegova odsotnost povzroča klasičen način odpovedi: petdeset primerkov tvoje storitve isto sekundo prejme kodo 429, vsi čakajo točno eno sekundo, nato pa se vsi hkrati ponovno zaženejo in so kot skupina spet zavrnjeni. Z dodajanjem naključnega zamika razpršiš ta ponovni zagon – to je zdravilo za „thundering herd” (učinek črede).
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)
Opazi zadnji poskus: namesto da bi pogoltnili napako, jo posredujemo naprej. Klicatelj tako prejme pravo diagnostiko – 429 ali 500 – in se lahko sam odloči, kaj storiti z njo.
Uporaba knjižnice Tenacity
Ročno pisanje te zanke hitro postane ponavljajoče se opravilo, ko moraš zaščititi pet funkcij. Za naprednejše upravljanje ponovnih poskusov je tenacity pravo orodje: okrasek (dekorator) razglasi politiko, telo funkcije pa vsebuje le klic poslovne logike. Dobiš iste sestavine, vendar poimenovane in konfigurabilne – seznam izjem za ponovni poskus, eksponentno čakanje z zgornjo mejo šestdesetih sekund, ustavitev po petih poskusih in samodejno beleženje pred vsakim premorom.
# 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)
Vzorec odklopnika tokokroga (Circuit Breaker)
Ponovni poskusi rešujejo incidente, ki trajajo nekaj sekund. Postanejo škodljivi, ko izpad traja dlje: vsaka uporabniška zahteva takrat porabi pet poskusov in trideset sekund čakanja pred neuspehom, tvoji niti se kopičijo in na koncu odpove tvoja lastna storitev. Odklopnik tokokroga prepreči, da bi tvoja aplikacija še naprej klicala nedelujoči API.
Deluje kot električni odklopnik s tremi stanji. Zaprto (Closed): vse deluje normalno in klici potekajo skozi. Odprto (Open): API velja za nedelujočega in klici so takoj blokirani, brez poskusa omrežne povezave – uporabnik prejme napako v milisekundah namesto po časovni omejitvi. Polodprto (Half-open): ko poteče čas mirovanja, se pošlje testni klic, da se preveri, ali je API spet na voljo: če uspe, se tokokrog zapre; če ne uspe, se za nov cikel ponovno odpre.
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")
Števec napak se ponastavi na nič, takoj ko klic uspe: tokokrog odprejo zaporedne napake, ne zgodovinsko kumulativno število. Integracija na strani odjemalca se nato свede na tri korake – zaprosi za dovoljenje, sporoči uspeh, sporoči neuspeh.
# 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}")
Združevanje treh vzorcev
V proizvodnem okolju združi eksponentno zamikanje, odklopnik tokokroga in časovno omejitev. Opazi konstruktor: odjemalec je ustvarjen z max_retries=0, kar onemogoči notranje ponovne poskuse SDK-ja. Brez tega bi se tvoji trije poskusi pomnožili z dvema poskusoma SDK-ja in čakal bi veliko dlje, kot pričakuješ. Tridesetsekundna časovna omejitev omejuje vsak posamezen klic, zanka upravlja ponovne poskuse, odklopnik tokokroga pa spremlja splošno zdravje storitve.
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."))
Preden nadaljuješ, preizkusi tega odjemalca s simulacijo izpada: izklopi omrežje, zaženi ducat klicev in preveri, ali zadnji klici takoj odpovejo namesto čakanja. Če temu ni tako, je tvoj prag previsok za obdelano količino prometa.
Ključne ugotovitve
- SDK privzeto opravi 2 ponovna poskusa – prilagodi z
max_retries - Eksponentno zamikanje z jitterjem preprečuje učinek „thundering herd”
- Odklopnik tokokroga ščiti tvojo aplikacijo pred dolgotrajnimi izpadi
- Za deklarativno upravljanje ponovnih poskusov v proizvodnem okolju uporabi
tenacity - Za največjo odpornost združi vse tri vzorce
- Nikoli ne ponavljaj napak 400/401/403 (napake odjemalca)