Étude de cas
Starter kit microservices événementiels
Projet personnel — architecture événementielle de bout en bout, de Rust à Angular
- Rust
- Kafka
- Quarkus
- Java
- PostgreSQL
- Spring Boot
01
Contexte et enjeu
Chaîne événementielle complète : simulateurs d'émission en Rust, Kafka, services de traitement Quarkus, PostgreSQL, passerelle API / BFF Spring Boot et frontend Angular, avec l'observabilité sur toute la chaîne. Projet personnel d'apprentissage et d'architecture. Le code et le dépôt restent privés.
Projet personnel d'apprentissage et d'architecture : reconstituer de bout en bout une chaîne de traitement événementielle, depuis les simulateurs d'émission jusqu'à l'interface de supervision.
L'objectif n'est pas un produit fini mais un terrain d'essai assumé — éprouver une architecture découplée par événements, avec une observabilité sur toute la chaîne. Le code et le dépôt restent privés.
02
Mon rôle et périmètre
Conception de l'architecture : découpage des services, définition des topics Kafka et du contrat d'événement.
Développement des simulateurs d'émission en Rust et des services de traitement en Quarkus (Java).
Mise en place de la passerelle API / BFF en Spring Boot et du frontend Angular de supervision.
03
Défis techniques
Définir un contrat d'événement tenable
Un flux événementiel oblige à décider ce qui identifie un événement, comment il est ordonné, et comment un service peut le retraiter sans produire de doublon. Ce contrat se fige vite : le changer après coup se paie sur tous les consommateurs.
Trouver le bon grain de découpage
Découper trop finement multiplie les contrats d'événements à maintenir ; découper trop grossièrement annule le bénéfice du découplage. Le bon grain se cherche en fonction du métier, pas de la technique.
Rendre la chaîne observable
Sur une chaîne asynchrone, une latence ou une erreur se voit rarement là où elle se produit : sans suivi de bout en bout d'un événement, un système distribué devient surtout plus difficile à diagnostiquer.
04
Solution et architecture
- 01
Émission
- Rust
- 02
Messagerie
- Kafka
- 03
Traitement
- Quarkus
- Java
- 04
Persistance
- PostgreSQL
- 05
Exposition
- Spring Boot
- API Gateway / BFF
- 06
Interface
- Angular
- TypeScript
Chaîne événementielle complète : simulateurs d'émission en Rust, messagerie Kafka, services de traitement Quarkus, persistance PostgreSQL, passerelle API / BFF Spring Boot et frontend Angular — avec l'observabilité en travers de toute la chaîne.
Projet d'apprentissage : l'objectif est l'architecture et la mise en pratique, pas la mise en production. Schéma complet, aucune donnée client. Chaque service garde son domaine séparé de ses adaptateurs (messagerie, persistance, exposition) : c'est là que j'ai mis en pratique l'architecture hexagonale.
05
Stack détaillée et pourquoi
- Rust
- Pourquoi ce choix — Simulateurs d'émission : binaire autonome, empreinte mémoire prévisible et bon comportement en débit soutenu — un producteur crédible pour alimenter la chaîne.
- Kafka
- Pourquoi ce choix — Journal distribué : les événements sont conservés et relisibles, et producteurs comme consommateurs sont découplés par topics plutôt que par appels directs.
- Quarkus
- Pourquoi ce choix — Services de traitement en Java avec démarrage rapide et empreinte réduite, pensés pour des consommateurs conteneurisés qui montent et descendent souvent.
- PostgreSQL
- Pourquoi ce choix — Projection de l'état métier dans un modèle relationnel : contraintes et transactions là où le flux asynchrone en a le plus besoin.
- Spring Boot
- Pourquoi ce choix — Passerelle API / BFF : point d'entrée unique pour le frontend et agrégation des lectures, en gardant les services de traitement hors du chemin des requêtes utilisateur.
- Angular
- Pourquoi ce choix — Frontend de supervision : structure par modules et services, formulaires et tableaux de suivi pour observer ce qui circule dans la chaîne.
06
Résultats
- Briques de la chaîne
- 6Émission, messagerie, traitement, persistance, exposition, interface
07
Ce que j'en retiens
Une chaîne événementielle se conçoit à l'envers : ce sont les contrats d'événements qui déterminent le découpage des services, pas l'inverse. C'est aussi le projet qui m'a fait toucher le coût réel du découplage — l'observabilité n'est pas un supplément, c'est ce qui rend l'architecture exploitable quand quelque chose se perd entre deux services.
Un besoin similaire ?
Je peux vous présenter plus en détail les choix techniques, les contraintes et les enseignements de cette réalisation.