Kordusproovid, eksponentsiaalne tagasitõmbumine ja voolukatkesti
Sellel lehel
Kordusproovid, eksponentsiaalne tagasitõmbumine ja voolukatkesti
Mööduvad vead on tootmiskeskkonnas tavalised. OpenAI SDK haldab automaatselt kahte kordusproovi, kuid maksimaalse töökindluse tagamiseks peaksid rakendama oma strateegiaid. Eelmises õppetükis õppisid tundma korratavaid vigu; selles õpid proove targalt sooritama – ilma olukorda, mida püüad parandada, halvemaks muutmata.
Eksponentsiaalne tagasitõmbumine
Põhimõte on lihtne: iga järgmine kordus ootab eelmisest kauem. See hoiab ära API ülekoormamise, kui see on surve all. Jitter (juhuslik viivitus) väärib erilist tähelepanu, sest selle puudumine põhjustab klassikalise tõrkeolukorra: viiskümmend sinu teenuse eksemplari saavad samal sekundil veakoodi 429, kõik ootavad täpselt ühe sekundi, taaskäivituvad siis koos ja lükatakse taas grupina tagasi. Juhusliku viivituse lisamisega hajutad selle taaskäivituse – see on lahendus „müriseva karja“ (thundering herd) probleemile.
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 väljakutse eksponentsiaalse tagasitõmbumise ja jitteriga."""
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 # Viimane katse, edasta viga
# Eksponentsiaalne tagasitõmbumine: 1s, 2s, 4s, 8s, 16s
base_delay = 2 ** attempt
# Juhuslik jitter müriseva karja vältimiseks
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")
# Kasutus
result = call_with_backoff("Explain exponential backoff.")
print(result)
Pane tähele viimast katset: edastame algse vea selle neelamise asemel. Seega saab väljakutsuja tegeliku diagnostika – 429 või 500 – ja saab otsustada, mida sellega ette võtta.
Tenacity teegi kasutamine
Selle tsükli käsitsi kirjutamine muutub kiiresti korduvaks, kui sul on kaitsta viis funktsiooni. Täiustatud kordushalduse jaoks on tenacity õige tööriist: dekorator deklareerib poliitika ja funktsiooni keha sisaldab ainult äriloogika väljakutset. Saad samad koostisosad, kuid nimetatud ja konfigureeritavana – erandite loend, mida korrata, eksponentsiaalne ooteaeg, mis on piiratud kuuekümne sekundiga, peatumine pärast viit katset ja automaatne logimine enne iga pausi.
# 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 väljakutse automaatse kordusega läbi tenacity."""
response = client.responses.create(
model=model,
input=prompt
)
return response.output_text
# Kasutus – kordused on läbipaistvad
result = resilient_call("Hello!")
print(result)
Voolukatkesti muster
Kordusproovid lahendavad mõne sekundi kestvaid intsidente. Need muutuvad kahjulikuks, kui katkestus kestab kauem: iga kasutaja päring tarbib siis viis katset ja kolmkümmend sekundit ootamist enne ebaõnnestumist, sinu lõimed kuhjuvad ja lõpuks kukub kokku sinu enda teenus. Voolukatkesti takistab sinu rakendusel jätkamast ebaõnnestuva API kutsumist.
See toimib nagu elektriline voolukatkesti, kolme olekuga. Suletud (Closed): kõik toimib normaalselt ja väljakutsed pääsevad läbi. Avatud (Open): API loetakse maas olevaks ja väljakutsed blokeeritakse koheselt, isegi võrku püüdmata – kasutaja saab vea millisekundite jooksul, mitte pärast aegumist. Pool-avatud (Half-open): kui puhkeaeg on möödunud, saadetakse testväljakutse kontrollimaks, kas API on taastunud: kui see õnnestub, sulgeb vooluahel; kui ebaõnnestub, avaneb see uueks tsükliks.
import time
from enum import Enum
class CircuitState(Enum):
CLOSED = "closed"
OPEN = "open"
HALF_OPEN = "half_open"
class CircuitBreaker:
"""API väljakutsete voolukatkesti."""
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:
"""Kontrollib, kas väljakutse on lubatud."""
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 # Üks testväljakutse
return False
# Pool-avatud: lubatud on ainult üks väljakutse
return True
def record_success(self):
"""Salvestab eduka väljakutse."""
self.consecutive_errors = 0
self.state = CircuitState.CLOSED
def record_error(self):
"""Salvestab ebaõnnestumise."""
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")
Vealoendur lähtestatakse nulliks niipea, kui väljakutse õnnestub: vooluahela avavad järjestikused ebaõnnestumised, mitte ajalooline kumulatiivne arv. Kliendipoolne integreerimine taandub siis kolmele sammule – küsi luba, anna märku edust, anna märku ebaõnnestumisest.
# Integreerimine OpenAI kliendiga
circuit = CircuitBreaker(error_threshold=3, reset_timeout=30.0)
def call_with_circuit_breaker(prompt: str) -> str:
"""Voolukatkestiga kaitstud API väljakutse."""
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
# Kasutus
try:
result = call_with_circuit_breaker("Hello!")
print(result)
except RuntimeError as e:
print(f"Error: {e}")
Kolme mustri kombineerimine
Tootmiskeskkonnas kombineeri tagasitõmbumine, voolukatkesti ja aegumine. Pane tähele konstruktorit: klient luuakse parameetriga max_retries=0, mis lülitab SDK sisemised kordused välja. Ilma selleta korrutuksid sinu kolm katset SDK kahega ja ootaksid palju kauem kui oodatud. Kolmekümne sekundi pikkune aegumine piirab iga üksikut väljakutset, tsükkel haldab kordusi ja voolukatkesti jälgib teenuse üldist tervist.
class APIClient:
"""Kõiki mustreid ühendav töökindel API klient."""
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")
# Kasutus
api = APIClient()
print(api.call("Explain resilience in software engineering."))
Enne edasiliikumist testi seda klienti, simuleerides katkestust: lõika võrk lahti, käivita tosin väljakutset ja veendu, et viimased ebaõnnestuvad koheselt, ootamise asemel. Kui see nii ei ole, on sinu lävi töödeldava mahu jaoks liiga kõrge.
Peamised punktid
- SDK haldab vaikimisi 2 kordust – kohanda seda parameetriga
max_retries - Eksponentsiaalne tagasitõmbumine koos jitteriga hoiab ära müriseva karja
- Voolukatkesti kaitseb sinu rakendust pikaajaliste katkestuste eest
- Kasuta tootmiskeskkonnas deklaratiiivseks kordushalduseks teeki
tenacity - Maksimaalse töökindluse saavutamiseks kombineeri kõiki kolme mustrit
- Ära kunagi korda vigu 400/401/403 (kliendivead)