Circuit Breaker

Le Circuit Breaker est un pattern architectural essentiel pour construire des systèmes distribués résilients. Inspiré des disjoncteurs électriques, il surveille les appels entre services et coupe automatiquement la connexion lorsqu'un taux d'échec dépasse un seuil défini. Ce mécanisme prévient les effets en cascade et permet aux services de se rétablir sans être submergés par des requêtes vouées à l'échec.

Fondements du Circuit Breaker

• Trois états principaux : Closed (normal), Open (coupé), Half-Open (test de récupération)
• Surveillance en temps réel des taux d'échec et des temps de réponse
• Basculement automatique entre états selon des seuils configurables
• Protection contre les défaillances en cascade dans les architectures microservices

Avantages pour les systèmes distribués

• Amélioration de la résilience globale du système face aux défaillances partielles
• Réduction de la charge sur les services défaillants, leur permettant de récupérer
• Prévention de l'effet domino où une défaillance propage l'instabilité
• Amélioration de l'expérience utilisateur avec des échecs rapides plutôt que des timeouts longs
• Métriques précises sur la santé des dépendances externes

Exemple concret d'implémentation

class CircuitBreaker {
  private state: 'CLOSED' | 'OPEN' | 'HALF_OPEN' = 'CLOSED';
  private failureCount = 0;
  private successCount = 0;
  private lastFailureTime?: number;
  
  constructor(
    private threshold: number = 5,
    private timeout: number = 60000,
    private halfOpenAttempts: number = 3
  ) {}

  async execute<T>(fn: () => Promise<T>): Promise<T> {
    if (this.state === 'OPEN') {
      if (Date.now() - this.lastFailureTime! >= this.timeout) {
        this.state = 'HALF_OPEN';
        this.successCount = 0;
      } else {
        throw new Error('Circuit breaker is OPEN');
      }
    }

    try {
      const result = await fn();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
      throw error;
    }
  }

  private onSuccess(): void {
    this.failureCount = 0;
    
    if (this.state === 'HALF_OPEN') {
      this.successCount++;
      if (this.successCount >= this.halfOpenAttempts) {
        this.state = 'CLOSED';
      }
    }
  }

  private onFailure(): void {
    this.failureCount++;
    this.lastFailureTime = Date.now();
    
    if (this.failureCount >= this.threshold) {
      this.state = 'OPEN';
    }
  }

  getState() {
    return this.state;
  }
}

Cette implémentation montre les transitions d'état essentielles : le circuit se ferme après des succès consécutifs en mode Half-Open, s'ouvre après dépassement du seuil d'échecs, et teste périodiquement la récupération du service.

Mise en œuvre stratégique

1. Identifier les points d'intégration critiques entre services où implémenter le pattern
2. Définir des seuils adaptés au contexte : nombre d'échecs, fenêtre temporelle, timeout
3. Implémenter une stratégie de fallback : cache, réponse par défaut, ou dégradation gracieuse
4. Configurer la période de test en Half-Open pour valider la récupération du service
5. Intégrer des métriques et alertes pour monitorer les ouvertures de circuits
6. Tester les scénarios de défaillance en environnement de staging avec chaos engineering

Outils et bibliothèques

• Resilience4j (Java) : bibliothèque légère avec support Circuit Breaker, Retry, Rate Limiter
• Polly (.NET) : framework de résilience avec politiques composables
• Hystrix (Netflix, maintenance mode) : référence historique du pattern, remplacé par Resilience4j
• Opossum (Node.js) : implémentation simple et performante pour JavaScript/TypeScript
• Istio/Envoy : Circuit Breaker au niveau service mesh pour architecture cloud-native

Le Circuit Breaker est devenu indispensable dans les architectures modernes distribuées, où les défaillances sont inévitables. En isolant automatiquement les composants défaillants, ce pattern transforme les systèmes fragiles en infrastructures résilientes capables de maintenir un niveau de service acceptable même face à des pannes partielles. Son implémentation stratégique réduit significativement les incidents de production et améliore la satisfaction utilisateur.