Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Újrapróbálkozás, exponenciális visszalépés és megszakító áramkör

14. lecke 22 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Újrapróbálkozás, exponenciális visszalépés és megszakító áramkör
  2. Exponenciális visszalépés
  3. A Tenacity könyvtár használata
  4. A megszakító áramkör (Circuit Breaker) minta
  5. A három minta kombinálása
  6. Főbb megállapítások

Újrapróbálkozás, exponenciális visszalépés és megszakító áramkör

Az átmeneti hibák teljesen normálisak éles környezetben. Az OpenAI SDK automatikusan kezel két újrapróbálkozást, de a maximális ellenállóképesség érdekében érdemes saját stratégiákat implementálnod. Az előző leckében megtanultad felismerni az újrapróbálható hibákat; ebben a leckében azt tanulod meg, hogyan próbáld újra intelligensen – anélkül, hogy rontanál a helyzeten, amit éppen megoldani próbálsz.

Exponenciális visszalépés

Az elv egyszerű: minden újrapróbálkozásnál tovább várunk, mint az előzőnél. Ez megakadályozza, hogy túlterheld az API-t, amikor az amúgy is nyomás alatt van. A „jitter“ (véletlenszerű ingadozás) külön figyelmet érdemel, mert hiánya egy klasszikus hibaforráshoz vezet: a szolgáltatásod ötven példánya egyszerre kap egy 429-es hibát, mind pontosan egy másodpercet vár, majd egyszerre indulnak újra, és csoportként ismét elutasítást kapnak. Véletlenszerű késleltetés hozzáadásával szétoszlatod ezeket az újraindításokat – ez a megoldás a „mennydörgő csorda“ (thundering herd) problémájára.

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 hívás exponenciális visszalépéssel és jitterrel."""

    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  # Utolsó próbálkozás, továbbítjuk a hibát

            # Exponenciális visszalépés: 1s, 2s, 4s, 8s, 16s
            base_delay = 2 ** attempt

            # Véletlenszerű jitter a mennydörgő csorda elkerülésére
            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")

# Használat
result = call_with_backoff("Explain exponential backoff.")
print(result)

Figyeld meg az utolsó próbálkozást: az eredeti hibát továbbítjuk ahelyett, hogy elnyelnénk. Így a hívó fél megkapja a valós diagnosztikát – 429-es vagy 500-as hibát –, és eldöntheti, mit kezdjen vele.

A Tenacity könyvtár használata

Ha öt függvényt kell védened, ennek a ciklusnak a kézi megírása gyorsan ismétlődővé válik. A fejlettebb újrapróbálkozás-kezeléshez a tenacity a legjobb eszköz: a dekorátor deklarálja a szabályzatot, a függvény törzse pedig csak az üzleti logika hívását tartalmazza. Ugyanazokat az összetevőket kapod, de elnevezve és konfigurálhatóan – a újrapróbálandó kivételek listáját, a hatvan másodpercre korlátozott exponenciális várakozást, az öt próbálkozás utáni leállást, és az automatikus naplózást minden szünet előtt.

# 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 hívás automatikus újrapróbálkozással a tenacity segítségével."""
    response = client.responses.create(
        model=model,
        input=prompt
    )
    return response.output_text

# Használat — az újrapróbálkozások transzparensek
result = resilient_call("Hello!")
print(result)

A megszakító áramkör (Circuit Breaker) minta

Az újrapróbálkozás megoldja a néhány másodpercig tartó incidenseket. Hosszabb kimaradás esetén azonban káros becomes: ekkor minden felhasználói kérés öt próbálkozást és harminc másodperc várakozást emészt fel a hiba előtt, a szálaid felhalmozódnak, és végül a saját szolgáltatásod dől be. A megszakító áramkör megakadályozza, hogy az alkalmazásod tovább hívjon egy hibás API-t.

Úgy működik, mint egy elektromos megszakító, három állapottal. Zárt (Closed): minden normálisan működik, a hívások áthaladnak. Nyitott (Open): az API leálltnek számít, a hívásokat azonnal blokkoljuk, még a hálózati kísérlet nélkül is – a felhasználó milliszekundumok alatt kap hibát a time-out helyett. Félig nyitott (Half-open): miután a pihenőidő letelt, küldünk egy teszthívást, hogy ellenőrizzük, visszatért-e az API: ha sikerül, az áramkör záródik; ha sikertelen, újra nyílik egy új ciklusra.

import time
from enum import Enum

class CircuitState(Enum):
    CLOSED = "closed"
    OPEN = "open"
    HALF_OPEN = "half_open"

class CircuitBreaker:
    """Megszakító áramkör API hívásokhoz."""

    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:
        """Ellenőrzi, hogy engedélyezett-e egy hívás."""
        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  # Egy teszt hívás
            return False

        # Félig nyitott: csak egy hívás engedélyezett
        return True

    def record_success(self):
        """Sikeres hívást rögzít."""
        self.consecutive_errors = 0
        self.state = CircuitState.CLOSED

    def record_error(self):
        """Sikertelenséget rögzít."""
        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")

A hiba számláló nullára áll vissza, amint egy hívás sikerül: nem a történelmi, halmozott szám számít, hanem a zsinórban bekövetkezett hibák nyitják ki az áramkört. A kliens oldali integráció ezután három lépésre redukálódik: engedélyt kérni, sikert jelezni, hibát jelezni.

# Integráció az OpenAI klienssel
circuit = CircuitBreaker(error_threshold=3, reset_timeout=30.0)

def call_with_circuit_breaker(prompt: str) -> str:
    """API hívás megszakító áramkörrel védve."""
    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

# Használat
try:
    result = call_with_circuit_breaker("Hello!")
    print(result)
except RuntimeError as e:
    print(f"Error: {e}")

A három minta kombinálása

Éles környezetben kombináld a visszalépést, a megszakító áramkört és a time-outot. Figyeld meg a konstruktort: a klienst max_retries=0 paraméterrel hozzuk létre, ami letiltja az SDK belső újrapróbálkozásait. Enélkül a te három próbálkozásod megszorozódna az SDK két próbálkozásával, és a vártnál sokkal tovább várnál. A harminc másodperces time-out korlátozza az egyes hívásokat, a ciklus kezeli az újrapróbálkozásokat, a megszakító áramkör pedig a szolgáltatás általános egészségét figyeli.

class APIClient:
    """Ellenállóképes API kliens, amely egyesíti az összes mintát."""

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

# Használat
api = APIClient()
print(api.call("Explain resilience in software engineering."))

Mielőtt továbblépnél, teszteld ezt a klienst egy kimaradás szimulálásával: vágd el a hálózatot, indíts el egy tucat hívást, és ellenőrizd, hogy az utolsók azonnal hibáznak-e várakozás helyett. Ha nem így történik, akkor a küszöbértéked túl magas a feldolgozott forgalomhoz képest.

Főbb megállapítások

  • Az SDK alapértelmezetten 2 újrapróbálkozást kezel – állítsd be a max_retries paraméterrel
  • A jitterrel kiegészített exponenciális visszalépés elkerüli a mennydörgő csorda hatást
  • A megszakító áramkör megvédi az alkalmazásodat a hosszan tartó kimaradásoktól
  • Használd a tenacity könyvtárat a deklaratív újrapróbálkozás-kezeléshez éles környezetben
  • Kombináld mindhárom mintát a maximális ellenállóképesség érdekében
  • Soha ne próbálj újra 400/401/403-as hibákat (kliens oldali hibák)