Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Atkārtoti mēģinājumi, eksponenciāla atkāpe un ķēdes pārtraucējs

Nodarbība 14 no 22 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Atkārtoti mēģinājumi, eksponenciāla atkāpe un ķēdes pārtraucējs
  2. Eksponenciāla atkāpe
  3. Tenacity bibliotēkas izmantošana
  4. Ķēdes pārtraucēja (Circuit Breaker) modelis
  5. Trīs modeļu kombinēšana
  6. Galvenās atziņas

Atkārtoti mēģinājumi, eksponenciāla atkāpe un ķēdes pārtraucējs

Pārejošas kļūdas ražošanas vidē ir norma. OpenAI SDK automātiski veic divus atkārtotus mēģinājumus, taču, lai nodrošinātu maksimālu noturību, tev vajadzētu ieviest savas stratēģijas. Iepriekšējā nodarbībā tu iemācījies atpazīt kļūdas, kuras vērts atkārtot; šajā tu apgūsi, kā veikt atkārtotus mēģinājumus gudri — nepasliktinot situāciju, kuru cenšies novērst.

Eksponenciāla atkāpe

Princips ir vienkāršs: katrs nākamais mēģinājums gaida ilgāk nekā iepriekšējais. Tas novērš API pārslodzi brīžos, kad tas ir noslogots. Īpaša uzmanība jāpievērš „jitter” (nejaušai svārstībai), jo tās trūkums rada klasisku kļūmes režīmu: piecdesmit tava servisa eksemplāri vienā sekundē saņem 429 kļūdu, visi gaida tieši vienu sekundi, tad visi vienlaikus restartējas un atkal tiek noraidīti kā grupa. Pievienojot nejaušu aizkavi, tu izkliedē šo restartēšanos — tas ir risinājums pret „pērkona barā” (thundering herd) problēmu.

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 izsaukums ar eksponenciālu atkāpi un 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  # Pēdējais mēģinājums, izmet kļūdu tālāk

            # Eksponenciāla atkāpe: 1s, 2s, 4s, 8s, 16s
            base_delay = 2 ** attempt

            # Nejaušs jitter, lai izvairītos no pērkona bara
            jitter = random.uniform(0, base_delay * 0.5)
            delay = base_delay + jitter

            print(f"Mēģinājums {attempt + 1}/{max_retries} neizdevās. "
                  f"Atkārtošu pēc {delay:.1f}s...")
            time.sleep(delay)

    raise RuntimeError("Šeit nekad nevajadzētu nonākt")

# Lietošana
result = call_with_backoff("Paskaidro eksponenciālo atkāpi.")
print(result)

Ievēro pēdējo mēģinājumu: mēs izmetam oriģinālo kļūdu tālāk, nevis to „norijam”. Tādējādi izsaucošais kods saņem īsto diagnostiku — 429 vai 500 — un var lemt, ko darīt tālāk.

Tenacity bibliotēkas izmantošana

Šāda cikla rakstīšana ar roku ātri kļūst atkārtojoša, tiklīdz tev ir piecas funkcijas, kas jāaizsargā. Izvērstākai atkārtotu mēģinājumu pārvaldībai tenacity ir galvenais rīks: dekorators deklarē politiku, bet funkcijas ķermenī paliek tikai biznesa loģikas izsaukums. Tu iegūsti tās pašas sastāvdaļas, bet ar nosaukumiem un konfigurējamām vērtībām — izņēmumu sarakstu, kuriem veikt atkārtotu mēģinājumu, eksponenciālu gaidīšanu ar griestiem sešdesmit sekundēs, apstāšanos pēc pieciem mēģinājumiem un automātisku žurnālēšanu pirms katras pauzes.

# 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 izsaukums ar automātisku atkārtošanu, izmantojot tenacity."""
    response = client.responses.create(
        model=model,
        input=prompt
    )
    return response.output_text

# Lietošana — atkārtojumi ir caurspīdīgi
result = resilient_call("Sveiki!")
print(result)

Ķēdes pārtraucēja (Circuit Breaker) modelis

Atkārtoti mēģinājumi atrisina incidentus, kas ilgst dažas sekundes. Tie kļūst kaitīgi, ja pārtraukums ilgst ilgāk: tad katrs lietotāja pieprasījums patērē piecus mēģinājumus un trīsdesmit sekundes gaidīšanas laika pirms kļūmes, tavi pavedieni sakrājas un beigās nobirst pats tavs serviss. Ķēdes pārtraucējs novērš tavas lietotnes turpmākus izsaukumus uz nefunkcionējošu API.

Tas darbojas līdzīgi elektriskajam ķēdes pārtraucējam ar trim stāvokļiem. Slēgts (Closed): viss darbojas normāli un izsaukumi tiek laisti cauri. Atvērts (Open): API tiek uzskatīts par nefunkcionējošu, un izsaukumi tiek uzreiz bloķēti, pat nemēģinot veikt tīkla savienojumu — lietotājs saņem kļūdu milisekunžu laikā, nevis pēc noilguma. Pusatvērts (Half-open): tiklīdz atpūtas periods ir beidzies, tiek nosūtīts testa izsaukums, lai pārbaudītu, vai API ir atjaunojies: ja tas izdodas, ķēde aizveras; ja ne, tā atkal atveras uz jaunu ciklu.

import time
from enum import Enum

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

class CircuitBreaker:
    """Ķēdes pārtraucējs API izsaukumiem."""

    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:
        """Pārbauda, vai izsaukums ir atļauts."""
        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  # Viens testa izsaukums
            return False

        # Pusatvērts: atļauts tikai viens izsaukums
        return True

    def record_success(self):
        """Reģistrē veiksmīgu izsaukumu."""
        self.consecutive_errors = 0
        self.state = CircuitState.CLOSED

    def record_error(self):
        """Reģistrē kļūmi."""
        self.consecutive_errors += 1
        self.last_error_time = time.monotonic()

        if self.consecutive_errors >= self.threshold:
            self.state = CircuitState.OPEN
            print(f"Ķēde ATVĒRTA pēc {self.threshold} secīgām kļūdām")

Kļūdu skaitītājs tiek atiestatīts uz nulli, tiklīdz izsaukums ir veiksmīgs: ķēdi atver secīgas kļūmes, nevis vēsturisks kumulatīvs skaits. Integrācija klienta pusē tad reducējas uz trim soļiem — jautāt atļauju, signalizēt par veiksmi, signalizēt par kļūmi.

# Integrācija ar OpenAI klientu
circuit = CircuitBreaker(error_threshold=3, reset_timeout=30.0)

def call_with_circuit_breaker(prompt: str) -> str:
    """API izsaukums, ko aizsargā ķēdes pārtraucējs."""
    if not circuit.can_call():
        raise RuntimeError(
            f"Ķēde atvērta — API nav pieejams. "
            f"Atkārto pēc {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

# Lietošana
try:
    result = call_with_circuit_breaker("Sveiki!")
    print(result)
except RuntimeError as e:
    print(f"Kļūda: {e}")

Trīs modeļu kombinēšana

Ražošanas vidē apvieno atkāpi, ķēdes pārtraucēju un noilgumu. Ievēro konstruktoru: klients tiek izveidots ar max_retries=0, kas atspējo SDK iekšējos atkārtotos mēģinājumus. Bez tā tavi trīs mēģinājumi reizinātos ar SDK diviem, un tu gaidītu daudz ilgāk, nekā paredzēts. Trīsdesmit sekunžu noilgums ierobežo katru atsevišķu izsaukumu, cikls apstrādā atkārtojumus, bet ķēdes pārtraucējs uzrauga servisa vispārējo veselību.

class APIClient:
    """Noturīgs API klients, kas apvieno visus modeļus."""

    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("Serviss uz laiku nav pieejams")

        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("Neizdevās pēc visiem mēģinājumiem")

# Lietošana
api = APIClient()
print(api.call("Paskaidro noturību programmatūras inženierijā."))

Pirms dodies tālāk, pārbaudi šo klientu, simulējot pārtraukumu: atslēdz tīklu, palaid duci izsaukumu un pārliecinies, ka pēdējie neizdodas uzreiz, nevis gaidot. Ja tas tā nav, tavs slieksnis ir pārāk augsts apstrādātajam apjomam.

Galvenās atziņas

  • SDK pēc noklusējuma veic 2 atkārtotus mēģinājumus — pielāgo to ar max_retries
  • Eksponenciāla atkāpe ar jitter novērš „pērkona bara” efektu
  • Ķēdes pārtraucējs aizsargā tavu lietotni no ilgstošiem pārtraukumiem
  • Izmanto tenacity deklarativai atkārtotu mēģinājumu pārvaldībai ražošanas vidē
  • Apvieno visus trīs modeļus, lai sasniegtu maksimālu noturību
  • Nekad neatkārto 400/401/403 kļūdas (klienta kļūdas)