Επαναληπτικές προσπάθειες, εκθετική καθυστέρηση και διακόπτης κυκλώματος
Σε αυτήν τη σελίδα
Επαναληπτικές προσπάθειες, εκθετική καθυστέρηση και διακόπτης κυκλώματος
Τα παροδικά σφάλματα είναι φυσιολογικά στην παραγωγή. Το SDK της OpenAI διαχειρίζεται αυτόματα δύο επαναληπτικές προσπάθειες, αλλά για μέγιστη ανθεκτικότητα, θα πρέπει να υλοποιήσετε τις δικές σας στρατηγικές. Το προηγούμενο μάθημα σας δίδαξε να αναγνωρίζετε τα σφάλματα που επιδέχονται επανάληψη· αυτό το μάθημα σας διδάσκει πώς να κάνετε επαναληπτικές προσπάθειες με έξυπνο τρόπο—χωρίς να επιδεινώνετε την κατάσταση που προσπαθείτε να διορθώσετε.
Εκθετική καθυστέρηση (Exponential Backoff)
Η αρχή είναι απλή: κάθε επαναληπτική προσπάθεια περιμένει περισσότερο χρόνο από την προηγούμενη. Αυτό αποτρέπει τον υπερφορτωμένο του API όταν βρίσκεται υπό πίεση. Η τυχαία διακύμανση (jitter) αξίζει ιδιαίτερης προσοχής, καθώς η απουσία της προκαλεί μια κλασική κατάσταση αστοχίας: πενήντα στιγμιότυπα της υπηρεσίας σας λαμβάνουν ένα σφάλμα 429 την ίδια στιγμή, όλα περιμένουν ακριβώς ένα δευτερόλεπτο, στη συνέχεια όλα επανεκκινούν ταυτόχρονα και απορρίπτονται ξανά ως ομάδα. Προσθέτοντας μια τυχαία καθυστέρηση, κατανέμετε αυτή την επανεκκίνηση—αυτή είναι η λύση για το φαινόμενο του «thundering herd».
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)
Παρατηρήστε την τελική προσπάθεια: προωθούμε το αρχικό σφάλμα αντί να το καταπίνουμε. Έτσι, ο καλών λαμβάνει την πραγματική διάγνωση—429 ή 500—και μπορεί να αποφασίσει τι θα κάνει με αυτήν.
Χρήση της βιβλιοθήκης Tenacity
Η χειροκίνητη συγγραφή αυτού του βρόχου γίνεται γρήγορα επαναληπτική μόλις έχετε πέντε συναρτήσεις προς προστασία. Για πιο προηγμένη διαχείριση επαναληπτικών προσπαθειών, το tenacity είναι το κατάλληλο εργαλείο: ο διακοσμητής δηλώνει την πολιτική και το σώμα της συνάρτησης περιέχει μόνο την κλήση της επιχειρηματικής λογικής. Λαμβάνετε τα ίδια συστατικά, αλλά ονοματισμένα και παραμετροποιήσιμα—τη λίστα των εξαιρέσεων για επανάληψη, την εκθετική αναμονή με ανώτατο όριο τα εξήντα δευτερόλεπτα, τη διακοπή μετά από πέντε προσπάθειες και την αυτόματη καταγραφή πριν από κάθε παύση.
# 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)
Το πρότυπο του διακόπτη κυκλώματος (Circuit Breaker)
Οι επαναληπτικές προσπάθειες λύνουν περιστατικά που διαρκούν λίγα δευτερόλεπτα. Γίνονται επιβλαβείς όταν η διακοπή διαρκεί περισσότερο: κάθε αίτημα χρήστη καταναλώνει τότε πέντε προσπάθειες και τριάντα δευτερόλεπτα αναμονής πριν αποτύχει, τα νήματα σας συσσωρεύονται και τελικά καταρρέει η δική σας υπηρεσία. Ο διακόπτης κυκλώματος εμποδίζει την εφαρμογή σας να συνεχίσει να καλεί ένα API που αποτυγχάνει.
Λειτουργεί όπως ένας ηλεκτρικός διακόπτης κυκλώματος, με τρεις καταστάσεις. Κλειστό (Closed), όλα λειτουργούν κανονικά και οι κλήσεις περνούν. Ανοιχτό (Open), το API θεωρείται εκτός λειτουργίας και οι κλήσεις μπλοκάρονται αμέσως, χωρίς καν να επιχειρείται η σύνδεση δικτύου—ο χρήστης λαμβάνει ένα σφάλμα σε χιλιοστά του δευτερολέπτου αντί να περιμένει τη λήξη του χρονικού ορίου. Ημι-ανοιχτό (Half-open), μόλις παρέλθει η περίοδος ανάπαυλας, στέλνεται μια δοκιμαστική κλήση για να ελεγχθεί αν το API έχει επανέλθει: αν επιτύχει, το κύκλωμα κλείνει· αν αποτύχει, ανοίγει ξανά για έναν νέο κύκλο.
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")
Ο μετρητής σφαλμάτων μηδενίζεται μόλις μια κλήση επιτύχει: είναι οι διαδοχικές αποτυχίες που ανοίγουν το κύκλωμα, όχι ένας ιστορικός σωρευτικός αριθμός. Η ενσωμάτωση στην πλευρά του πελάτη ανάγεται τότε σε τρία βήματα—ζητήστε άδεια, σηματοδοτήστε επιτυχία, σηματοδοτήστε αποτυχία.
# 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}")
Συνδυασμός των τριών προτύπων
Στην παραγωγή, συνδυάστε την εκθετική καθυστέρηση, τον διακόπτη κυκλώματος και το χρονικό όριο. Παρατηρήστε τον κατασκευαστή: ο πελάτης δημιουργείται με max_retries=0, το οποίο απενεργοποιεί τις εσωτερικές επαναληπτικές προσπάθειες του SDK. Χωρίς αυτό, οι τρεις προσπάθειές σας θα πολλαπλασιάζονταν με τις δύο του SDK και θα περιμένατε πολύ περισσότερο από το αναμενόμενο. Το χρονικό όριο των τριάντα δευτερολέπτων οριοθετεί κάθε μεμονωμένη κλήση, ο βρόχος διαχειρίζεται τις επαναληπτικές προσπάθειες και ο διακόπτης κυκλώματος παρακολουθεί τη γενική υγεία της υπηρεσίας.
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."))
Πριν προχωρήσετε, δοκιμάστε αυτόν τον πελάτη προσομοιώνοντας μια διακοπή: διακόψτε το δίκτυο, εκκινήστε μια δωδεκάδα κλήσεων και επαληθεύστε ότι οι τελευταίες αποτυγχάνουν ακαριαία αντί να περιμένουν. Αν δεν συμβαίνει αυτό, το κατώφλι σας είναι πολύ υψηλό για τον όγκο που επεξεργάζεστε.
Βασικά σημεία
- Το SDK διαχειρίζεται 2 επαναληπτικές προσπάθειες από προεπιλογή — προσαρμόστε το με το
max_retries - Η εκθετική καθυστέρηση με τυχαία διακύμανση (jitter) αποφεύγει το φαινόμενο «thundering herd»
- Ο διακόπτης κυκλώματος προστατεύει την εφαρμογή σας από παρατεταμένες διακοπές
- Χρησιμοποιήστε το
tenacityγια δηλωτική διαχείριση επαναληπτικών προσπαθειών στην παραγωγή - Συνδυάστε και τα τρία πρότυπα για μέγιστη ανθεκτικότητα
- Μην κάνετε ποτέ επαναληπτικές προσπάθειες για σφάλματα 400/401/403 (σφάλματα πελάτη)