Atriail, Cúlú Easpónantúil, agus Briseadh Ciorcaid
Ar an leathanach seo
Atriail, Cúlú Easpónantúil, agus Briseadh Ciorcaid
Is gnách earráidí sealadacha i dtimpeallachtaí táirgeachta. Déanann an OpenAI SDK dhá atriail a láimhseáil go huathoibríoch, ach chun athléimneacht uasta a bhaint amach, ba chóir duit do chuid straitéisí féin a chur i bhfeidhm. Mhúin an cheacht roimhe seo duit earráidí in-atrialaithe a aithint; múinidh an ceacht seo duit atriail a dhéanamh go cliste—gan an scéal atá tú ag iarraidh a shocrú a dhéanamh níos measa.
Cúlú Easpónantúil
Tá an prionsabal simplí: fanann gach atriail níos faide ná an ceann roimhe. Coscaíonn sé seo ró-ualú ar an API nuair a bhíonn brú air. Tuilleann Jitter aird ar leith toisc go mbíonn mód teipthe clasaiceach mar thoradh ar a easnamh: faigheann caoga sampla de do sheirbhís 429 ag an soicind céanna, fanann siad go léir díreach soicind amháin, ansin tosaíonn siad go léir arís le chéile agus diúltaítear dóibh arís mar ghrúpa. Trí mhoill randamach a chur leis, scaipeann tú an t-atosaigh seo—sin an leigheas ar an “thundering herd” (tréad scanraithe).
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)
Tabhair faoi deara an iarracht dheireanach: scaipeann muid an earráid bhunaidh in ionad í a shlogadh. Mar sin, faigheann an glaoiteoir an diagnóisic fhíor—429 nó 500—is féidir leis cinneadh a dhéanamh faoin méid atá le déanamh léi.
An Leabharlann Tenacity a Úsáid
Éiríonn an lúb seo a scríobh de láimh athfhillteach go tapa nuair a bhíonn cúig fheidhm le cosaint agat. Chun bainistíocht atriail níos casta a dhéanamh, is é tenacity an uirlis is fearr: dearbhaíonn an maisitheoir (decorator) an polasaí, agus ní bhíonn sa chorp feidhme ach an glao ar an loighic gnó. Faigheann tú na comhábhair chéanna, ach ainmnithe agus inchoigeartaithe—an liosta eisceachtaí le haghaidh atriail, fanacht easpónantúil teoranta ag seasca soicind, stopadh tar éis cúig iarracht, agus logáil uathoibríoch roimh gach sos.
# 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)
An Patrún Briseadh Ciorcaid
Réitíonn atriail teagmhais a mhaireann cúpla soicind. Éiríonn sé díobhálach nuair a mhaireann an mhíchumas níos faide: ansin caithfidh gach iarratas úsáideora cúig iarracht agus tríocha soicind feithimh sula dteipeann air, carnann do shnáitheanna suas, agus is é do sheirbhís féin a théann síos. Cosnaíonn an briseadh ciorcaid d’fheidhmchlár ó bheith ag glaoch ar API atá ag teipthe i gcónaí.
Oibríonn sé cosúil le briseadh ciorcaid leictreach, le trí staid. Dúnta, oibríonn gach rud go gnáth agus téann glaonna tríd. Oscailte, meastar go bhfuil an API síos agus blocáiltear glaonna láithreach, gan iarracht líonra a dhéanamh fiú—faigheann an t-úsáideoir earráid i millisoicind in ionad tar éis am-teorainn. Leath-oscailte, nuair a bheidh an tréimhse scíthe caite, seoltar glao tástála chun a sheiceáil an bhfuil an API ar ais: má éiríonn leis, dúnann an ciorcad; má theipeann air, osclaítear arís é do thimthriall nua.
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")
Athshocraítear an t-áireamh earráide go nialas chomh luath agus a éiríonn le glao: is teipeanna leanúnacha a osclaíonn an ciorcad, ní comhaireamh carnach stairiúil. Tagann comhtháthú taobh an chliaint síos ansin do thrí chéim—iarr cead, cuir rath in iúl, cuir teip in iúl.
# 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}")
An Trí Phatrún a Chomhcheangal
I dtimpeallachtaí táirgeachta, comhcheangail cúlú, briseadh ciorcaid, agus am-teorainn. Tabhair faoi deara an tógálaí: cruthaítear an cliant le max_retries=0, rud a dhíchumasaíonn atriail inmheánacha an SDK. Gan é seo, iolrófaí do thrí iarracht faoi dhó an SDK, agus bheadh ort feitheamh i bhfad níos faide ná mar a bhí súil agat. Teorannaíonn an t-am-teorainn tríocha soicind gach glao aonair, déanann an lúb bainistíocht ar atriail, agus déanann an briseadh ciorcaid monatóireacht ar shláinte ghinearálta na seirbhíse.
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."))
Sula dtéann tú ar aghaidh, déan tástáil ar an gcliant seo trí mhíchumas a shamhlú: gearr an líonra, seol dosaen glao, agus fíoraigh go dteipeann ar na cinn dheireanacha láithreach in ionad feithimh. Mura bhfuil sé sin amhlaidh, tá do tairseach ró-ard don toirt atá á próiseáil.
Príomhphointí
- Déanann an SDK 2 atriail a láimhseáil de réir réamhshocraithe — coigeartaigh le
max_retries - Seachnaíonn cúlú easpónantúil le jitter an “thundering herd”
- Cosnaíonn an briseadh ciorcaid d’fheidhmchlár ó mhíchumais fhada
- Úsáid
tenacitychun bainistíocht atriail dhearbhaitheach a dhéanamh i dtáirgeadh - Comhcheangail na trí phatrún uile chun athléimneacht uasta a bhaint amach
- Ná déan atriail ar earráidí 400/401/403 riamh (earráidí cliant)