Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Kartojimas, eksponentinis delsos didinimas ir grandinės pertraukiklis

Paskaita 14 iš 22 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Kartojimas, eksponentinis delsos didinimas ir grandinės pertraukiklis
  2. Eksponentinis delsos didinimas
  3. Tenacity bibliotekos naudojimas
  4. Grandinės pertraukiklio (Circuit Breaker) šablonas
  5. Trijų šablonų derinimas
  6. Svarbiausi punktai

Kartojimas, eksponentinis delsos didinimas ir grandinės pertraukiklis

Laikinos klaidos gamybinėje aplinkoje yra normalus reiškinys. OpenAI SDK automatiškai atlieka du kartojimus, tačiau norint užtikrinti maksimalų atsparumą, turėtumėte įgyvendinti savo strategijas. Ankstesnėje pamokoje išmokai atpažinti kartojimui tinkamas klaidas; šioje išmoksi kartoti protingai – nepablogindamas situacijos, kurią bandai ištaisyti.

Eksponentinis delsos didinimas

Principas paprastas: kiekvienas kartojimas laukia ilgiau nei ankstesnis. Tai neleidžia perkrauti API, kai jis yra apkrautas. Ypatingo dėmesio vertas „jitter“ (atsitiktinis svyravimas), nes jo nebuvimas sukelia klasikinį gedimo scenarijų: penkiasdešimt tavo paslaugos egzempliorių tą pačią sekundę gauna 429 klaidą, visi laukia lygiai vieną sekundę, tada visi vienu metu paleidžiami iš naujo ir vėl grupėje atmetami. Pridėjus atsitiktinį delsą, šis paleidimas išskaidomas – tai yra vaistas nuo „triukšmingos bandos“ (thundering herd) problemos.

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 užklausa su eksponentiniu delsos didinimu ir 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  # Paskutinis bandymas, perduoti klaidą toliau

            # Eksponentinis delsos didinimas: 1s, 2s, 4s, 8s, 16s
            base_delay = 2 ** attempt

            # Atsitiktinis jitter, kad išvengtume triukšmingos bandos
            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")

# Naudojimas
result = call_with_backoff("Explain exponential backoff.")
print(result)

Atkreipk dėmesį į paskutinį bandymą: mes perduodame originalią klaidą toliau, o ne ją „nuryjame“. Taip kviečiantysis kodas gauna tikrą diagnostiką – 429 arba 500 – ir gali pats nuspręsti, ką su ja daryti.

Tenacity bibliotekos naudojimas

Rašyti šį ciklą rankiniu būdu greitai tampa varginančia, kai reikia apsaugoti penkias funkcijas. Sudėtingesnei kartojimų valdybai tenacity yra pagrindinis įrankis: dekoratorius deklaruoja politiką, o funkcijos kūne lieka tik verslo logikos iškvietimas. Gauni tuos pačius ingredientus, bet pavadintus ir konfigūruojamus – išimčių, kurioms taikomas kartojimas, sąrašą, eksponentinį laukimą, apribotą šešiasdešimčia sekundžių, sustojimą po penkių bandymų ir automatinį registravimą prieš kiekvieną pauzę.

# 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 užklausa su automatiniu kartojimu naudojant tenacity."""
    response = client.responses.create(
        model=model,
        input=prompt
    )
    return response.output_text

# Naudojimas – kartojimai yra skaidrūs
result = resilient_call("Hello!")
print(result)

Grandinės pertraukiklio (Circuit Breaker) šablonas

Kartojimas išsprendžia kelias sekundes trunkančius incidentus. Jis tampa žalingas, kai sutrikimas trunka ilgiau: tuomet kiekvienas naudotojo prašymas sunaudoja penkis bandymus ir trisdešimt sekundžių laukimo prieš nepavykstant, jūsų gijos kaupiasi ir galiausiai nutrūksta jūsų pačių paslauga. Grandinės pertraukiklis neleidžia jūsų programai toliau kviesti neveikiančio API.

Jis veikia kaip elektros grandinės pertraukiklis ir turi tris būsenas. Uždara (Closed) – viskas veikia normaliai, užklausos praleidžiamos. Atidaryta (Open) – API laikomas neveikiančiu, užklausos blokuojamos iškart, net nebandant jungtis prie tinklo – naudotojas gauna klaidą per milisekundes, o ne po laiko limito. Pusiau atidaryta (Half-open) – pasibaigus poilsio laikui, siunčiama bandomoji užklausa patikrinti, ar API vėl veikia: jei pavyksta, grandinė užsidaro; jei nepavyksta, ji vėl atsidaro naujam ciklui.

import time
from enum import Enum

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

class CircuitBreaker:
    """API užklausų grandinės pertraukiklis."""

    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:
        """Patikrina, ar užklausa leidžiama."""
        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  # Viena bandomoji užklausa
            return False

        # Pusiau atidaryta: leidžiama tik viena užklausa
        return True

    def record_success(self):
        """Įrašo sėkmingą užklausą."""
        self.consecutive_errors = 0
        self.state = CircuitState.CLOSED

    def record_error(self):
        """Įrašo nesėkmę."""
        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")

Klaidų skaitiklis nustatomas į nulį, kai tik užklausa pavyksta: grandinę atidaro iš eilės einančios nesėkmės, o ne istorinis kaupiamasis skaičius. Integracija kliento pusėje tada susiveda į tris žingsnius – paprašyti leidimo, pranešti apie sėkmę, pranešti apie nesėkmę.

# Integracija su OpenAI klientu
circuit = CircuitBreaker(error_threshold=3, reset_timeout=30.0)

def call_with_circuit_breaker(prompt: str) -> str:
    """API užklausa, apsaugota grandinės pertraukikliu."""
    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

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

Trijų šablonų derinimas

Gamybinėje aplinkoje derinkite delsos didinimą, grandinės pertraukiklį ir laiko limitą. Atkreipk dėmesį į konstruktorių: klientas sukurtas su max_retries=0, kas išjungia vidinius SDK kartojimus. Be to, jūsų trys bandymai padaugintųsi iš SDK dviejų bandymų ir lauktumėte daug ilgiau nei tikėtasi. Trisdešimties sekundžių laiko limitas apriboja kiekvieną atskirą užklausą, ciklas valdo kartojimus, o grandinės pertraukiklis stebi bendrą paslaugos būklę.

class APIClient:
    """Atsparus API klientas, sujungiantis visus šablonus."""

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

# Naudojimas
api = APIClient()
print(api.call("Explain resilience in software engineering."))

Prieš judant toliau, ištestuok šį klientą imituodamas sutrikimą: nutrauk tinklo ryšį, paleisk dešimt užklausų ir patikrink, ar paskutinės nepavyksta akimirksniu, užuot laukusios. Jei taip nėra, tavo slenkstis yra per didelis apdorojamam kiekiui.

Svarbiausi punktai

  • SDK pagal numatytuosius nustatymus atlieka 2 kartojimus – koreguokite naudodami max_retries
  • Eksponentinis delsos didinimas su jitter išvengia triukšmingos bandos
  • Grandinės pertraukiklis apsaugo jūsų programą nuo ilgalaikių sutrikimų
  • Naudokite tenacity deklaratyviam kartojimų valdymui gamybinėje aplinkoje
  • Derinkite visus tris šablonus, kad pasiektumėte maksimalų atsparumą
  • Niekada nekartokite 400/401/403 klaidų (kliento klaidos)