Újrapróbálkozás, exponenciális visszalépés és megszakító áramkör
Ezen az oldalon
Újrapróbálkozás, exponenciális visszalépés és megszakító áramkör
Az átmeneti hibák teljesen normálisak éles környezetben. Az OpenAI SDK automatikusan kezel két újrapróbálkozást, de a maximális ellenállóképesség érdekében érdemes saját stratégiákat implementálnod. Az előző leckében megtanultad felismerni az újrapróbálható hibákat; ebben a leckében azt tanulod meg, hogyan próbáld újra intelligensen – anélkül, hogy rontanál a helyzeten, amit éppen megoldani próbálsz.
Exponenciális visszalépés
Az elv egyszerű: minden újrapróbálkozásnál tovább várunk, mint az előzőnél. Ez megakadályozza, hogy túlterheld az API-t, amikor az amúgy is nyomás alatt van. A „jitter“ (véletlenszerű ingadozás) külön figyelmet érdemel, mert hiánya egy klasszikus hibaforráshoz vezet: a szolgáltatásod ötven példánya egyszerre kap egy 429-es hibát, mind pontosan egy másodpercet vár, majd egyszerre indulnak újra, és csoportként ismét elutasítást kapnak. Véletlenszerű késleltetés hozzáadásával szétoszlatod ezeket az újraindításokat – ez a megoldás a „mennydörgő csorda“ (thundering herd) problémájára.
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 hívás exponenciális visszalépéssel és jitterrel."""
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 # Utolsó próbálkozás, továbbítjuk a hibát
# Exponenciális visszalépés: 1s, 2s, 4s, 8s, 16s
base_delay = 2 ** attempt
# Véletlenszerű jitter a mennydörgő csorda elkerülésére
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")
# Használat
result = call_with_backoff("Explain exponential backoff.")
print(result)
Figyeld meg az utolsó próbálkozást: az eredeti hibát továbbítjuk ahelyett, hogy elnyelnénk. Így a hívó fél megkapja a valós diagnosztikát – 429-es vagy 500-as hibát –, és eldöntheti, mit kezdjen vele.
A Tenacity könyvtár használata
Ha öt függvényt kell védened, ennek a ciklusnak a kézi megírása gyorsan ismétlődővé válik. A fejlettebb újrapróbálkozás-kezeléshez a tenacity a legjobb eszköz: a dekorátor deklarálja a szabályzatot, a függvény törzse pedig csak az üzleti logika hívását tartalmazza. Ugyanazokat az összetevőket kapod, de elnevezve és konfigurálhatóan – a újrapróbálandó kivételek listáját, a hatvan másodpercre korlátozott exponenciális várakozást, az öt próbálkozás utáni leállást, és az automatikus naplózást minden szünet előtt.
# 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 hívás automatikus újrapróbálkozással a tenacity segítségével."""
response = client.responses.create(
model=model,
input=prompt
)
return response.output_text
# Használat — az újrapróbálkozások transzparensek
result = resilient_call("Hello!")
print(result)
A megszakító áramkör (Circuit Breaker) minta
Az újrapróbálkozás megoldja a néhány másodpercig tartó incidenseket. Hosszabb kimaradás esetén azonban káros becomes: ekkor minden felhasználói kérés öt próbálkozást és harminc másodperc várakozást emészt fel a hiba előtt, a szálaid felhalmozódnak, és végül a saját szolgáltatásod dől be. A megszakító áramkör megakadályozza, hogy az alkalmazásod tovább hívjon egy hibás API-t.
Úgy működik, mint egy elektromos megszakító, három állapottal. Zárt (Closed): minden normálisan működik, a hívások áthaladnak. Nyitott (Open): az API leálltnek számít, a hívásokat azonnal blokkoljuk, még a hálózati kísérlet nélkül is – a felhasználó milliszekundumok alatt kap hibát a time-out helyett. Félig nyitott (Half-open): miután a pihenőidő letelt, küldünk egy teszthívást, hogy ellenőrizzük, visszatért-e az API: ha sikerül, az áramkör záródik; ha sikertelen, újra nyílik egy új ciklusra.
import time
from enum import Enum
class CircuitState(Enum):
CLOSED = "closed"
OPEN = "open"
HALF_OPEN = "half_open"
class CircuitBreaker:
"""Megszakító áramkör API hívásokhoz."""
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:
"""Ellenőrzi, hogy engedélyezett-e egy hívás."""
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 # Egy teszt hívás
return False
# Félig nyitott: csak egy hívás engedélyezett
return True
def record_success(self):
"""Sikeres hívást rögzít."""
self.consecutive_errors = 0
self.state = CircuitState.CLOSED
def record_error(self):
"""Sikertelenséget rögzít."""
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")
A hiba számláló nullára áll vissza, amint egy hívás sikerül: nem a történelmi, halmozott szám számít, hanem a zsinórban bekövetkezett hibák nyitják ki az áramkört. A kliens oldali integráció ezután három lépésre redukálódik: engedélyt kérni, sikert jelezni, hibát jelezni.
# Integráció az OpenAI klienssel
circuit = CircuitBreaker(error_threshold=3, reset_timeout=30.0)
def call_with_circuit_breaker(prompt: str) -> str:
"""API hívás megszakító áramkörrel védve."""
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
# Használat
try:
result = call_with_circuit_breaker("Hello!")
print(result)
except RuntimeError as e:
print(f"Error: {e}")
A három minta kombinálása
Éles környezetben kombináld a visszalépést, a megszakító áramkört és a time-outot. Figyeld meg a konstruktort: a klienst max_retries=0 paraméterrel hozzuk létre, ami letiltja az SDK belső újrapróbálkozásait. Enélkül a te három próbálkozásod megszorozódna az SDK két próbálkozásával, és a vártnál sokkal tovább várnál. A harminc másodperces time-out korlátozza az egyes hívásokat, a ciklus kezeli az újrapróbálkozásokat, a megszakító áramkör pedig a szolgáltatás általános egészségét figyeli.
class APIClient:
"""Ellenállóképes API kliens, amely egyesíti az összes mintát."""
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")
# Használat
api = APIClient()
print(api.call("Explain resilience in software engineering."))
Mielőtt továbblépnél, teszteld ezt a klienst egy kimaradás szimulálásával: vágd el a hálózatot, indíts el egy tucat hívást, és ellenőrizd, hogy az utolsók azonnal hibáznak-e várakozás helyett. Ha nem így történik, akkor a küszöbértéked túl magas a feldolgozott forgalomhoz képest.
Főbb megállapítások
- Az SDK alapértelmezetten 2 újrapróbálkozást kezel – állítsd be a
max_retriesparaméterrel - A jitterrel kiegészített exponenciális visszalépés elkerüli a mennydörgő csorda hatást
- A megszakító áramkör megvédi az alkalmazásodat a hosszan tartó kimaradásoktól
- Használd a
tenacitykönyvtárat a deklaratív újrapróbálkozás-kezeléshez éles környezetben - Kombináld mindhárom mintát a maximális ellenállóképesség érdekében
- Soha ne próbálj újra 400/401/403-as hibákat (kliens oldali hibák)