Avant les microservices, essayez le monolithe modulaire
Les microservices règlent des problèmes d’organisation, pas de code. Pourquoi je recommande souvent de commencer par un monolithe bien découpé, et comment le construire.

« On va partir sur des microservices. » J’entends cette phrase au tout début de beaucoup de projets, souvent avant qu’on sache précisément ce que l’application va faire. Et je réponds presque toujours la même chose : pas encore.
Ce que les microservices règlent vraiment
Les microservices ne rendent pas le code meilleur. Ils permettent surtout à plusieurs équipes de livrer indépendamment : chacune déploie son service à son rythme, avec sa base de données, sans attendre les autres. C’est un outil d’organisation avant d’être un outil technique.
En échange, on paie cher :
- des appels réseau là où il y avait des appels de méthode, avec leurs pannes et leurs latences ;
- des transactions qui ne tiennent plus dans une seule base ;
- une supervision, un traçage et des déploiements à multiplier par le nombre de services ;
- des contrats d’API à faire évoluer sans casser les autres.
Pour une équipe de six personnes, c’est souvent beaucoup de complexité pour un bénéfice qu’on n’utilise pas.
Le monolithe modulaire
L’alternative que je recommande pour démarrer : une seule application, déployée en un seul bloc, mais découpée en modules aux frontières strictes. Chaque module correspond à un domaine métier (commandes, facturation, catalogue…), possède ses données et n’expose qu’une interface publique aux autres.
En Java, ça peut ressembler à ceci :
com.acme.facturation
api/ // ce que les autres modules ont le droit d’appeler
internal/ // tout le reste, invisible de l’extérieur
com.acme.commandes
api/
internal/Les modules Java (JPMS), Spring Modulith ou de simples tests d’architecture avec ArchUnit permettent de faire respecter ces frontières automatiquement. Sans cette vérification, le monolithe modulaire redevient un monolithe tout court en quelques mois.
Les règles qui comptent
- Pas de table partagée. Chaque module possède ses tables ; un autre module passe par son API, jamais par une requête SQL directe.
- Des échanges explicites. Un module en informe un autre par un appel à son API ou par un événement interne, pas en modifiant ses données.
- Un module, une équipe quand l’équipe grandit, avec un responsable clair.
Le jour où il faut découper
Si ces règles sont respectées, extraire un module en service séparé devient un travail raisonnable : l’interface existe déjà, les données sont déjà isolées. On le fait quand on a une vraie raison :
- une équipe qui doit livrer à un rythme très différent des autres ;
- un module qui a besoin de monter en charge seul (un moteur de calcul, un import massif) ;
- une technologie différente justifiée pour une partie précise.
À ce moment-là, on sait exactement où couper, parce que le code nous l’a montré.
En pratique
Commencer par un monolithe modulaire, ce n’est pas renoncer aux microservices. C’est retarder une décision coûteuse jusqu’au moment où l’on dispose des informations pour la prendre. Et dans beaucoup de cas, ce moment n’arrive jamais : l’application reste un monolithe propre, simple à déployer et à faire évoluer. Ce n’est pas un échec, c’est souvent le meilleur résultat possible.
À lire aussi
- Déployer sans interruption : rolling, blue-green, canary et base de donnéesComment mettre en production en pleine journée sans coupure : les trois stratégies de déploiement, les sondes de santé et les migrations de base de données en deux temps.
- Observabilité : logs, métriques et traces, à quoi sert chacunLes quatre signaux à surveiller, des logs structurés, des traces avec OpenTelemetry et des alertes basées sur les SLO : comment je rends une application observable.
- Un pipeline GitLab CI propre pour une application Java et MavenCache Maven, étapes parallèles, rapports de tests, SonarQube, publication dans Nexus et règles d’exécution : un .gitlab-ci.yml commenté pour une application Java.