Accueil › Spring Boot › Principes des microservices
Principes des microservices
Microservices avec Spring Cloudavance
Un monolithe est déployé comme une seule unité ; des microservices sont plusieurs applications indépendantes, déployées séparément, communiquant par le réseau. Le critère de découpage qui fonctionne le mieux est le bounded context (Domain-Driven Design) : chaque service porte une capacité métier complète — pas une couche technique — avec sa propre logique et sa propre base de données.
| Monolithe | Microservices | |
|---|---|---|
| Déploiement | Une unité | Indépendant par service |
| Communication interne | Appels de méthode (en mémoire) | Réseau (REST, messages) |
| Transaction | ACID, immédiate | Cohérence éventuelle |
| Scalabilité | Toute l'application | Service par service |
| Complexité opérationnelle | Faible | Élevée (réseau, observabilité, déploiement) |
| Autonomie des équipes | Limitée (code partagé) | Forte, si le découpage est bon |
Les microservices ont un coût réel : latence et pannes réseau, cohérence éventuelle des données au lieu de transactions, observabilité distribuée à mettre en place, et un déploiement à orchestrer par service. Ce coût ne se justifie que s'il achète quelque chose — autonomie d'équipes, scalabilité différenciée, déploiements indépendants et fréquents. Une équipe qui démarre un produit gagne en général à commencer par un monolithe modulaire : une seule application, mais avec des frontières internes nettes qui préparent un découpage ultérieur si le besoin se confirme.
Les termes à connaître
- Bounded context
Concept du Domain-Driven Design : une frontière explicite autour d'un sous-domaine métier (facturation, catalogue, expédition…), à l'intérieur de laquelle un modèle et un vocabulaire restent cohérents. C'est la base la plus fiable pour découper des microservices — plus fiable qu'un découpage technique (par couche) ou organisationnel arbitraire.
- Une base de données par service
Chaque microservice possède son propre schéma, inaccessible directement aux autres services. C'est ce qui garantit le découplage : sans cela, deux services partageant une base sont couplés par le schéma, même s'ils communiquent par API.
- Cohérence éventuelle (eventual consistency)
Dans un système distribué, les données de plusieurs services ne sont pas toujours synchronisées à l'instant T. Elles convergent avec un délai (via des événements, par exemple), au lieu d'une transaction unique et immédiate comme dans un monolithe.
- Communication synchrone vs asynchrone
Synchrone (REST, gRPC) : le service appelant attend la réponse, couplage temporel fort. Asynchrone (message, événement) : l'appelant publie et continue, le traitement se fait indépendamment — découplage temporel, mais complexité de traçabilité en plus.
- Monolithe modulaire
Une seule application déployée, mais découpée en modules internes aux frontières nettes (packages séparés, pas de dépendances croisées non maîtrisées). Étape intermédiaire courante avant de découper en microservices, ou alternative durable quand la complexité distribuée ne se justifie pas.
- 12-factor app
Ensemble de bonnes pratiques pour des applications cloud-native : configuration dans l'environnement (pas dans le code), dépendances explicites, processus sans état, logs traités comme des flux d'événements, parité dev/prod… Base commune aux architectures microservices modernes.
- Complexité accidentelle vs essentielle
La complexité essentielle vient du métier (elle existe quoi qu'on fasse). La complexité accidentelle vient des choix d'architecture (réseau, sérialisation, orchestration…). Les microservices échangent de la complexité métier contre de la complexité distribuée : ce n'est un bon calcul que si le métier ou l'organisation le justifie.
Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.