Circuit Breaker Python: Creazione di applicazioni tolleranti ai guasti

Nel mondo dei sistemi distribuiti e dei microservizi, affrontare i guasti è inevitabile. I servizi possono diventare non disponibili a causa di problemi di rete, server sovraccarichi o bug imprevisti. Quando un servizio in errore non viene gestito correttamente, può portare a guasti a cascata, abbattendo interi sistemi. Il pattern Circuit Breaker è una potente tecnica per prevenire questi guasti a cascata e creare applicazioni più resilienti. Questo articolo fornisce una guida completa sull'implementazione del pattern Circuit Breaker in Python.

Cos'è il pattern Circuit Breaker?

Il pattern Circuit Breaker, ispirato agli interruttori automatici elettrici, funge da proxy per le operazioni che potrebbero fallire. Monitora i tassi di successo e di fallimento di queste operazioni e, quando viene raggiunta una certa soglia di guasti, "scatta" l'interruttore, impedendo ulteriori chiamate al servizio in errore. Ciò consente al servizio in errore di riprendersi senza essere sopraffatto dalle richieste e impedisce al servizio chiamante di sprecare risorse tentando di connettersi a un servizio noto per essere inattivo.

Il Circuit Breaker ha tre stati principali:

• Chiuso: L'interruttore automatico è nel suo stato normale, consentendo alle chiamate di passare al servizio protetto. Monitora il successo e il fallimento di queste chiamate.
• Aperto: L'interruttore automatico è scattato e tutte le chiamate al servizio protetto sono bloccate. Dopo un periodo di timeout specificato, l'interruttore automatico passa allo stato Half-Open.
• Half-Open: L'interruttore automatico consente un numero limitato di chiamate di prova al servizio protetto. Se queste chiamate hanno successo, l'interruttore automatico torna allo stato Chiuso. Se falliscono, torna allo stato Aperto.

Ecco una semplice analogia: immagina di provare a prelevare denaro da un bancomat. Se il bancomat non riesce ripetutamente a erogare contanti (forse a causa di un errore di sistema presso la banca), interverrebbe un Circuit Breaker. Invece di continuare a tentare prelievi che probabilmente falliranno, il Circuit Breaker bloccherebbe temporaneamente ulteriori tentativi (stato Aperto). Dopo un po', potrebbe consentire un singolo tentativo di prelievo (stato Half-Open). Se quel tentativo ha successo, il Circuit Breaker riprenderà il normale funzionamento (stato Chiuso). Se fallisce, il Circuit Breaker rimarrà nello stato Aperto per un periodo più lungo.

Perché usare un Circuit Breaker?

L'implementazione di un Circuit Breaker offre diversi vantaggi:

• Previene i guasti a cascata: bloccando le chiamate a un servizio in errore, il Circuit Breaker impedisce che il guasto si diffonda ad altre parti del sistema.
• Migliora la resilienza del sistema: il Circuit Breaker consente ai servizi in errore di riprendersi senza essere sopraffatti dalle richieste, portando a un sistema più stabile e resiliente.
• Riduce il consumo di risorse: evitando chiamate non necessarie a un servizio in errore, il Circuit Breaker riduce il consumo di risorse sia sul servizio chiamante che su quello chiamato.
• Fornisce meccanismi di fallback: quando l'interruttore è aperto, il servizio chiamante può eseguire un meccanismo di fallback, ad esempio restituendo un valore memorizzato nella cache o visualizzando un messaggio di errore, offrendo una migliore esperienza utente.

Implementazione di un Circuit Breaker in Python

Esistono diversi modi per implementare il pattern Circuit Breaker in Python. Puoi creare la tua implementazione da zero oppure utilizzare una libreria di terze parti. Qui esploreremo entrambi gli approcci.

1. Costruire un Circuit Breaker personalizzato

Iniziamo con un'implementazione personalizzata di base per comprendere i concetti fondamentali. Questo esempio utilizza il modulo `threading` per la sicurezza dei thread e il modulo `time` per la gestione dei timeout.

            
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
              
            
          

Spiegazione:

• Classe `CircuitBreaker`:
  • `__init__(self, failure_threshold, recovery_timeout)`: Inizializza l'interruttore automatico con una soglia di errore (il numero di errori prima di far scattare l'interruttore), un timeout di ripristino (il tempo di attesa prima di tentare uno stato half-open) e imposta lo stato iniziale su `CLOSED`.
  • `call(self, func, *args, **kwargs)`: Questo è il metodo principale che avvolge la funzione che si desidera proteggere. Controlla lo stato corrente dell'interruttore automatico. Se è `OPEN`, controlla se il timeout di ripristino è trascorso. In tal caso, passa a `HALF_OPEN`. In caso contrario, genera un'eccezione `CircuitBreakerError`. Se lo stato non è `OPEN`, esegue la funzione e gestisce le potenziali eccezioni.
  • `record_failure(self)`: Incrementa il conteggio degli errori e registra l'ora dell'errore. Se il conteggio degli errori supera la soglia, passa l'interruttore allo stato `OPEN`.
  • `reset(self)`: Reimposta il conteggio degli errori e passa l'interruttore allo stato `CLOSED`.
• Classe `CircuitBreakerError`: Un'eccezione personalizzata generata quando l'interruttore automatico è aperto.
• Funzione `unreliable_service()`: Simula un servizio che fallisce in modo casuale.
• Esempio di utilizzo: dimostra come utilizzare la classe `CircuitBreaker` per proteggere la funzione `unreliable_service()`.

Considerazioni chiave per l'implementazione personalizzata:

• Thread Safety: `threading.Lock()` è fondamentale per garantire la sicurezza dei thread, soprattutto in ambienti concorrenti.
• Gestione degli errori: il blocco `try...except` intercetta le eccezioni dal servizio protetto e chiama `record_failure()`.
• Transizioni di stato: la logica per la transizione tra gli stati `CLOSED`, `OPEN` e `HALF_OPEN` è implementata all'interno dei metodi `call()` e `record_failure()`.

2. Utilizzo di una libreria di terze parti: `pybreaker`

Sebbene la creazione del tuo Circuit Breaker possa essere una buona esperienza di apprendimento, l'utilizzo di una libreria di terze parti ben testata è spesso una soluzione migliore per gli ambienti di produzione. Una popolare libreria Python per l'implementazione del pattern Circuit Breaker è `pybreaker`.

Installazione:

            
pip install pybreaker

            

              
                Copy
              
            
          

Esempio di utilizzo:

            
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
              
            
          

Spiegazione:

• Installazione: il comando `pip install pybreaker` installa la libreria.
• Classe `pybreaker.CircuitBreaker`:
  • `fail_max`: specifica il numero di errori consecutivi prima che l'interruttore automatico si apra.
  • `reset_timeout`: specifica il tempo (in secondi) in cui l'interruttore automatico rimane aperto prima di passare allo stato half-open.
  • `name`: un nome descrittivo per l'interruttore automatico.
• Decoratore: il decoratore `@circuit_breaker` avvolge la funzione `unreliable_service()`, gestendo automaticamente la logica dell'interruttore automatico.
• Gestione delle eccezioni: il blocco `try...except` intercetta `pybreaker.CircuitBreakerError` quando l'interruttore è aperto e `ServiceError` (la nostra eccezione personalizzata) quando il servizio fallisce.

Vantaggi dell'utilizzo di `pybreaker`:

• Implementazione semplificata: `pybreaker` fornisce un'API pulita e facile da usare, riducendo il codice boilerplate.
• Thread Safety: `pybreaker` è thread-safe, il che lo rende adatto per applicazioni concorrenti.
• Personalizzabile: è possibile configurare vari parametri, come la soglia di errore, il timeout di ripristino e i listener di eventi.
• Event Listeners: `pybreaker` supporta i listener di eventi, consentendo di monitorare lo stato dell'interruttore automatico e di intraprendere azioni di conseguenza (ad esempio, registrazione, invio di avvisi).

3. Concetti avanzati di Circuit Breaker

Oltre all'implementazione di base, ci sono diversi concetti avanzati da considerare quando si utilizzano Circuit Breaker:

• Metriche e monitoraggio: la raccolta di metriche sulle prestazioni dei tuoi Circuit Breaker è essenziale per comprendere il loro comportamento e identificare potenziali problemi. Librerie come Prometheus e Grafana possono essere utilizzate per visualizzare queste metriche. Tieni traccia di metriche come:
• Stato del Circuit Breaker (Aperto, Chiuso, Half-Open)
• Numero di chiamate riuscite
• Numero di chiamate fallite
• Latenza delle chiamate
• Meccanismi di fallback: quando l'interruttore è aperto, è necessaria una strategia per gestire le richieste. I meccanismi di fallback comuni includono:
• Restituzione di un valore memorizzato nella cache.
• Visualizzazione di un messaggio di errore all'utente.
• Chiamata di un servizio alternativo.
• Restituzione di un valore predefinito.
• Circuit Breaker asincroni: nelle applicazioni asincrone (che utilizzano `asyncio`), dovrai utilizzare un'implementazione asincrona di Circuit Breaker. Alcune librerie offrono il supporto asincrono.
• Bulkhead: il pattern Bulkhead isola parti di un'applicazione per evitare che i guasti in una parte si propaghino ad altre. I Circuit Breaker possono essere utilizzati in combinazione con i Bulkhead per fornire una tolleranza ai guasti ancora maggiore.
• Circuit Breaker basati sul tempo: invece di tenere traccia del numero di errori, un Circuit Breaker basato sul tempo apre l'interruttore se il tempo di risposta medio del servizio protetto supera una certa soglia entro una data finestra temporale.

Esempi pratici e casi d'uso

Ecco alcuni esempi pratici di come puoi utilizzare i Circuit Breaker in diversi scenari:

• Architettura a microservizi: in un'architettura a microservizi, i servizi spesso dipendono l'uno dall'altro. Un Circuit Breaker può proteggere un servizio dall'essere sopraffatto da errori in un servizio downstream. Ad esempio, un'applicazione di e-commerce potrebbe avere microservizi separati per il catalogo prodotti, l'elaborazione degli ordini e l'elaborazione dei pagamenti. Se il servizio di elaborazione dei pagamenti diventa non disponibile, un Circuit Breaker nel servizio di elaborazione degli ordini può impedire la creazione di nuovi ordini, prevenendo un guasto a cascata.
• Connessioni al database: se la tua applicazione si connette frequentemente a un database, un Circuit Breaker può impedire tempeste di connessione quando il database non è disponibile. Considera un'applicazione che si connette a un database distribuito geograficamente. Se un'interruzione di rete influisce su una delle regioni del database, un Circuit Breaker può impedire all'applicazione di tentare ripetutamente di connettersi alla regione non disponibile, migliorando le prestazioni e la stabilità.
• API esterne: quando chiami le API esterne, un Circuit Breaker può proteggere la tua applicazione da errori e interruzioni transitori. Molte organizzazioni si affidano ad API di terze parti per varie funzionalità. Incapsulando le chiamate API con un Circuit Breaker, le organizzazioni possono creare integrazioni più robuste e ridurre l'impatto dei guasti delle API esterne.
• Logica di ripetizione: i Circuit Breaker possono funzionare in combinazione con la logica di ripetizione. Tuttavia, è importante evitare ripetizioni aggressive che possono aggravare il problema. Il Circuit Breaker dovrebbe impedire le ripetizioni quando il servizio è noto per essere non disponibile.

Considerazioni globali

Quando si implementano Circuit Breaker in un contesto globale, è importante considerare quanto segue:

• Latenza di rete: la latenza di rete può variare in modo significativo a seconda della posizione geografica dei servizi chiamanti e chiamati. Regola di conseguenza il timeout di ripristino. Ad esempio, le chiamate tra servizi in Nord America ed Europa potrebbero riscontrare una latenza maggiore rispetto alle chiamate all'interno della stessa regione.
• Fusi orari: assicurati che tutti i timestamp vengano gestiti in modo coerente tra i diversi fusi orari. Usa UTC per l'archiviazione dei timestamp.
• Interruzioni regionali: considera la possibilità di interruzioni regionali e implementa Circuit Breaker per isolare i guasti a regioni specifiche.
• Considerazioni culturali: quando si progettano meccanismi di fallback, considera il contesto culturale dei tuoi utenti. Ad esempio, i messaggi di errore dovrebbero essere localizzati e culturalmente appropriati.

Best practice

Ecco alcune best practice per l'utilizzo efficace dei Circuit Breaker:

• Inizia con impostazioni conservative: inizia con una soglia di errore relativamente bassa e un timeout di ripristino più lungo. Monitora il comportamento del Circuit Breaker e regola le impostazioni in base alle esigenze.
• Utilizza meccanismi di fallback appropriati: scegli meccanismi di fallback che offrano una buona esperienza utente e riducano al minimo l'impatto dei guasti.
• Monitora lo stato del Circuit Breaker: tieni traccia dello stato dei tuoi Circuit Breaker e imposta avvisi per avvisarti quando un interruttore è aperto.
• Testa il comportamento del Circuit Breaker: simula i guasti nel tuo ambiente di test per assicurarti che i tuoi Circuit Breaker funzionino correttamente.
• Evita l'eccessiva dipendenza dai Circuit Breaker: i Circuit Breaker sono uno strumento per mitigare i guasti, ma non sostituiscono la risoluzione delle cause sottostanti di tali guasti. Indaga e correggi le cause principali dell'instabilità del servizio.
• Considera il tracing distribuito: integra strumenti di tracing distribuiti (come Jaeger o Zipkin) per tenere traccia delle richieste su più servizi. Questo può aiutarti a identificare la causa principale dei guasti e a comprendere l'impatto dei Circuit Breaker sull'intero sistema.

Conclusione

Il pattern Circuit Breaker è uno strumento prezioso per la creazione di applicazioni tolleranti ai guasti e resilienti. Prevenendo i guasti a cascata e consentendo ai servizi in errore di riprendersi, i Circuit Breaker possono migliorare significativamente la stabilità e la disponibilità del sistema. Sia che tu scelga di creare la tua implementazione o di utilizzare una libreria di terze parti come `pybreaker`, comprendere i concetti fondamentali e le best practice del pattern Circuit Breaker è essenziale per sviluppare software robusto e affidabile negli odierni ambienti distribuiti complessi.

Implementando i principi delineati in questa guida, puoi creare applicazioni Python più resilienti ai guasti, garantendo una migliore esperienza utente e un sistema più stabile, indipendentemente dalla tua portata globale.