Résilience des microservices : implémenter le pattern Outbox et Circuit Breaker en Go

Pattern Outbox PostgreSQL, verrouillage SKIP LOCKED et disjoncteur gobreaker : le guide d'ingénierie Go pour des microservices résilients.

Résilience des microservices : implémenter le pattern Outbox et Circuit Breaker en Go

1. Le problème : l'illusion de la transaction distribuée et les pannes en cascade

Dans une architecture microservices distribuée, deux défaillances classiques menacent en permanence la cohérence des données et la disponibilité du système : le problème du Dual-Write (double écriture) et la propagation des pannes en cascade.

Le piège du Dual-Write

Lorsqu'un service doit effectuer une action métier (par exemple, enregistrer une commande en base de données PostgreSQL) et avertir le reste du système en publiant un événement sur un bus de messages (Kafka ou RabbitMQ), l'implémentation naïve consiste à exécuter la requête SQL, puis à appeler l'API du courtier de messages :

// Approche naïve vulnérable au Dual-Write
err := db.Exec("INSERT INTO orders ...")
if err != nil {
return err
}
err = kafkaProducer.Publish("order_created", event) // Si Kafka est hors ligne, l'événement est perdu !

Cette approche repose sur l'illusion qu'un appel réseau vers un bus de messages distant réussira systématiquement après une transaction SQL. Si le réseau vacille, si le courtier subit une panne éphémère ou si le processus Go plante entre la validation SQL (commit) et la publication, la base de données enregistre la commande mais l'événement n'est jamais émis. Les services de facturation, de stock ou de livraison ne seront jamais notifiés, provoquant une désynchronisation grave de l'état du système.

Inversement, tenter de publier l'événement avant de valider la transaction SQL crée le risque d'émettre un événement fantôme si la base de données rejette la transaction en raison d'une contrainte d'unicité ou d'un verrou.

La réaction en chaîne et l'épuisement des goroutines

Parallèlement aux problèmes de cohérence, la dépendance directe entre microservices crée un risque d'effondrement global. Si un service applicatif effectue des appels HTTP ou gRPC synchrones vers un service aval qui devient lent ou indisponible, les requêtes entrantes s'accumulent. En Go, chaque requête entrante consomme une goroutine et de la mémoire. En quelques secondes sous forte charge, des milliers de goroutines se retrouvent bloquées en attente de réponse, épuisant les ressources du serveur jusqu'au plantage complet du service appelant.

Pour bâtir un système distribué hautement résilient en Go, il est indispensable de séparer physiquement l'émission d'événements de la transaction SQL via le pattern Transactional Outbox, et de protéger les appels réseau sortants contre les pannes en cascade grâce à un disjoncteur logiciel (Circuit Breaker).


2. La solution étape par étape : implémenter l'Outbox Pattern et le Circuit Breaker en Go

La mise en œuvre d'une architecture résiliente repose sur deux mécanismes complémentaires : le stockage atomique des événements en base pour l'Outbox, et l'encapsulation des appels distants pour le Circuit Breaker.

Étape 1 : Créer la table Outbox et exécuter la transaction atomique

Plutôt que d'envoyer l'événement directement sur le réseau, la transaction SQL enregistre simultanément la donnée métier et l'événement correspondant dans une table dédiée nommée outbox.

Créez d'abord la table dans PostgreSQL :

CREATE TABLE outbox_events (
id UUID PRIMARY KEY,
aggregate_type VARCHAR(255) NOT NULL,
aggregate_id VARCHAR(255) NOT NULL,
type VARCHAR(255) NOT NULL,
payload JSONB NOT NULL,
created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
processed_at TIMESTAMP WITH TIME ZONE NULL
);

CREATE INDEX idx_outbox_unprocessed ON outbox_events (created_at) WHERE processed_at IS NULL;

Dans votre code Go, utilisez une transaction SQL unique pour insérer l'entité métier et le message Outbox :

func CreateOrder(ctx context.Context, db *sql.DB, order Order) error {
tx, err := db.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()

// 1. Inscription de la commande métier
_, err = tx.ExecContext(ctx, "INSERT INTO orders (id, amount) VALUES ($1, $2)", order.ID, order.Amount)
if err != nil {
return err
}

// 2. Écriture atomique de l'événement dans la table outbox
payload, _ := json.Marshal(order)
_, err = tx.ExecContext(ctx,
"INSERT INTO outbox_events (id, aggregate_type, aggregate_id, type, payload) VALUES ($1, $2, $3, $4, $5)",
uuid.New(), "Order", order.ID, "OrderCreated", payload,
)
if err != nil {
return err
}

return tx.Commit()
}

Étape 2 : Implémenter le relayeur d'événements (Outbox Relay) avec verrouillage sécurisé

Un composant d'arrière-plan en Go scrute périodiquement la table outbox pour dépiler les messages en attente et les publier sur le bus. Pour éviter que plusieurs répliques de votre service ne traitent les mêmes événements en parallèle, utilisez la clause SQL FOR UPDATE SKIP LOCKED.

func StartOutboxRelay(ctx context.Context, db *sql.DB, publisher MessagePublisher) {
ticker := time.NewTicker(1 * time.Second)
defer ticker.Stop()

for {
select {
case <-ctx.Done():
return
case <-ticker.C:
processOutboxBatch(ctx, db, publisher)
}
}
}

func processOutboxBatch(ctx context.Context, db *sql.DB, publisher MessagePublisher) {
tx, err := db.BeginTx(ctx, nil)
if err != nil {
return
}
defer tx.Rollback()

// Sélection sécurisée sans blocage pour les instances concurrentes
rows, err := tx.QueryContext(ctx, `
SELECT id, type, payload FROM outbox_events
WHERE processed_at IS NULL
ORDER BY created_at ASC
LIMIT 50 FOR UPDATE SKIP LOCKED
`)
if err != nil {
return
}
defer rows.Close()

var eventsToMark []uuid.UUID
for rows.Next() {
var id uuid.UUID
var eventType string
var payload []byte
if err := rows.Scan(&id, &eventType, &payload); err != nil {
continue
}

if err := publisher.Publish(eventType, payload); err == nil {
eventsToMark = append(eventsToMark, id)
}
}

// Marquage des événements publiés
for _, id := range eventsToMark {
tx.ExecContext(ctx, "UPDATE outbox_events SET processed_at = NOW() WHERE id = $1", id)
}

tx.Commit()
}

Étape 3 : Protéger les appels distants avec gobreaker

Pour empêcher la propagation des pannes lors des appels vers d'autres services, intégrez le composant Circuit Breaker standard de Go (github.com/sony/gobreaker/v2).

import "github.com/sony/gobreaker/v2"

type ClientResilient struct {
httpClient *http.Client
cb *gobreaker.CircuitBreaker[[]byte]
}

func NewClientResilient() *ClientResilient {
settings := gobreaker.Settings{
Name: "ExternalPaymentAPI",
MaxRequests: 3, // Requêtes autorisées en état HALF-OPEN
Interval: 10 * time.Second, // Fenêtre glissante de comptage
Timeout: 30 * time.Second, // Durée du maintien en état OPEN
ReadyToTrip: func(counts gobreaker.Counts) bool {
failureRatio := float64(counts.TotalFailures) / float64(counts.Requests)
return counts.Requests >= 5 && failureRatio >= 0.6 // Ouverture si > 60% d'échecs sur 5 requêtes
},
}

return &ClientResilient{
httpClient: &http.Client{Timeout: 5 * time.Second},
cb: gobreaker.NewCircuitBreaker[[]byte](settings),
}
}

func (c *ClientResilient) CallService(url string) ([]byte, error) {
// Encapsulation de l'appel dans le disjoncteur
return c.cb.Execute(func() ([]byte, error) {
resp, err := c.httpClient.Get(url)
if err != nil {
return nil, err
}
defer resp.Body.Close()

if resp.StatusCode >= 500 {
return nil, fmt.Errorf("erreur serveur distant: %d", resp.StatusCode)
}

return io.ReadAll(resp.Body)
})
}


3. Les pièges à éviter : du doublon de message à l'idempotence manquée

Bien que ces deux modèles améliorent considérablement la robustesse d'un système distribué, plusieurs pièges d'implémentation doivent être anticipés.

Le piège de la garantie d'émission : comprendre la livraison At-Least-Once

Le pattern Outbox garantit que chaque événement sera émis au moins une fois (At-Least-Once delivery). Il est techniquement impossible de garantir une livraison exacte au niveau réseau. Si le relayeur Go publie un message sur Kafka mais subit un crash ou un redémarrage juste avant d'exécuter la commande SQL UPDATE outbox_events SET processed_at = NOW(), le message sera réexpédié lors de la tentative suivante.

La solution obligatoire : l'idempotence consommateur

Chaque service consommateur doit être conçu de façon rigoureusement idempotente. Deux stratégies d'ingénierie s'imposent :

  • Clé d'idempotence (Inbox Pattern) : Conserver la liste des identifiants d'événements (event_id) déjà traités dans une table processed_events avec une contrainte de clé primaire. Si un événement avec la même clé réapparaît, la transaction est ignorée sans erreur.
  • Opérations SQL idempotentes : Préférer des requêtes réassortissantes ou conditionnelles (UPDATE account SET balance = balance - 50 WHERE transaction_id = '...') plutôt que des incréments aveugles.

La mauvaise configuration des seuils du Circuit Breaker

Définir un seuil de basculement (ReadyToTrip) trop agressif peut fermer l'accès à un service distant en raison de micro-coupures réseau passagères. À l'inverse, un délai de réinitialisation (Timeout) trop court ne laisse pas le temps au service aval de vider ses files d'attente et de récupérer, provoquant une oscillation permanente entre l'état OPEN et HALF-OPEN.


4. Pour aller plus loin : CDC avec Debezium et supervision OpenTelemetry

Pour pousser l'architecture au niveau industriel et traiter des volumes massifs de données, deux évolutions d'ingénierie peuvent être apportées.

Remplacer la scrutation SQL par la capture de données de changement (CDC)

La méthode de scrutation par SELECT ... FOR UPDATE SKIP LOCKED génère une charge de requêtes répétitives sur la base de données PostgreSQL. Sur des systèmes traitant des milliers de transactions par seconde, il est préférable d'adopter la capture de changements de données (Change Data Capture ou CDC) via des outils comme Debezium ou la bibliothèque Go pglogrepl.

Au lieu de lire la table outbox, un composant écoute directement le journal de pré-écriture de PostgreSQL (Write-Ahead Log ou WAL). Chaque insertion dans la table outbox est immédiatement interceptée dans le flux de réplication logique et poussée vers Kafka avec une latence inférieure à la milliseconde et sans aucune charge d'interrogation SQL.

Superviser les basculements et la profondeur de la file

Pour garantir une observabilité optimale de votre infrastructure en production, exportez les métriques de votre résilience vers Prometheus et OpenTelemetry :

  • Profondeur de la table Outbox : Nombre d'enregistrements dont processed_at IS NULL. Une hausse prolongée de cette métrique alerte immédiatement sur un blocage du courtier de messages.
  • Compteur de transitions d'état du Circuit Breaker : Suivez les passages à l'état OPEN pour déclencher des alertes PagerDuty avant que les utilisateurs finaux ne constatent une dégradation de service.

En combinant le pattern Outbox et les disjoncteurs logiciels en Go, vous dotez votre architecture microservices d'une tolérance aux pannes de classe industrielle, capable de supporter les pannes réseau et les indisponibilités matérielles sans jamais perdre la moindre donnée métier.


Sources :

  1. DEV Community — Circuit Breaker Patterns in Go Microservices
  2. Rost Glukhov — Circuit Breaker Pattern in Go: Stop Cascading Failures
  3. OneUptime — How to Implement the Transactional Outbox Pattern in Go
  4. Daily.dev — How to implement the Outbox pattern in Go and Postgres
  5. GitHub — sony/gobreaker: Circuit Breaker implemented in Go