Formations — 1 037 leçons en français

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.

Lire l'explication détaillée et faire le quiz →

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.