Atkārtoti mēģinājumi, eksponenciāla atkāpe un ķēdes pārtraucējs
Šajā lapā
Atkārtoti mēģinājumi, eksponenciāla atkāpe un ķēdes pārtraucējs
Pārejošas kļūdas ražošanas vidē ir norma. OpenAI SDK automātiski veic divus atkārtotus mēģinājumus, taču, lai nodrošinātu maksimālu noturību, tev vajadzētu ieviest savas stratēģijas. Iepriekšējā nodarbībā tu iemācījies atpazīt kļūdas, kuras vērts atkārtot; šajā tu apgūsi, kā veikt atkārtotus mēģinājumus gudri — nepasliktinot situāciju, kuru cenšies novērst.
Eksponenciāla atkāpe
Princips ir vienkāršs: katrs nākamais mēģinājums gaida ilgāk nekā iepriekšējais. Tas novērš API pārslodzi brīžos, kad tas ir noslogots. Īpaša uzmanība jāpievērš „jitter” (nejaušai svārstībai), jo tās trūkums rada klasisku kļūmes režīmu: piecdesmit tava servisa eksemplāri vienā sekundē saņem 429 kļūdu, visi gaida tieši vienu sekundi, tad visi vienlaikus restartējas un atkal tiek noraidīti kā grupa. Pievienojot nejaušu aizkavi, tu izkliedē šo restartēšanos — tas ir risinājums pret „pērkona barā” (thundering herd) problēmu.
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 izsaukums ar eksponenciālu atkāpi un 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 # Pēdējais mēģinājums, izmet kļūdu tālāk
# Eksponenciāla atkāpe: 1s, 2s, 4s, 8s, 16s
base_delay = 2 ** attempt
# Nejaušs jitter, lai izvairītos no pērkona bara
jitter = random.uniform(0, base_delay * 0.5)
delay = base_delay + jitter
print(f"Mēģinājums {attempt + 1}/{max_retries} neizdevās. "
f"Atkārtošu pēc {delay:.1f}s...")
time.sleep(delay)
raise RuntimeError("Šeit nekad nevajadzētu nonākt")
# Lietošana
result = call_with_backoff("Paskaidro eksponenciālo atkāpi.")
print(result)
Ievēro pēdējo mēģinājumu: mēs izmetam oriģinālo kļūdu tālāk, nevis to „norijam”. Tādējādi izsaucošais kods saņem īsto diagnostiku — 429 vai 500 — un var lemt, ko darīt tālāk.
Tenacity bibliotēkas izmantošana
Šāda cikla rakstīšana ar roku ātri kļūst atkārtojoša, tiklīdz tev ir piecas funkcijas, kas jāaizsargā. Izvērstākai atkārtotu mēģinājumu pārvaldībai tenacity ir galvenais rīks: dekorators deklarē politiku, bet funkcijas ķermenī paliek tikai biznesa loģikas izsaukums. Tu iegūsti tās pašas sastāvdaļas, bet ar nosaukumiem un konfigurējamām vērtībām — izņēmumu sarakstu, kuriem veikt atkārtotu mēģinājumu, eksponenciālu gaidīšanu ar griestiem sešdesmit sekundēs, apstāšanos pēc pieciem mēģinājumiem un automātisku žurnālēšanu pirms katras pauzes.
# 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 izsaukums ar automātisku atkārtošanu, izmantojot tenacity."""
response = client.responses.create(
model=model,
input=prompt
)
return response.output_text
# Lietošana — atkārtojumi ir caurspīdīgi
result = resilient_call("Sveiki!")
print(result)
Ķēdes pārtraucēja (Circuit Breaker) modelis
Atkārtoti mēģinājumi atrisina incidentus, kas ilgst dažas sekundes. Tie kļūst kaitīgi, ja pārtraukums ilgst ilgāk: tad katrs lietotāja pieprasījums patērē piecus mēģinājumus un trīsdesmit sekundes gaidīšanas laika pirms kļūmes, tavi pavedieni sakrājas un beigās nobirst pats tavs serviss. Ķēdes pārtraucējs novērš tavas lietotnes turpmākus izsaukumus uz nefunkcionējošu API.
Tas darbojas līdzīgi elektriskajam ķēdes pārtraucējam ar trim stāvokļiem. Slēgts (Closed): viss darbojas normāli un izsaukumi tiek laisti cauri. Atvērts (Open): API tiek uzskatīts par nefunkcionējošu, un izsaukumi tiek uzreiz bloķēti, pat nemēģinot veikt tīkla savienojumu — lietotājs saņem kļūdu milisekunžu laikā, nevis pēc noilguma. Pusatvērts (Half-open): tiklīdz atpūtas periods ir beidzies, tiek nosūtīts testa izsaukums, lai pārbaudītu, vai API ir atjaunojies: ja tas izdodas, ķēde aizveras; ja ne, tā atkal atveras uz jaunu ciklu.
import time
from enum import Enum
class CircuitState(Enum):
CLOSED = "closed"
OPEN = "open"
HALF_OPEN = "half_open"
class CircuitBreaker:
"""Ķēdes pārtraucējs API izsaukumiem."""
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:
"""Pārbauda, vai izsaukums ir atļauts."""
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 # Viens testa izsaukums
return False
# Pusatvērts: atļauts tikai viens izsaukums
return True
def record_success(self):
"""Reģistrē veiksmīgu izsaukumu."""
self.consecutive_errors = 0
self.state = CircuitState.CLOSED
def record_error(self):
"""Reģistrē kļūmi."""
self.consecutive_errors += 1
self.last_error_time = time.monotonic()
if self.consecutive_errors >= self.threshold:
self.state = CircuitState.OPEN
print(f"Ķēde ATVĒRTA pēc {self.threshold} secīgām kļūdām")
Kļūdu skaitītājs tiek atiestatīts uz nulli, tiklīdz izsaukums ir veiksmīgs: ķēdi atver secīgas kļūmes, nevis vēsturisks kumulatīvs skaits. Integrācija klienta pusē tad reducējas uz trim soļiem — jautāt atļauju, signalizēt par veiksmi, signalizēt par kļūmi.
# Integrācija ar OpenAI klientu
circuit = CircuitBreaker(error_threshold=3, reset_timeout=30.0)
def call_with_circuit_breaker(prompt: str) -> str:
"""API izsaukums, ko aizsargā ķēdes pārtraucējs."""
if not circuit.can_call():
raise RuntimeError(
f"Ķēde atvērta — API nav pieejams. "
f"Atkārto pēc {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
# Lietošana
try:
result = call_with_circuit_breaker("Sveiki!")
print(result)
except RuntimeError as e:
print(f"Kļūda: {e}")
Trīs modeļu kombinēšana
Ražošanas vidē apvieno atkāpi, ķēdes pārtraucēju un noilgumu. Ievēro konstruktoru: klients tiek izveidots ar max_retries=0, kas atspējo SDK iekšējos atkārtotos mēģinājumus. Bez tā tavi trīs mēģinājumi reizinātos ar SDK diviem, un tu gaidītu daudz ilgāk, nekā paredzēts. Trīsdesmit sekunžu noilgums ierobežo katru atsevišķu izsaukumu, cikls apstrādā atkārtojumus, bet ķēdes pārtraucējs uzrauga servisa vispārējo veselību.
class APIClient:
"""Noturīgs API klients, kas apvieno visus modeļus."""
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("Serviss uz laiku nav pieejams")
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("Neizdevās pēc visiem mēģinājumiem")
# Lietošana
api = APIClient()
print(api.call("Paskaidro noturību programmatūras inženierijā."))
Pirms dodies tālāk, pārbaudi šo klientu, simulējot pārtraukumu: atslēdz tīklu, palaid duci izsaukumu un pārliecinies, ka pēdējie neizdodas uzreiz, nevis gaidot. Ja tas tā nav, tavs slieksnis ir pārāk augsts apstrādātajam apjomam.
Galvenās atziņas
- SDK pēc noklusējuma veic 2 atkārtotus mēģinājumus — pielāgo to ar
max_retries - Eksponenciāla atkāpe ar jitter novērš „pērkona bara” efektu
- Ķēdes pārtraucējs aizsargā tavu lietotni no ilgstošiem pārtraukumiem
- Izmanto
tenacitydeklarativai atkārtotu mēģinājumu pārvaldībai ražošanas vidē - Apvieno visus trīs modeļus, lai sasniegtu maksimālu noturību
- Nekad neatkārto 400/401/403 kļūdas (klienta kļūdas)