Python Circuit Breaker: Bygging av feiltolerante applikasjoner

I en verden av distribuerte systemer og mikrotjenester er håndtering av feil uunngåelig. Tjenester kan bli utilgjengelige på grunn av nettverksproblemer, overbelastede servere eller uventede feil. Når en feilende tjeneste ikke håndteres riktig, kan det føre til kaskaderende feil og velte hele systemer. Circuit Breaker-mønsteret er en kraftig teknikk for å forhindre disse kaskaderende feilene og bygge mer robuste applikasjoner. Denne artikkelen gir en omfattende veiledning om implementering av Circuit Breaker-mønsteret i Python.

Hva er Circuit Breaker-mønsteret?

Circuit Breaker-mønsteret, inspirert av elektriske automatsikringer, fungerer som en proxy for operasjoner som kan feile. Det overvåker suksess- og feilrater for disse operasjonene, og når en viss terskel av feil nås, "vrir" sikringen, noe som forhindrer ytterligere kall til den feilende tjenesten. Dette gir den feilende tjenesten tid til å komme seg uten å bli overveldet av forespørsler, og forhindrer at den kallende tjenesten kaster bort ressurser på å prøve å koble til en tjeneste som er kjent for å være nede.

Circuit Breaker har tre hovedtilstander:

• Lukket (Closed): Automatsikringen er i sin normale tilstand og tillater at kall passerer til den beskyttede tjenesten. Den overvåker suksess og feil for disse kallene.
• Åpen (Open): Automatsikringen er vippet og alle kall til den beskyttede tjenesten blokkeres. Etter en spesifisert tidsavbruddsperiode går automatsikringen over til Halvåpen tilstand.
• Halvåpen (Half-Open): Automatsikringen tillater et begrenset antall testkall til den beskyttede tjenesten. Hvis disse kallene lykkes, går automatsikringen tilbake til Lukket tilstand. Hvis de feiler, går den tilbake til Åpen tilstand.

Her er en enkel analogi: Tenk deg at du prøver å ta ut penger fra en minibank. Hvis minibanken gjentatte ganger mislykkes med å gi ut kontanter (kanskje på grunn av en systemfeil i banken), vil en Circuit Breaker gripe inn. I stedet for å fortsette å forsøke uttak som sannsynligvis vil feile, vil Circuit Breaker midlertidig blokkere ytterligere forsøk (Åpen tilstand). Etter en stund kan den tillate et enkelt uttak (Halvåpen tilstand). Hvis det forsøket lykkes, vil Circuit Breaker gjenoppta normal drift (Lukket tilstand).

Hvorfor bruke en Circuit Breaker?

Implementering av en Circuit Breaker gir flere fordeler:

• Forhindrer kaskaderende feil: Ved å blokkere kall til en feilende tjeneste, forhindrer Circuit Breaker at feilen sprer seg til andre deler av systemet.
• Forbedrer systemrobusthet: Circuit Breaker gir feilende tjenester tid til å komme seg uten å bli overveldet av forespørsler, noe som fører til et mer stabilt og robust system.
• Reduserer ressursforbruk: Ved å unngå unødvendige kall til en feilende tjeneste, reduserer Circuit Breaker ressursforbruket på både den kallende og den kalte tjenesten.
• Tilbyr fallback-mekanismer: Når kretsen er åpen, kan den kallende tjenesten utføre en fallback-mekanisme, som å returnere en cachelagret verdi eller vise en feilmelding, noe som gir en bedre brukeropplevelse.

Implementering av en Circuit Breaker i Python

Det finnes flere måter å implementere Circuit Breaker-mønsteret i Python. Du kan bygge din egen implementasjon fra bunnen av, eller du kan bruke et tredjepartsbibliotek. Her vil vi utforske begge tilnærmingene.

1. Bygging av en egendefinert Circuit Breaker

La oss starte med en grunnleggende, egendefinert implementasjon for å forstå kjernekonseptene. Dette eksemplet bruker `threading`-modulen for trådsikkerhet og `time`-modulen for håndtering av tidsavbrudd.

            
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
              
            
          

Forklaring:

• `CircuitBreaker` Klasse:
  • `__init__(self, failure_threshold, recovery_timeout)`: Initialiserer automatsikringen med en feilterskel (antall feil før kretsen vippes), en gjenopprettingstid (tiden å vente før forsøk på halvåpen tilstand), og setter den initiale tilstanden til `CLOSED`.
  • `call(self, func, *args, **kwargs)`: Dette er hovedmetoden som omslutter funksjonen du vil beskytte. Den sjekker den gjeldende tilstanden til automatsikringen. Hvis den er `OPEN`, sjekker den om gjenopprettingstidsavbruddet har utløpt. Hvis så, går den til `HALF_OPEN`. Ellers utsteder den en `CircuitBreakerError`. Hvis tilstanden ikke er `OPEN`, utfører den funksjonen og håndterer potensielle unntak.
  • `record_failure(self)`: Øker feiltellingen og registrerer tidspunktet for feilen. Hvis feiltellingen overstiger terskelen, endres kretsen til `OPEN` tilstand.
  • `reset(self)`: Tilbakestiller feiltellingen og endrer kretsen til `CLOSED` tilstand.
• `CircuitBreakerError` Klasse: Et egendefinert unntak som utstedes når automatsikringen er åpen.
• `unreliable_service()` Funksjon: Simulerer en tjeneste som feiler tilfeldig.
• Eksempelbruk: Viser hvordan du bruker `CircuitBreaker`-klassen til å beskytte `unreliable_service()`-funksjonen.

Viktige hensyn for egendefinert implementasjon:

• Trådsikkerhet: `threading.Lock()` er avgjørende for å sikre trådsikkerhet, spesielt i samtidige miljøer.
• Feilhåndtering: `try...except`-blokken fanger opp unntak fra den beskyttede tjenesten og kaller `record_failure()`.
• Tilstandsoverganger: Logikken for å skifte mellom `CLOSED`, `OPEN` og `HALF_OPEN` tilstander er implementert i `call()` og `record_failure()` metodene.

2. Bruk av et tredjepartsbibliotek: `pybreaker`

Selv om det å bygge din egen Circuit Breaker kan være en god læringsopplevelse, er det ofte et bedre alternativ for produksjonsmiljøer å bruke et godt testet tredjepartsbibliotek. Et populært Python-bibliotek for implementering av Circuit Breaker-mønsteret er `pybreaker`.

Installasjon:

            
pip install pybreaker

            

              
                Copy
              
            
          

Eksempelbruk:

            
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
              
            
          

Forklaring:

• Installasjon: `pip install pybreaker`-kommandoen installerer biblioteket.
• `pybreaker.CircuitBreaker` Klasse:
  • `fail_max`: Spesifiserer antall påfølgende feil før automatsikringen åpnes.
  • `reset_timeout`: Spesifiserer tiden (i sekunder) automatsikringen forblir åpen før den går over til halvåpen tilstand.
  • `name`: Et beskrivende navn for automatsikringen.
• Dekoratør: `@circuit_breaker`-dekoratøren omslutter `unreliable_service()`-funksjonen og håndterer automatisk Circuit Breaker-logikken.
• Unntakshåndtering: `try...except`-blokken fanger opp `pybreaker.CircuitBreakerError` når kretsen er åpen og `ServiceError` (vårt egendefinerte unntak) når tjenesten feiler.

Fordeler med å bruke `pybreaker`:

• Forenklet implementering: `pybreaker` tilbyr en ren og enkel API, noe som reduserer overflødig kode.
• Trådsikkerhet: `pybreaker` er trådsikker, noe som gjør den egnet for samtidige applikasjoner.
• Tilpassbar: Du kan konfigurere ulike parametere, som feilterskel, gjenopprettingstid og hendelseslyttere.
• Hendelseslyttere: `pybreaker` støtter hendelseslyttere, noe som lar deg overvåke tilstanden til automatsikringen og utføre handlinger deretter (f.eks. logging, sende varsler).

3. Avanserte Circuit Breaker-konsepter

Utover den grunnleggende implementasjonen, er det flere avanserte konsepter å vurdere ved bruk av Circuit Breakers:

• Metrikker og overvåking: Innsamling av metrikker om ytelsen til dine Circuit Breakers er avgjørende for å forstå deres oppførsel og identifisere potensielle problemer. Biblioteker som Prometheus og Grafana kan brukes til å visualisere disse metrikkene. Spor metrikker som:
• Circuit Breaker-tilstand (Åpen, Lukket, Halvåpen)
• Antall vellykkede kall
• Antall mislykkede kall
• Latens for kall
• Fallback-mekanismer: Når kretsen er åpen, trenger du en strategi for å håndtere forespørsler. Vanlige fallback-mekanismer inkluderer:
• Returnere en cachelagret verdi.
• Vise en feilmelding til brukeren.
• Kalle en alternativ tjeneste.
• Returnere en standardverdi.
• Asynkrone Circuit Breakers: I asynkrone applikasjoner (ved bruk av `asyncio`) må du bruke en asynkron Circuit Breaker-implementasjon. Noen biblioteker tilbyr asynkron støtte.
• Bulkheads (Skott): Bulkhead-mønsteret isolerer deler av en applikasjon for å forhindre at feil i én del sprer seg til andre. Circuit Breakers kan brukes i kombinasjon med Bulkheads for å gi enda større feiltoleranse.
• Tidsbaserte Circuit Breakers: I stedet for å spore antall feil, åpner en tidsbasert Circuit Breaker kretsen hvis gjennomsnittlig responstid for den beskyttede tjenesten overskrider en viss terskel innenfor et gitt tidsvindu.

Praktiske eksempler og bruksområder

Her er noen praktiske eksempler på hvordan du kan bruke Circuit Breakers i ulike scenarier:

• Mikrotjenestearkitektur: I en mikrotjenestearkitektur er tjenester ofte avhengige av hverandre. En Circuit Breaker kan beskytte en tjeneste mot å bli overveldet av feil i en nedstrømms tjeneste. For eksempel kan en e-handelsapplikasjon ha separate mikrotjenester for produktkatalog, ordrebehandling og betalingsbehandling. Hvis betalingsbehandlingstjenesten blir utilgjengelig, kan en Circuit Breaker i ordrebehandlingstjenesten forhindre at nye ordre opprettes, noe som forhindrer kaskaderende feil.
• Databaseforbindelser: Hvis applikasjonen din ofte kobler til en database, kan en Circuit Breaker forhindre tilkoblingsstormer når databasen er utilgjengelig. Vurder en applikasjon som kobler til en geografisk distribuert database. Hvis en nettverksavbrudd påvirker en av databaserigioneene, kan en Circuit Breaker forhindre at applikasjonen gjentatte ganger prøver å koble til den utilgjengelige regionen, noe som forbedrer ytelse og stabilitet.
• Eksterne APIer: Ved kall til eksterne APIer kan en Circuit Breaker beskytte applikasjonen din mot forbigående feil og nedetid. Mange organisasjoner er avhengige av tredjeparts APIer for ulike funksjonaliteter. Ved å omslutte API-kall med en Circuit Breaker, kan organisasjoner bygge mer robuste integrasjoner og redusere virkningen av eksterne API-feil.
• Forsøkslogikk (Retry logic): Circuit Breakers kan fungere i kombinasjon med forsøkslogikk. Det er imidlertid viktig å unngå aggressive forsøk som kan forverre problemet. Circuit Breaker bør forhindre forsøk når tjenesten er kjent for å være utilgjengelig.

Globale hensyn

Når du implementerer Circuit Breakers i en global kontekst, er det viktig å ta hensyn til følgende:

• Nettverkslatens: Nettverkslatensen kan variere betydelig avhengig av den geografiske plasseringen til de kallende og kalte tjenestene. Juster gjenopprettingstidsavbruddet deretter. For eksempel kan kall mellom tjenester i Nord-Amerika og Europa oppleve høyere latens enn kall innenfor samme region.
• Tidssoner: Sørg for at alle tidsstempler håndteres konsekvent på tvers av forskjellige tidssoner. Bruk UTC for lagring av tidsstempler.
• Regionale utfall: Vurder muligheten for regionale utfall og implementer Circuit Breakers for å isolere feil til spesifikke regioner.
• Kulturelle hensyn: Når du designer fallback-mekanismer, bør du vurdere den kulturelle konteksten til brukerne dine. Feilmeldinger bør for eksempel lokaliseres og være kulturelt passende.

Beste praksis

Her er noen beste praksiser for effektiv bruk av Circuit Breakers:

• Start med konservative innstillinger: Begynn med en relativt lav feilterskel og en lengre gjenopprettingstid. Overvåk Circuit Breakerens oppførsel og juster innstillingene etter behov.
• Bruk passende fallback-mekanismer: Velg fallback-mekanismer som gir en god brukeropplevelse og minimerer virkningen av feil.
• Overvåk Circuit Breaker-tilstand: Spor tilstanden til dine Circuit Breakers og sett opp varsler for å varsle deg når en krets er åpen.
• Test Circuit Breaker-oppførsel: Simuler feil i testmiljøet ditt for å sikre at dine Circuit Breakers fungerer som de skal.
• Unngå overdreven avhengighet av Circuit Breakers: Circuit Breakers er et verktøy for å redusere feil, men de er ikke en erstatning for å adressere de underliggende årsakene til disse feilene. Undersøk og fiks grunnårsakene til tjenesteustabilitet.
• Vurder distribuert sporing: Integrer verktøy for distribuert sporing (som Jaeger eller Zipkin) for å spore forespørsler på tvers av flere tjenester. Dette kan hjelpe deg med å identifisere grunnårsaken til feil og forstå virkningen av Circuit Breakers på det totale systemet.

Konklusjon

Circuit Breaker-mønsteret er et verdifullt verktøy for å bygge feiltolerante og robuste applikasjoner. Ved å forhindre kaskaderende feil og gi feilende tjenester tid til å komme seg, kan Circuit Breakers forbedre systemstabilitet og tilgjengelighet betydelig. Enten du velger å bygge din egen implementasjon eller bruke et tredjepartsbibliotek som `pybreaker`, er det avgjørende å forstå kjernekonseptene og beste praksis for Circuit Breaker-mønsteret for å utvikle robuste og pålitelige programvarer i dagens komplekse distribuerte miljøer.

Ved å implementere prinsippene som er skissert i denne veiledningen, kan du bygge Python-applikasjoner som er mer motstandsdyktige mot feil, og sikre en bedre brukeropplevelse og et mer stabilt system, uavhengig av din globale rekkevidde.