Python Circuit Breaker: Het bouwen van fouttolerante en veerkrachtige applicaties

In de wereld van softwareontwikkeling, met name bij het omgaan met gedistribueerde systemen en microservices, zijn applicaties inherent vatbaar voor storingen. Deze storingen kunnen afkomstig zijn van verschillende bronnen, waaronder netwerkproblemen, tijdelijke service-uitval en overbelaste resources. Zonder de juiste afhandeling kunnen deze storingen zich door het hele systeem voortzetten, wat leidt tot een volledige ineenstorting en een slechte gebruikerservaring. Dit is waar het Circuit Breaker-patroon om de hoek komt kijken - een cruciaal ontwerppatroon voor het bouwen van fouttolerante en veerkrachtige applicaties.

Fouttolerantie en Veerkracht Begrijpen

Voordat we in het Circuit Breaker-patroon duiken, is het essentieel om de concepten van fouttolerantie en veerkracht te begrijpen:

• Fouttolerantie: De mogelijkheid van een systeem om correct te blijven functioneren, zelfs in de aanwezigheid van fouten. Het gaat om het minimaliseren van de impact van fouten en het waarborgen dat het systeem functioneel blijft.
• Veerkracht: De mogelijkheid van een systeem om te herstellen van storingen en zich aan te passen aan veranderende omstandigheden. Het gaat om het terugveren van fouten en het handhaven van een hoog prestatieniveau.

Het Circuit Breaker-patroon is een belangrijke component bij het bereiken van zowel fouttolerantie als veerkracht.

Het Circuit Breaker-patroon uitgelegd

Het Circuit Breaker-patroon is een softwareontwerppatroon dat wordt gebruikt om cascade-storingen in gedistribueerde systemen te voorkomen. Het fungeert als een beschermende laag, die de gezondheid van externe services bewaakt en voorkomt dat de applicatie herhaaldelijk operaties probeert die waarschijnlijk zullen mislukken. Dit is cruciaal om resource-uitputting te voorkomen en de algehele stabiliteit van het systeem te waarborgen.

Zie het als een elektrische stroomonderbreker in uw huis. Wanneer er een storing optreedt (bijvoorbeeld een kortsluiting), schakelt de onderbreker uit, waardoor de elektriciteit niet meer kan stromen en verdere schade wordt voorkomen. Op dezelfde manier bewaakt de Circuit Breaker de oproepen naar externe services. Als de oproepen herhaaldelijk mislukken, 'schakelt' de onderbreker uit, waardoor verdere oproepen naar die service worden voorkomen totdat de service weer gezond wordt geacht.

De staten van een Circuit Breaker

Een Circuit Breaker werkt doorgaans in drie staten:

• Gesloten: De standaardtoestand. De Circuit Breaker staat toe dat verzoeken naar de externe service worden doorgestuurd. Het bewaakt het succes of de mislukking van deze verzoeken. Als het aantal mislukkingen een vooraf gedefinieerde drempel binnen een specifiek tijdsbestek overschrijdt, schakelt de Circuit Breaker over naar de 'Open'-toestand.
• Open: In deze toestand weigert de Circuit Breaker onmiddellijk alle verzoeken en retourneert een fout (bijvoorbeeld een `CircuitBreakerError`) naar de aanroepende applicatie zonder te proberen contact op te nemen met de externe service. Na een vooraf gedefinieerde time-outperiode schakelt de Circuit Breaker over naar de 'Half-Open'-toestand.
• Half-Open: In deze toestand staat de Circuit Breaker een beperkt aantal verzoeken toe om naar de externe service te worden doorgestuurd. Dit wordt gedaan om te testen of de service is hersteld. Als deze verzoeken slagen, schakelt de Circuit Breaker terug naar de 'Gesloten'-toestand. Als ze mislukken, keert hij terug naar de 'Open'-toestand.

Voordelen van het gebruik van een Circuit Breaker

• Verbeterde fouttolerantie: Voorkomt cascade-storingen door defecte services te isoleren.
• Verbeterde veerkracht: Hiermee kan het systeem op een goede manier herstellen van storingen.
• Verminderd resourceverbruik: Voorkomt verspilling van resources bij herhaaldelijk mislukte verzoeken.
• Betere gebruikerservaring: Voorkomt lange wachttijden en niet-reagerende applicaties.
• Vereenvoudigde foutafhandeling: Biedt een consistente manier om storingen af te handelen.

Een Circuit Breaker implementeren in Python

Laten we eens kijken hoe we het Circuit Breaker-patroon in Python kunnen implementeren. We beginnen met een basisimplementatie en voegen vervolgens meer geavanceerde functies toe, zoals faaldrempels en time-outperioden.

Basisimplementatie

Hier is een eenvoudig voorbeeld van een Circuit Breaker-klasse:

            
import time

class CircuitBreaker:
 def __init__(self, service_function, failure_threshold=3, retry_timeout=10):
 self.service_function = service_function
 self.failure_threshold = failure_threshold
 self.retry_timeout = retry_timeout
 self.state = 'closed'
 self.failure_count = 0
 self.last_failure_time = None

 def __call__(self, *args, **kwargs):
 if self.state == 'open':
 if time.time() - self.last_failure_time < self.retry_timeout:
 raise Exception('Circuit is open')
 else:
 self.state = 'half-open'

 if self.state == 'half_open':
 try:
 result = self.service_function(*args, **kwargs)
 self.state = 'closed'
 self.failure_count = 0
 return result
 except Exception as e:
 self.failure_count += 1
 self.last_failure_time = time.time()
 self.state = 'open'
 raise e

 if self.state == 'closed':
 try:
 result = self.service_function(*args, **kwargs)
 self.failure_count = 0
 return result
 except Exception as e:
 self.failure_count += 1
 if self.failure_count >= self.failure_threshold:
 self.state = 'open'
 self.last_failure_time = time.time()
 raise Exception('Circuit is open') from e
 raise e

            

              
                Copy
              
            
          

Uitleg:

• `__init__`: Initialiseert de CircuitBreaker met de servicefunctie die moet worden aangeroepen, een faaldrempel en een time-out voor opnieuw proberen.
• `__call__`: Deze methode onderschept de aanroepen naar de servicefunctie en handelt de Circuit Breaker-logica af.
• Gesloten toestand: Roept de servicefunctie aan. Als deze mislukt, verhoogt `failure_count`. Als `failure_count` de `failure_threshold` overschrijdt, schakelt deze over naar de 'Open'-toestand.
• Open toestand: Gooit onmiddellijk een uitzondering op en voorkomt verdere aanroepen naar de service. Na de `retry_timeout` schakelt deze over naar de 'Half-Open'-toestand.
• Half-Open toestand: Staat één testaanroep naar de service toe. Als dit lukt, gaat de Circuit Breaker terug naar de 'Gesloten'-toestand. Als dit mislukt, keert deze terug naar de 'Open'-toestand.

Voorbeeldgebruik

Laten we laten zien hoe u deze Circuit Breaker kunt gebruiken:

            
import time
import random

def my_service(success_rate=0.8):
 if random.random() < success_rate:
 return "Succes!"
 else:
 raise Exception("Service mislukt")


circuit_breaker = CircuitBreaker(my_service, failure_threshold=2, retry_timeout=5)

for i in range(10):
 try:
 result = circuit_breaker()
 print(f"Poging {i+1}: {result}")
 except Exception as e:
 print(f"Poging {i+1}: Fout: {e}")
 time.sleep(1)

            

              
                Copy
              
            
          

In dit voorbeeld simuleert `my_service` een service die af en toe mislukt. De Circuit Breaker bewaakt de service en 'opent' na een bepaald aantal mislukkingen het circuit, waardoor verdere aanroepen worden voorkomen. Na een time-outperiode schakelt deze over naar 'half-open' om de service opnieuw te testen.

Geavanceerde functies toevoegen

De basisimplementatie kan worden uitgebreid met meer geavanceerde functies:

• Time-out voor serviceaanroepen: Implementeer een time-outmechanisme om te voorkomen dat de Circuit Breaker vastloopt als de service er te lang over doet om te reageren.
• Monitoring en logboekregistratie: Registreer de staatsovergangen en -fouten voor monitoring en debugging.
• Statistieken en rapportage: Verzamel statistieken over de prestaties van de Circuit Breaker (bijvoorbeeld het aantal aanroepen, fouten, openingstijd) en rapporteer deze aan een monitoringsysteem.
• Configuratie: Sta configuratie toe van de faaldrempel, de time-out voor opnieuw proberen en andere parameters via configuratiebestanden of omgevingsvariabelen.

Verbeterde implementatie met time-out en logboekregistratie

Hier is een verfijnde versie met time-outs en basislogboekregistratie:

            
import time
import logging
import functools

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

class CircuitBreaker:
 def __init__(self, service_function, failure_threshold=3, retry_timeout=10, timeout=5):
 self.service_function = service_function
 self.failure_threshold = failure_threshold
 self.retry_timeout = retry_timeout
 self.timeout = timeout
 self.state = 'closed'
 self.failure_count = 0
 self.last_failure_time = None
 self.logger = logging.getLogger(__name__)

 @staticmethod
 def _timeout(func, timeout): #Decorator
 @functools.wraps(func)
 def wrapper(*args, **kwargs):
 import signal

 def handler(signum, frame):
 raise TimeoutError("Function call timed out")

 signal.signal(signal.SIGALRM, handler)
 signal.alarm(timeout)
 try:
 result = func(*args, **kwargs)
 signal.alarm(0)
 return result
 except TimeoutError:
 raise
 except Exception as e:
 raise
 finally:
 signal.alarm(0)
 return wrapper


 def __call__(self, *args, **kwargs):
 if self.state == 'open':
 if time.time() - self.last_failure_time < self.retry_timeout:
 self.logger.warning('Circuit is open, rejecting request')
 raise Exception('Circuit is open')
 else:
 self.logger.info('Circuit is half-open')
 self.state = 'half_open'

 if self.state == 'half_open':
 try:
 result = self._timeout(self.service_function, self.timeout)(*args, **kwargs)
 self.logger.info('Circuit is closed after successful half-open call')
 self.state = 'closed'
 self.failure_count = 0
 return result
 except TimeoutError as e:
 self.failure_count += 1
 self.last_failure_time = time.time()
 self.logger.error(f'Half-open call timed out: {e}')
 self.state = 'open'
 raise e
 except Exception as e:
 self.failure_count += 1
 self.last_failure_time = time.time()
 self.logger.error(f'Half-open call failed: {e}')
 self.state = 'open'
 raise e

 if self.state == 'closed':
 try:
 result = self._timeout(self.service_function, self.timeout)(*args, **kwargs)
 self.failure_count = 0
 return result
 except TimeoutError as e:
 self.failure_count += 1
 if self.failure_count >= self.failure_threshold:
 self.logger.error(f'Service timed out repeatedly, opening circuit: {e}')
 self.state = 'open'
 self.last_failure_time = time.time()
 raise Exception('Circuit is open') from e
 self.logger.error(f'Service timed out: {e}')
 raise e
 except Exception as e:
 self.failure_count += 1
 if self.failure_count >= self.failure_threshold:
 self.logger.error(f'Service failed repeatedly, opening circuit: {e}')
 self.state = 'open'
 self.last_failure_time = time.time()
 raise Exception('Circuit is open') from e
 self.logger.error(f'Service failed: {e}')
 raise e

            

              
                Copy
              
            
          

Belangrijkste verbeteringen:

• Time-out: Geïmplementeerd met behulp van de `signal`-module om de uitvoeringstijd van de servicefunctie te beperken.
• Logboekregistratie: Gebruikt de `logging`-module om staatsovergangen, fouten en waarschuwingen te registreren. Dit maakt het gemakkelijker om het gedrag van de Circuit Breaker te bewaken.
• Decorator: De time-outimplementatie maakt nu gebruik van een decorator voor schonere code en bredere toepasbaarheid.

Voorbeeldgebruik (met time-out en logboekregistratie)

            
import time
import random

def my_service(success_rate=0.8):
 time.sleep(random.uniform(0, 3))
 if random.random() < success_rate:
 return "Succes!"
 else:
 raise Exception("Service mislukt")

circuit_breaker = CircuitBreaker(my_service, failure_threshold=2, retry_timeout=5, timeout=2)

for i in range(10):
 try:
 result = circuit_breaker()
 print(f"Poging {i+1}: {result}")
 except Exception as e:
 print(f"Poging {i+1}: Fout: {e}")
 time.sleep(1)

            

              
                Copy
              
            
          

De toevoeging van de time-out en logboekregistratie verbetert de robuustheid en observeerbaarheid van de Circuit Breaker aanzienlijk.

De juiste Circuit Breaker-implementatie kiezen

Hoewel de voorbeelden een startpunt bieden, kunt u overwegen bestaande Python-bibliotheken of -frameworks te gebruiken voor productieomgevingen. Enkele populaire opties zijn:

• Pybreaker: Een goed onderhouden en veelzijdige bibliotheek die een robuuste Circuit Breaker-implementatie biedt. Het ondersteunt verschillende configuraties, statistieken en staatsovergangen.
• Resilience4j (met Python-wrapper): Hoewel het in de eerste plaats een Java-bibliotheek is, biedt Resilience4j uitgebreide mogelijkheden voor fouttolerantie, waaronder Circuit Breakers. Een Python-wrapper kan worden gebruikt voor integratie.
• Aangepaste implementaties: Voor specifieke behoeften of complexe scenario's kan een aangepaste implementatie nodig zijn, waardoor volledige controle over het gedrag van de Circuit Breaker en de integratie met de monitoring- en logboekregistratiesystemen van de applicatie mogelijk is.

Best Practices voor Circuit Breaker

Om het Circuit Breaker-patroon effectief te gebruiken, volgt u deze best practices:

• Kies een geschikte faaldrempel: De faaldrempel moet zorgvuldig worden gekozen op basis van de verwachte foutfrequentie van de externe service. Als u de drempel te laag instelt, kan dit leiden tot onnodige circuitonderbrekingen, terwijl als u deze te hoog instelt, de detectie van echte fouten kan worden vertraagd. Houd rekening met de typische foutfrequentie.
• Stel een realistische time-out voor opnieuw proberen in: De time-out voor opnieuw proberen moet lang genoeg zijn om de externe service te laten herstellen, maar niet zo lang dat dit overmatige vertragingen veroorzaakt voor de aanroepende applicatie. Houd rekening met netwerklatentie en serviceterugsteltijd.
• Implementeer monitoring en waarschuwingen: Bewaak de staatsovergangen, foutfrequenties en open duur van de Circuit Breaker. Stel waarschuwingen in om u op de hoogte te stellen wanneer de Circuit Breaker vaak opent of sluit of als de foutfrequenties toenemen. Dit is cruciaal voor proactief beheer.
• Configureer Circuit Breakers op basis van serviceafhankelijkheden: Pas Circuit Breakers toe op services die externe afhankelijkheden hebben of cruciaal zijn voor de functionaliteit van de applicatie. Geef prioriteit aan bescherming voor kritieke services.
• Fouten in Circuit Breaker op een goede manier afhandelen: Uw applicatie moet in staat zijn om `CircuitBreakerError`-uitzonderingen op een goede manier af te handelen, door alternatieve reacties of fallback-mechanismen aan de gebruiker te bieden. Ontwerp voor geleidelijke degradatie.
• Houd rekening met idempotentie: Zorg ervoor dat bewerkingen die door uw applicatie worden uitgevoerd idempotent zijn, vooral bij het gebruik van retry-mechanismen. Dit voorkomt onbedoelde neveneffecten als een verzoek meerdere keren wordt uitgevoerd als gevolg van een service-uitval en nieuwe pogingen.
• Gebruik Circuit Breakers in combinatie met andere fouttolerantiepatronen: Het Circuit Breaker-patroon werkt goed met andere fouttolerantiepatronen zoals nieuwe pogingen en schotten om een uitgebreide oplossing te bieden. Dit creëert een gelaagde verdediging.
• Documenteer uw Circuit Breaker-configuratie: Documenteer duidelijk de configuratie van uw Circuit Breakers, inclusief de faaldrempel, de time-out voor opnieuw proberen en alle andere relevante parameters. Dit zorgt voor onderhoudbaarheid en maakt het oplossen van problemen gemakkelijk.

Real-World Voorbeelden en Mondiale Impact

Het Circuit Breaker-patroon wordt veel gebruikt in verschillende industrieën en applicaties over de hele wereld. Enkele voorbeelden zijn:

• E-commerce: Bij het verwerken van betalingen of interactie met voorraadsystemen. (bijv. retailers in de Verenigde Staten en Europa gebruiken Circuit Breakers om storingen in betalingsgateways af te handelen.)
• Financiële diensten: In online banking- en handelsplatforms, om te beschermen tegen verbindingsproblemen met externe API's of marktgegevensfeeds. (bijv. wereldwijde banken gebruiken Circuit Breakers om realtime beurskoersen van beurzen over de hele wereld te beheren.)
• Cloud computing: Binnen microservices-architecturen, om servicefouten af te handelen en de beschikbaarheid van applicaties te behouden. (bijv. grote cloudproviders zoals AWS, Azure en Google Cloud Platform gebruiken intern Circuit Breakers om serviceproblemen af te handelen.)
• Gezondheidszorg: In systemen die patiëntgegevens verstrekken of interageren met API's van medische apparaten. (bijv. ziekenhuizen in Japan en Australië gebruiken Circuit Breakers in hun patiëntenbeheersystemen.)
• Reisindustrie: Bij communicatie met reserveringssystemen voor luchtvaartmaatschappijen of hotelservices. (bijv. reisbureaus die in meerdere landen actief zijn, gebruiken Circuit Breakers om om te gaan met onbetrouwbare externe API's.)

Deze voorbeelden illustreren de veelzijdigheid en het belang van het Circuit Breaker-patroon bij het bouwen van robuuste en betrouwbare applicaties die storingen kunnen doorstaan en een naadloze gebruikerservaring kunnen bieden, ongeacht de geografische locatie van de gebruiker.

Geavanceerde overwegingen

Naast de basisprincipes zijn er meer geavanceerde onderwerpen om te overwegen:

• Schotpatroon: Combineer Circuit Breakers met het Schotpatroon om storingen te isoleren. Het schotpatroon beperkt het aantal gelijktijdige verzoeken aan een bepaalde service, waardoor wordt voorkomen dat één mislukte service het hele systeem platlegt.
• Beperking van de snelheid: Implementeer snelheidsbeperking in combinatie met Circuit Breakers om services te beschermen tegen overbelasting. Dit helpt voorkomen dat een stortvloed aan verzoeken een service overweldigt die al moeite heeft.
• Aangepaste staatsovergangen: U kunt de staatsovergangen van de Circuit Breaker aanpassen om complexere foutafhandelingslogica te implementeren.
• Gedistribueerde Circuit Breakers: In een gedistribueerde omgeving hebt u mogelijk een mechanisme nodig om de staat van Circuit Breakers over meerdere instanties van uw applicatie te synchroniseren. Overweeg het gebruik van een gecentraliseerde configuratieopslag of een gedistribueerd vergrendelingsmechanisme.
• Monitoring en dashboards: Integreer uw Circuit Breaker met monitoring- en dashboardtools om realtime inzicht te bieden in de gezondheid van uw services en de prestaties van uw Circuit Breakers.

Conclusie

Het Circuit Breaker-patroon is een cruciaal hulpmiddel voor het bouwen van fouttolerante en veerkrachtige Python-applicaties, met name in de context van gedistribueerde systemen en microservices. Door dit patroon te implementeren, kunt u de stabiliteit, beschikbaarheid en gebruikerservaring van uw applicaties aanzienlijk verbeteren. Van het voorkomen van cascade-storingen tot het op een goede manier afhandelen van fouten, de Circuit Breaker biedt een proactieve aanpak voor het beheren van de inherente risico's die gepaard gaan met complexe softwaresystemen. Het effectief implementeren ervan, in combinatie met andere fouttolerantietechnieken, zorgt ervoor dat uw applicaties zijn voorbereid om de uitdagingen van een constant evoluerend digitaal landschap aan te gaan.

Door de concepten te begrijpen, best practices te implementeren en gebruik te maken van beschikbare Python-bibliotheken, kunt u applicaties creëren die robuuster, betrouwbaarder en gebruiksvriendelijker zijn voor een wereldwijd publiek.