Opakování, exponenciální backoff a jistič
Na této stránce
Opakování, exponenciální backoff a jistič
Přechodné chyby jsou v produkčním prostředí běžné. SDK OpenAI sice automaticky provádí dva pokusy o opakování, ale pro maximální odolnost bys měl implementovat vlastní strategie. Předchozí lekce tě naučila rozpoznávat chyby, které lze opakovat; tato tě naučí opakovat inteligentně – aniž bys situaci, kterou se snažíš napravit, ještě zhoršil.
Exponenciální backoff
Princip je jednoduchý: každé další opakování čeká déle než to předchozí. Tím zabráníš přetížení API, když je pod tlakem. Zvláštní pozornost si zaslouží „jitter“ (náhodné zpoždění), protože jeho absence vede ke klasickému režimu selhání: padesát instancí tvé služby obdrží ve stejnou sekundu chybu 429, všechny čekají přesně jednu sekundu, pak se všechny najednou restartují a jako skupina jsou opět odmítnuty. Přidáním náhodného zpoždění tento restart rozložíš – to je lék na efekt „hřmícího stáda“.
import time
import random
from openai import OpenAI, RateLimitError, InternalServerError, APIConnectionError
client = OpenAI()
def call_with_backoff(prompt: str, max_retries: int = 5) -> str:
"""Volání API s exponenciálním backoffem a jitterem."""
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 # Poslední pokus, předej chybu dál
# Exponenciální backoff: 1s, 2s, 4s, 8s, 16s
base_delay = 2 ** attempt
# Náhodný jitter k avoidance hřmícího stáda
jitter = random.uniform(0, base_delay * 0.5)
delay = base_delay + jitter
print(f"Pokus {attempt + 1}/{max_retries} selhal. "
f"Opakování za {delay:.1f}s...")
time.sleep(delay)
raise RuntimeError("Sem by se kód neměl nikdy dostat")
# Použití
result = call_with_backoff("Vysvětli exponenciální backoff.")
print(result)
Všimni si posledního pokusu: původní chybu přenášíme dál, místo abychom ji polykali. Volající tak získá skutečnou diagnostiku – 429 nebo 500 – a může se rozhodnout, co s ní dělat.
Použití knihovny Tenacity
Ruční psaní této smyčky se rychle stane opakujícím se úkolem, jakmile máš pět funkcí, které potřebuješ chránit. Pro pokročilejší správu opakování je nástrojem číslo jedna tenacity: dekorátor definuje politiku a tělo funkce obsahuje pouze volání obchodní logiky. Získáš stejné ingredience, ale pojmenované a konfigurovatelné – seznam výjimek pro opakování, exponenciální čekání omezené na šedesát sekund, ukončení po pěti pokusech a automatické logování před každou pauzou.
# 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:
"""Volání API s automatickým opakováním přes tenacity."""
response = client.responses.create(
model=model,
input=prompt
)
return response.output_text
# Použití — opakování jsou transparentní
result = resilient_call("Ahoj!")
print(result)
Vzorec jističe (Circuit Breaker)
Opakování řeší incidenty trvající několik sekund. Stává se však škodlivým, když výpadek trvá déle: každý uživatelský požadavek pak spotřebuje pět pokusů a třicet sekund čekání před selháním, vlákna se hromadí a nakonec padne tvá vlastní služba. Jistič zabrání tvé aplikaci v dalším volání nefungujícího API.
Funguje jako elektrický jistič se třemi stavy. Zavřeno (Closed): vše funguje normálně a požadavky procházejí. Otevřeno (Open): API je považováno za nefunkční a požadavky jsou okamžitě blokovány, aniž by se pokoušely o síť – uživatel obdrží chybu v milisekundách místo čekání na timeout. Polovičně otevřeno (Half-open): jakmile uplyne doba odpočinku, odešle se testovací požadavek, aby se zjistilo, zda je API opět funkční: pokud uspěje, obvod se uzavře; pokud selže, znovu se otevře pro nový cyklus.
import time
from enum import Enum
class CircuitState(Enum):
CLOSED = "closed"
OPEN = "open"
HALF_OPEN = "half_open"
class CircuitBreaker:
"""Jistič pro volání API."""
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:
"""Zkontroluje, zda je volání povoleno."""
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 # Jeden testovací požadavek
return False
# Half-open: povolen pouze jeden požadavek
return True
def record_success(self):
"""Zaznamená úspěšné volání."""
self.consecutive_errors = 0
self.state = CircuitState.CLOSED
def record_error(self):
"""Zaznamená selhání."""
self.consecutive_errors += 1
self.last_error_time = time.monotonic()
if self.consecutive_errors >= self.threshold:
self.state = CircuitState.OPEN
print(f"Jistič OTEVŘEN po {self.threshold} po sobě jdoucích chybách")
Počítadlo chyb se resetuje na nulu, jakmile jakýkoli požadavek uspěje: obvod otevírají až po sobě jdoucí selhání, nikoliv historický kumulativní součet. Integrace na straně klienta se pak redukuje na tři kroky – požádat o povolení, signalizovat úspěch, signalizovat selhání.
# Integrace s klientem OpenAI
circuit = CircuitBreaker(error_threshold=3, reset_timeout=30.0)
def call_with_circuit_breaker(prompt: str) -> str:
"""Volání API chráněné jističem."""
if not circuit.can_call():
raise RuntimeError(
f"Jistič otevřen — API nedostupné. "
f"Zkus to znovu za {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
# Použití
try:
result = call_with_circuit_breaker("Ahoj!")
print(result)
except RuntimeError as e:
print(f"Chyba: {e}")
Kombinace všech tří vzorců
V produkčním prostředí kombinuj backoff, jistič a timeout. Všimni si konstruktoru: klient je vytvořen s max_retries=0, což deaktivuje interní opakování SDK. Bez toho by se tvé tři pokusy násobily dvěma pokusy SDK a čekal bys mnohem déle, než očekáváš. Třicetisekundový timeout omezuje každé jednotlivé volání, smyčka řeší opakování a jistič monitoruje celkové zdraví služby.
class APIClient:
"""Odolný klient API kombinující všechny vzorce."""
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("Služba je dočasně nedostupná")
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("Selhání po všech pokusech")
# Použití
api = APIClient()
print(api.call("Vysvětli odolnost v softwarovém inženýrství."))
Než půjdeš dál, otestuj tohoto klienta simulací výpadku: odpoj síť, spusť tucet volání a ověř, že ta poslední selžou okamžitě, místo aby čekala. Pokud tomu tak není, je tvůj práh pro zpracovávaný objem příliš vysoký.
Klíčové poznatky
- SDK ve výchozím nastavení provádí 2 opakování – uprav pomocí
max_retries - Exponenciální backoff s jitterem zabraňuje efektu hřmícího stáda
- Jistič chrání tvou aplikaci před dlouhodobými výpadky
- Pro deklarativní správu opakování v produkci použij
tenacity - Pro maximální odolnost kombinuj všechny tři vzorce
- Nikdy neopakuj chyby 400/401/403 (chyby klienta)