Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Opakovanie, exponenciálne oneskorenie a istič

Lekcia 14 z 22 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Opakovanie, exponenciálne oneskorenie a istič
  2. Exponenciálne oneskorenie
  3. Používanie knižnice Tenacity
  4. Vzorec ističa (Circuit Breaker)
  5. Kombinácia troch vzorcov
  6. Kľúčové poznatky

Opakovanie, exponenciálne oneskorenie a istič

Prechodné chyby sú v prevádzke bežné. OpenAI SDK automaticky vykoná dva pokusy o opakovanie, no pre maximálnu odolnosť by si mal implementovať vlastné stratégie. Predchádzajúca lekcia ťa naučila rozpoznávať chyby, ktoré sa oplatí opakovať; táto ťa naučí opakovať ich inteligentne – bez toho, aby si situáciu, ktorú sa snažíš napraviť, ešte zhoršil.

Exponenciálne oneskorenie

Princíp je jednoduchý: každé ďalšie opakovanie čaká dlhšie ako to predchádzajúce. Tým zabrániš preťaženiu API, keď je pod tlakom. Zvláštnu pozornosť si zasluhuje jitter (náhodná variácia), pretože jeho absencia spôsobuje klasický režim zlyhania: päťdesiat inštancií tvojej služby dostane chybu 429 v tej istej sekunde, všetky počkajú presne jednu sekundu, potom sa všetky narozpok restartujú a opäť ich skupinovo odmietne. Pridaním náhodného oneskorenia tento reštart rozložíš – to je liek na efekt „hromadného návalu“ (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:
    """Volanie API s exponenciálnym oneskorením a jitterom."""

    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  # Posledný pokus, propaguj chybu ďalej

            # Exponenciálne oneskorenie: 1s, 2s, 4s, 8s, 16s
            base_delay = 2 ** attempt

            # Náhodný jitter na zabránenie hromadného návalu
            jitter = random.uniform(0, base_delay * 0.5)
            delay = base_delay + jitter

            print(f"Pokus {attempt + 1}/{max_retries} zlyhal. "
                  f"Opakovanie o {delay:.1f}s...")
            time.sleep(delay)

    raise RuntimeError("Sem by sa kód nemal nikdy dostať")

# Použitie
result = call_with_backoff("Vysvetli exponenciálne oneskorenie.")
print(result)

Všimni si posledný pokus: pôvodnú chybu propagujeme ďalej namiesto toho, aby sme ju „prehltli“. Volajúci tak dostane skutočnú diagnostiku – 429 alebo 500 – a môže sa rozhodnúť, čo s ňou urobí.

Používanie knižnice Tenacity

Ručné písanie tejto slučky sa rýchlo stane opakujúcim sa úkonom, akonáhle máš chrániť päť funkcií. Pre pokročilejšiu správu opakovaní je nástrojom číslo jedna tenacity: dekorátor deklaruje politiku a telo funkcie obsahuje iba volanie obchodnej logiky. Získaš tie isté ingrediencie, ale pomenované a konfigurovateľné – zoznam výnimiek na opakovanie, exponenciálne čakanie obmedzené na šesťdesiat sekúnd, zastavenie po piatich pokusoch a automatické logovanie pred každou pauzou.

# 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:
    """Volanie API s automatickým opakovaním cez tenacity."""
    response = client.responses.create(
        model=model,
        input=prompt
    )
    return response.output_text

# Použitie – opakovania sú transparentné
result = resilient_call("Ahoj!")
print(result)

Vzorec ističa (Circuit Breaker)

Opakovanie rieši incidenty trvajúce niekoľko sekúnd. Stáva sa škodlivým, keď výpadok trvá dlhšie: každá požiadavka používateľa potom spotrebuje päť pokusov a tridsať sekúnd čakania pred zlyhaním, tvoje vlákna sa hromadia a nakoniec padne tvoja vlastná služba. Ištič zabráni tvojej aplikácii pokračovať vo volaní nefunkčného API.

Funguje ako elektrický istič s tromi stavmi. Zatvorený (Closed): všetko funguje normálne a požiadavky prechádzajú. Otvorený (Open): API sa považuje za nefunkčné a požiadavky sú okamžite blokované, bez pokusu o sieť – používateľ dostane chybu v milisekundách namiesto čakania na časový limit. Polootvorený (Half-open): po uplynutí doby odpočinku sa odošle testovacia požiadavka na overenie, či je API späť: ak uspeje, obvod sa uzavrie; ak zlyhá, znova sa otvorí na nový cyklus.

import time
from enum import Enum

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

class CircuitBreaker:
    """Ištič pre volania API."""

    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:
        """Skontroluje, či je volanie povolené."""
        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  # Jeden testovací pokus
            return False

        # Polootvorený: povolený len jeden pokus
        return True

    def record_success(self):
        """Zaznamená úspešné volanie."""
        self.consecutive_errors = 0
        self.state = CircuitState.CLOSED

    def record_error(self):
        """Zaznamená zlyhanie."""
        self.consecutive_errors += 1
        self.last_error_time = time.monotonic()

        if self.consecutive_errors >= self.threshold:
            self.state = CircuitState.OPEN
            print(f"Ištič OTVORENÝ po {self.threshold} po sebe idúcich chybách")

Počítadlo chýb sa resetuje na nulu hneď, ako sa volanie podarí: obvod otvoria až po sebe idúce zlyhania, nie historický kumulatívny súčet. Integrácia na strane klienta sa potom redukuje na tri kroky – opýtať sa na povolenie, signalizovať úspech, signalizovať zlyhanie.

# Integrácia s klientom OpenAI
circuit = CircuitBreaker(error_threshold=3, reset_timeout=30.0)

def call_with_circuit_breaker(prompt: str) -> str:
    """Volanie API chránené ističom."""
    if not circuit.can_call():
        raise RuntimeError(
            f"Ištič otvorený – API nedostupné. "
            f"Skús znova o {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

# Použitie
try:
    result = call_with_circuit_breaker("Ahoj!")
    print(result)
except RuntimeError as e:
    print(f"Chyba: {e}")

Kombinácia troch vzorcov

V prevádzke kombinuj oneskorenie, istič a časový limit. Všimni si konštruktor: klient sa vytvorí s max_retries=0, čím sa deaktivujú interné opakovania SDK. Bez toho by sa tvoje tri pokusy vynásobili dvoma od SDK a čakal by si oveľa dlhšie, než sa očakáva. Tridsaťsekundový časový limit ohraničuje každé jednotlivé volanie, slučka rieši opakovania a istič monitoruje celkové zdravie služby.

class APIClient:
    """Odolný klient API kombinujúci všetky vzorce."""

    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("Služba dočasne nedostupná")

        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("Zlyhanie po všetkých pokusoch")

# Použitie
api = APIClient()
print(api.call("Vysvetli odolnosť v softvérovom inžinierstve."))

Predtým, než pôjdeš ďalej, otestuj tohto klienta simuláciou výpadku: odpoj sieť, spusti tucet volaní a over, či posledné zlyhajú okamžite namiesto čakania. Ak to tak nie je, tvoj prah je pre spracovávaný objem príliš vysoký.

Kľúčové poznatky

  • SDK štandardne vybaví 2 opakovania – uprav pomocou max_retries
  • Exponenciálne oneskorenie s jitterom zabraňuje efektu hromadného návalu
  • Ištič chráni tvoju aplikáciu pred dlhotrvajúcimi výpadkami
  • Na deklarativnú správu opakovaní v prevádzke použi tenacity
  • Pre maximálnu odolnosť kombinuj všetky tri vzorce
  • Nikdy neopakuj chyby 400/401/403 (chyby klienta)