Python Circuit Breaker: Izgradnja aplikacij, odpornih na napake

V svetu porazdeljenih sistemov in mikrostoritev je soočanje z napakami neizogibno. Storitve lahko postanejo nedostopne zaradi težav z omrežjem, preobremenjenih strežnikov ali nepričakovanih napak. Če storitev, ki ne deluje, ni pravilno obravnavana, lahko to povzroči verižne odpovedi, ki uničijo celotne sisteme. Vzorec Circuit Breaker je močna tehnika za preprečevanje teh verižnih odpovedi in izgradnjo bolj odpornih aplikacij. Ta članek ponuja obsežen vodnik za implementacijo vzorca Circuit Breaker v Pythonu.

Kaj je vzorec Circuit Breaker?

Vzorec Circuit Breaker, ki ga navdihujejo električni odklopniki, deluje kot proxy za operacije, ki bi lahko propadle. Spremlja uspešnost in stopnje neuspešnosti teh operacij in, ko je dosežena določena meja napak, "sproži" vezje, kar prepreči nadaljnje klice v storitev, ki ne deluje. To omogoča storitvi, ki ne deluje, čas za okrevanje, ne da bi jo preobremenile zahteve, in preprečuje storitvi, ki kliče, da bi zapravljala vire za poskušanje povezave s storitvijo, za katero je znano, da ne deluje.

Circuit Breaker ima tri glavna stanja:

• Closed: Odklopnik je v normalnem stanju in omogoča prehod klicev do zaščitene storitve. Spremlja uspeh in neuspeh teh klicev.
• Open: Odklopnik je sprožen in vsi klici v zaščiteno storitev so blokirani. Po določenem časovnem obdobju odklopnik preide v stanje Half-Open.
• Half-Open: Odklopnik omogoča omejeno število testnih klicev v zaščiteno storitev. Če so ti klici uspešni, se odklopnik vrne v stanje Closed. Če ne uspejo, se vrne v stanje Open.

Tukaj je preprosta analogija: predstavljajte si, da poskušate dvigniti denar z bankomata. Če bankomat večkrat ne izplača gotovine (morda zaradi sistemske napake v banki), bi posredoval Circuit Breaker. Namesto da bi nadaljevali s poskusi dvigov, ki verjetno ne bodo uspeli, bi Circuit Breaker začasno blokiral nadaljnje poskuse (stanje Open). Čez nekaj časa bi lahko dovolil en sam poskus dviga (stanje Half-Open). Če bi bil ta poskus uspešen, bi Circuit Breaker nadaljeval z normalnim delovanjem (stanje Closed). Če ne uspe, bi Circuit Breaker ostal v stanju Open daljše obdobje.

Zakaj uporabljati Circuit Breaker?

Implementacija Circuit Breaker ponuja več prednosti:

• Preprečuje verižne odpovedi: Z blokiranjem klicev v storitev, ki ne deluje, Circuit Breaker preprečuje, da bi se napaka razširila na druge dele sistema.
• Izboljša odpornost sistema: Circuit Breaker omogoča storitvam, ki ne delujejo, čas za okrevanje, ne da bi jih preobremenile zahteve, kar vodi do bolj stabilnega in odpornega sistema.
• Zmanjšuje porabo virov: Z izogibanjem nepotrebnim klicem v storitev, ki ne deluje, Circuit Breaker zmanjšuje porabo virov tako v storitvi, ki kliče, kot v storitvi, ki jo kliče.
• Zagotavlja mehanizme za nadomestne rešitve: Ko je vezje odprto, lahko storitev, ki kliče, izvede mehanizem za nadomestne rešitve, kot je vračanje vrednosti iz predpomnilnika ali prikazovanje sporočila o napaki, kar zagotavlja boljšo uporabniško izkušnjo.

Implementacija Circuit Breaker v Pythonu

Obstaja več načinov za implementacijo vzorca Circuit Breaker v Pythonu. Lahko zgradite svojo implementacijo iz nič ali pa uporabite knjižnico tretje osebe. Tukaj bomo raziskali oba pristopa.

1. Izgradnja odklopnika po meri

Začnimo z osnovno implementacijo po meri, da razumemo temeljne koncepte. Ta primer uporablja modul `threading` za varnost niti in modul `time` za obravnavanje časovnih omejitev.

            
import time
import threading

class CircuitBreaker:
    def __init__(self, failure_threshold, recovery_timeout):
        self.failure_threshold = failure_threshold
        self.recovery_timeout = recovery_timeout
        self.state = "CLOSED"
        self.failure_count = 0
        self.last_failure_time = None
        self.lock = threading.Lock()

    def call(self, func, *args, **kwargs):
        with self.lock:
            if self.state == "OPEN":
                if time.time() - self.last_failure_time > self.recovery_timeout:
                    self.state = "HALF_OPEN"
                else:
                    raise CircuitBreakerError("Circuit breaker is open")

        try:
            result = func(*args, **kwargs)
            self.reset()
            return result
        except Exception as e:
            self.record_failure()
            raise e

    def record_failure(self):
        with self.lock:
            self.failure_count += 1
            self.last_failure_time = time.time()

            if self.failure_count >= self.failure_threshold:
                self.state = "OPEN"
                print("Circuit breaker opened")

    def reset(self):
        with self.lock:
            self.failure_count = 0
            self.state = "CLOSED"
            print("Circuit breaker closed")

class CircuitBreakerError(Exception):
    pass

# Example Usage
def unreliable_service():
    # Simulate a service that sometimes fails
    import random
    if random.random() < 0.5:
        raise Exception("Service failed")
    else:
        return "Service successful"

circuit_breaker = CircuitBreaker(failure_threshold=3, recovery_timeout=10)

for i in range(10):
    try:
        result = circuit_breaker.call(unreliable_service)
        print(f"Call {i+1}: {result}")
    except CircuitBreakerError as e:
        print(f"Call {i+1}: {e}")
    except Exception as e:
        print(f"Call {i+1}: Service failed: {e}")
    time.sleep(1) 

            

              
                Copy
              
            
          

Pojasnilo:

• Razred `CircuitBreaker`:
  • `__init__(self, failure_threshold, recovery_timeout)`: Inicializira odklopnik s pragom napak (število napak pred sprožitvijo vezja), časovno omejitvijo za obnovitev (čas, ki ga je treba počakati pred poskusom polodprtega stanja) in nastavi začetno stanje na `CLOSED`.
  • `call(self, func, *args, **kwargs)`: To je glavna metoda, ki obdaja funkcijo, ki jo želite zaščititi. Preveri trenutno stanje odklopnika. Če je `OPEN`, preveri, ali je potekla časovna omejitev za obnovitev. Če je tako, preide v `HALF_OPEN`. V nasprotnem primeru sproži `CircuitBreakerError`. Če stanje ni `OPEN`, izvede funkcijo in obravnava morebitne izjeme.
  • `record_failure(self)`: Poveča število napak in zabeleži čas napake. Če število napak preseže prag, preklopi vezje v stanje `OPEN`.
  • `reset(self)`: Ponastavi število napak in preklopi vezje v stanje `CLOSED`.
• Razred `CircuitBreakerError`: Izjema po meri, ki se sproži, ko je odklopnik odprt.
• Funkcija `unreliable_service()`: Simulira storitev, ki naključno ne uspe.
• Primer uporabe: Prikazuje, kako uporabiti razred `CircuitBreaker` za zaščito funkcije `unreliable_service()`.

Ključni vidiki za implementacijo po meri:

• Varnost niti: `threading.Lock()` je ključen za zagotavljanje varnosti niti, zlasti v sočasnih okoljih.
• Obravnavanje napak: Blok `try...except` prestreže izjeme iz zaščitene storitve in pokliče `record_failure()`.
• Prehodi stanja: Logika za prehajanje med stanji `CLOSED`, `OPEN` in `HALF_OPEN` je implementirana v metodah `call()` in `record_failure()`.

2. Uporaba knjižnice tretje osebe: `pybreaker`

Čeprav je izgradnja lastnega odklopnika lahko dobra učna izkušnja, je uporaba dobro preizkušene knjižnice tretje osebe pogosto boljša možnost za produkcijska okolja. Ena priljubljena knjižnica Python za implementacijo vzorca Circuit Breaker je `pybreaker`.

Namestitev:

            
pip install pybreaker

            

              
                Copy
              
            
          

Primer uporabe:

            
import pybreaker
import time

# Define a custom exception for our service
class ServiceError(Exception):
    pass

# Simulate an unreliable service
def unreliable_service():
    import random
    if random.random() < 0.5:
        raise ServiceError("Service failed")
    else:
        return "Service successful"

# Create a CircuitBreaker instance
circuit_breaker = pybreaker.CircuitBreaker(
    fail_max=3,  # Number of failures before opening the circuit
    reset_timeout=10,  # Time in seconds before attempting to close the circuit
    name="MyService"
)

# Wrap the unreliable service with the CircuitBreaker
@circuit_breaker
def call_unreliable_service():
    return unreliable_service()

# Make calls to the service
for i in range(10):
    try:
        result = call_unreliable_service()
        print(f"Call {i+1}: {result}")
    except pybreaker.CircuitBreakerError as e:
        print(f"Call {i+1}: Circuit breaker is open: {e}")
    except ServiceError as e:
        print(f"Call {i+1}: Service failed: {e}")
    time.sleep(1)

            

              
                Copy
              
            
          

Pojasnilo:

• Namestitev: Ukaz `pip install pybreaker` namesti knjižnico.
• Razred `pybreaker.CircuitBreaker`:
  • `fail_max`: Določa število zaporednih neuspehov, preden se odpre odklopnik.
  • `reset_timeout`: Določa čas (v sekundah), ko ostane odklopnik odprt, preden preide v polodprto stanje.
  • `name`: Opisno ime za odklopnik.
• Dekorator: Dekorator `@circuit_breaker` obdaja funkcijo `unreliable_service()` in samodejno obravnava logiko odklopnika.
• Obravnavanje izjem: Blok `try...except` prestreže `pybreaker.CircuitBreakerError`, ko je vezje odprto, in `ServiceError` (našo izjemo po meri), ko storitev ne deluje.

Prednosti uporabe `pybreaker`:

• Poenostavljena implementacija: `pybreaker` ponuja čist in enostaven API za uporabo, kar zmanjšuje izvorno kodo.
• Varnost niti: `pybreaker` je varen za niti, zaradi česar je primeren za sočasne aplikacije.
• Prilagodljiv: Konfigurirate lahko različne parametre, kot so prag napak, časovna omejitev za ponastavitev in poslušalci dogodkov.
• Poslušalci dogodkov: `pybreaker` podpira poslušalce dogodkov, kar vam omogoča spremljanje stanja odklopnika in ustrezno ukrepanje (npr. beleženje, pošiljanje opozoril).

3. Napredni koncepti odklopnika

Poleg osnovne implementacije je treba pri uporabi odklopnikov upoštevati več naprednih konceptov:

• Meritve in spremljanje: Zbiranje metrik o učinkovitosti vaših odklopnikov je bistvenega pomena za razumevanje njihovega vedenja in prepoznavanje morebitnih težav. Za vizualizacijo teh metrik lahko uporabite knjižnice, kot sta Prometheus in Grafana. Spremljajte meritve, kot so:
• Stanje odklopnika (odprto, zaprto, polodprto)
• Število uspešnih klicev
• Število neuspešnih klicev
• Latenca klicev
• Mehanizmi za nadomestne rešitve: Ko je vezje odprto, potrebujete strategijo za obravnavanje zahtev. Pogosti mehanizmi za nadomestne rešitve vključujejo:
• Vračanje vrednosti iz predpomnilnika.
• Prikazovanje sporočila o napaki uporabniku.
• Klicanje alternativne storitve.
• Vračanje privzete vrednosti.
• Asinhroni odklopniki: V asinhronih aplikacijah (z uporabo `asyncio`) boste morali uporabiti asinhrono implementacijo odklopnika. Nekatere knjižnice ponujajo asinhrono podporo.
• Pregrade: Vzorec pregrade izolira dele aplikacije, da prepreči, da bi se napake v enem delu prenesle na druge. Odklopnike je mogoče uporabiti v povezavi s pregradami za zagotavljanje še večje tolerance na napake.
• Časovni odklopniki: Namesto sledenja številu napak časovni odklopnik odpre vezje, če povprečni odzivni čas zaščitene storitve preseže določen prag v določenem časovnem oknu.

Praktični primeri in primeri uporabe

• Arhitektura mikrostoritev: V arhitekturi mikrostoritev so storitve pogosto odvisne druga od druge. Odklopnik lahko zaščiti storitev pred preobremenitvijo zaradi napak v storitvi navzdol. Na primer, aplikacija za e-trgovino ima lahko ločene mikrostoritve za katalog izdelkov, obdelavo naročil in obdelavo plačil. Če obdelava plačil postane nedostopna, lahko odklopnik v storitvi za obdelavo naročil prepreči ustvarjanje novih naročil, kar prepreči verižno odpoved.
• Povezave z bazami podatkov: Če se vaša aplikacija pogosto povezuje z bazo podatkov, lahko odklopnik prepreči nevihte povezav, ko baza podatkov ni na voljo. Razmislite o aplikaciji, ki se povezuje z geografsko porazdeljeno bazo podatkov. Če izpad omrežja vpliva na eno od regij baze podatkov, lahko odklopnik prepreči aplikaciji, da bi večkrat poskušala vzpostaviti povezavo z nedostopno regijo, kar izboljša učinkovitost delovanja in stabilnost.
• Zunanji API-ji: Pri klicanju zunanjih API-jev lahko odklopnik zaščiti vašo aplikacijo pred prehodnimi napakami in izpadi. Mnoge organizacije se zanašajo na API-je tretjih oseb za različne funkcije. Z zavijanjem klicev API-jev z odklopnikom lahko organizacije ustvarijo robustnejše integracije in zmanjšajo vpliv napak zunanjih API-jev.
• Logika za ponovni poskus: Odklopniki lahko delujejo v povezavi z logiko za ponovni poskus. Vendar se je pomembno izogibati agresivnim ponovnim poskusom, ki lahko poslabšajo težavo. Odklopnik bi moral preprečiti ponovne poskuse, ko je znano, da storitev ni na voljo.

Globalni premisleki

Pri implementaciji odklopnikov v globalnem kontekstu je pomembno upoštevati naslednje:

• Latenca omrežja: Latenca omrežja se lahko znatno razlikuje glede na geografsko lokacijo storitev, ki kličejo in so klicane. Ustrezno prilagodite časovno omejitev za obnovitev. Na primer, klici med storitvami v Severni Ameriki in Evropi imajo lahko večjo latenco kot klici znotraj iste regije.
• Časovni pasovi: Zagotovite, da se vsi časovni žigi dosledno obravnavajo v različnih časovnih pasovih. Za shranjevanje časovnih žigov uporabite UTC.
• Regionalni izpadi: Razmislite o možnosti regionalnih izpadov in implementirajte odklopnike za izolacijo napak na določene regije.
• Kulturni premisleki: Pri oblikovanju mehanizmov za nadomestne rešitve upoštevajte kulturni kontekst svojih uporabnikov. Na primer, sporočila o napakah morajo biti lokalizirana in kulturno primerna.

Najboljše prakse

• Začnite s konservativnimi nastavitvami: Začnite z razmeroma nizkim pragom napak in daljšo časovno omejitvijo za obnovitev. Spremljajte obnašanje odklopnika in po potrebi prilagodite nastavitve.
• Uporabite ustrezne mehanizme za nadomestne rešitve: Izberite mehanizme za nadomestne rešitve, ki zagotavljajo dobro uporabniško izkušnjo in zmanjšujejo vpliv napak.
• Spremljajte stanje odklopnika: Sledite stanju svojih odklopnikov in nastavite opozorila, ki vas obvestijo, ko je vezje odprto.
• Preizkusite obnašanje odklopnika: Simulirajte napake v svojem testnem okolju, da zagotovite, da vaši odklopniki delujejo pravilno.
• Izogibajte se pretiranemu zanašanju na odklopnike: Odklopniki so orodje za blaženje napak, vendar niso nadomestilo za odpravljanje temeljnih vzrokov teh napak. Raziščite in popravite temeljne vzroke nestabilnosti storitev.
• Razmislite o porazdeljenem sledenju: Integrirajte orodja za porazdeljeno sledenje (kot sta Jaeger ali Zipkin) za sledenje zahtevam v več storitvah. To vam lahko pomaga prepoznati temeljni vzrok napak in razumeti vpliv odklopnikov na celoten sistem.

Zaključek

Z implementacijo načel, opisanih v tem priročniku, lahko zgradite aplikacije Python, ki so bolj odporne na napake, kar zagotavlja boljšo uporabniško izkušnjo in stabilnejši sistem, ne glede na vaš globalni doseg.