Architecture événementielle en Go : Construisons les systèmes réactifs du futur

Pourquoi l'architecture événementielle en Go est-elle la nouvelle ceinture noire du développement ?

Imaginez un orchestre où chaque musicien joue sa partition sans attendre le chef d'orchestre, tout en créant une symphonie parfaite. C'est exactement ainsi que fonctionne l'architecture événementielle en Go — chaque service vit sa propre vie, réagit aux événements et en produit de nouveaux, sans bloquer le flux général.

Dans un monde où les utilisateurs exigent une réaction instantanée et où les systèmes traitent des millions de requêtes par seconde, les API REST synchrones commencent à "s'étouffer". Go, avec ses goroutines légères et son support natif de la concurrence, devient le langage idéal pour construire des systèmes réactifs. Mais comment transformer le chaos des appels asynchrones en une architecture cohérente ? Commençons.

Qu'est-ce que l'architecture événementielle (EDA) et pourquoi Go ?

L'architecture événementielle en Go est un paradigme où les composants du système communiquent via des événements, et non par des appels directs. Au lieu que le service A attende la réponse du service B, il publie simplement un message dans un courtier, et B le récupère quand il est prêt.

Pourquoi Go est-il idéal pour l'EDA ?

\n
• Goroutines — des "threads" bon marché pour le traitement parallèle des événements (on peut en lancer un million sans problème)
\n
• Canaux — un mécanisme intégré pour transmettre des événements entre goroutines
\n
• Compilation rapide — les itérations dans les microservices deviennent fulgurantes
\n
• Simplicité — moins de "magie", plus de contrôle
\n

Construisons notre premier système événementiel en Go : du simple au complexe

Niveau 1 : Événements internes via les canaux

Commençons par les bases. Imaginez que nous écrivons un système de surveillance de serveur. Chaque événement (baisse de mémoire, augmentation du CPU) doit être traité de manière asynchrone.

package main\n\nimport (\n    "fmt"\n    "math/rand"\n    "time"\n)\n\ntype Event struct {\n    Type    string\n    Payload interface{}\n}\n\nfunc main() {\n    // Créons un canal pour les événements\n    eventChannel := make(chan Event, 100)\n    \n    // Producteur : générons des événements\n    go func() {\n        for {\n            time.Sleep(time.Duration(rand.Intn(1000)) * time.Millisecond)\n            event := Event{\n                Type: "system.memory.alert",\n                Payload: map[string]interface{}{\n                    "usage_pct": rand.Float64() * 100,\n                    "timestamp": time.Now(),\n                },\n            }\n            eventChannel <- event\n        }\n    }()\n    \n    // Consommateur : traitons les événements\n    go func() {\n        for event := range eventChannel {\n            fmt.Printf("Événement reçu : %s\\n", event.Type)\n            processEvent(event)\n        }\n    }()\n    \n    time.Sleep(5 * time.Second)\n}\n\nfunc processEvent(e Event) {\n    // Simulation de traitement\n    time.Sleep(200 * time.Millisecond)\n    fmt.Printf("Traité : %v\\n", e.Payload)\n}

C'est la base, mais pour la production, il faut quelque chose de plus. Lorsque le nombre de services dépasse la dizaine, les courtiers de messages entrent en scène.

Niveau 2 : Architecture événementielle en Go avec NATS

NATS est un courtier léger qui s'entend parfaitement avec Go. Il est plus rapide que RabbitMQ et plus simple que Kafka.

package main\n\nimport (\n    "log"\n    "time"\n    "github.com/nats-io/nats.go"\n)\n\ntype OrderEvent struct {\n    OrderID string    `json:"order_id"`\n    Status  string    `json:"status"`\n    Amount  float64   `json:"amount"`\n    Time    time.Time `json:"time"`\n}\n\nfunc main() {\n    // Connectons-nous à NATS\n    nc, err := nats.Connect(nats.DefaultURL)\n    if err != nil {\n        log.Fatal(err)\n    }\n    defer nc.Close()\n    \n    // Publions un événement (producteur)\n    event := OrderEvent{\n        OrderID: "ORD-12345",\n        Status:  "created",\n        Amount:  299.99,\n        Time:    time.Now(),\n    }\n    \n    data, _ := json.Marshal(event)\n