Avant les microservices, essayez le monolithe modulaire

Par Hamza Mechtaly · · 3 min de lecture

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.

Monolithe modulaire et microservices

« 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