Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Ponovni poskusi, eksponentno zamikanje in odklopnik tokokroga

Lekcija 14 od 22 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Ponovni poskusi, eksponentno zamikanje in odklopnik tokokroga
  2. Eksponentno zamikanje
  3. Uporaba knjižnice Tenacity
  4. Vzorec odklopnika tokokroga (Circuit Breaker)
  5. Združevanje treh vzorcev
  6. Ključne ugotovitve

Ponovni poskusi, eksponentno zamikanje in odklopnik tokokroga

Prehodne napake so v proizvodnem okolju običajne. OpenAI SDK samodejno opravi dva ponovna poskusa, toda za največjo odpornost moraš implementirati lastne strategije. Prejšnja lekcija te je naučila prepoznavati napake, ki jih je mogoče ponoviti; ta te bo naučila, kako jih pametno ponoviti – ne da bi poslabšal situacijo, ki jo poskušaš odpraviti.

Eksponentno zamikanje

Načelo je preprosto: vsak ponovni poskus čaka dlje kot prejšnji. To preprečuje preobremenitev API-ja, ko je ta pod pritiskom. Posebno pozornost si zasluži „jitter” (naključni odmik), saj njegova odsotnost povzroča klasičen način odpovedi: petdeset primerkov tvoje storitve isto sekundo prejme kodo 429, vsi čakajo točno eno sekundo, nato pa se vsi hkrati ponovno zaženejo in so kot skupina spet zavrnjeni. Z dodajanjem naključnega zamika razpršiš ta ponovni zagon – to je zdravilo za „thundering herd” (učinek črede).

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)

Opazi zadnji poskus: namesto da bi pogoltnili napako, jo posredujemo naprej. Klicatelj tako prejme pravo diagnostiko – 429 ali 500 – in se lahko sam odloči, kaj storiti z njo.

Uporaba knjižnice Tenacity

Ročno pisanje te zanke hitro postane ponavljajoče se opravilo, ko moraš zaščititi pet funkcij. Za naprednejše upravljanje ponovnih poskusov je tenacity pravo orodje: okrasek (dekorator) razglasi politiko, telo funkcije pa vsebuje le klic poslovne logike. Dobiš iste sestavine, vendar poimenovane in konfigurabilne – seznam izjem za ponovni poskus, eksponentno čakanje z zgornjo mejo šestdesetih sekund, ustavitev po petih poskusih in samodejno beleženje pred vsakim premorom.

# 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)

Vzorec odklopnika tokokroga (Circuit Breaker)

Ponovni poskusi rešujejo incidente, ki trajajo nekaj sekund. Postanejo škodljivi, ko izpad traja dlje: vsaka uporabniška zahteva takrat porabi pet poskusov in trideset sekund čakanja pred neuspehom, tvoji niti se kopičijo in na koncu odpove tvoja lastna storitev. Odklopnik tokokroga prepreči, da bi tvoja aplikacija še naprej klicala nedelujoči API.

Deluje kot električni odklopnik s tremi stanji. Zaprto (Closed): vse deluje normalno in klici potekajo skozi. Odprto (Open): API velja za nedelujočega in klici so takoj blokirani, brez poskusa omrežne povezave – uporabnik prejme napako v milisekundah namesto po časovni omejitvi. Polodprto (Half-open): ko poteče čas mirovanja, se pošlje testni klic, da se preveri, ali je API spet na voljo: če uspe, se tokokrog zapre; če ne uspe, se za nov cikel ponovno odpre.

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")

Števec napak se ponastavi na nič, takoj ko klic uspe: tokokrog odprejo zaporedne napake, ne zgodovinsko kumulativno število. Integracija na strani odjemalca se nato свede na tri korake – zaprosi za dovoljenje, sporoči uspeh, sporoči neuspeh.

# 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}")

Združevanje treh vzorcev

V proizvodnem okolju združi eksponentno zamikanje, odklopnik tokokroga in časovno omejitev. Opazi konstruktor: odjemalec je ustvarjen z max_retries=0, kar onemogoči notranje ponovne poskuse SDK-ja. Brez tega bi se tvoji trije poskusi pomnožili z dvema poskusoma SDK-ja in čakal bi veliko dlje, kot pričakuješ. Tridesetsekundna časovna omejitev omejuje vsak posamezen klic, zanka upravlja ponovne poskuse, odklopnik tokokroga pa spremlja splošno zdravje storitve.

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."))

Preden nadaljuješ, preizkusi tega odjemalca s simulacijo izpada: izklopi omrežje, zaženi ducat klicev in preveri, ali zadnji klici takoj odpovejo namesto čakanja. Če temu ni tako, je tvoj prag previsok za obdelano količino prometa.

Ključne ugotovitve

  • SDK privzeto opravi 2 ponovna poskusa – prilagodi z max_retries
  • Eksponentno zamikanje z jitterjem preprečuje učinek „thundering herd”
  • Odklopnik tokokroga ščiti tvojo aplikacijo pred dolgotrajnimi izpadi
  • Za deklarativno upravljanje ponovnih poskusov v proizvodnem okolju uporabi tenacity
  • Za največjo odpornost združi vse tri vzorce
  • Nikoli ne ponavljaj napak 400/401/403 (napake odjemalca)