Les Developpeurs

Choisir une architecture microservices pour le développement web : le guide

On vous a sûrement déjà vendu les microservices comme la solution moderne. Mais leur vrai coût est opérationnel, pas technique — et dans la majorité des cas, un monolithe modulaire bien structuré fait mieux le travail. Voici pourquoi dire non est souvent la bonne réponse.

Choisir une architecture microservices pour le développement web : le guide

On m'a posé la question trois fois le même mois. Trois projets différents, trois clients différents, la même phrase : « On part sur des microservices, non ? » À chaque fois, la réponse était non. Et à chaque fois, j'ai dû argumenter pendant quarante minutes pour expliquer pourquoi la réponse la plus moderne n'était pas la bonne.

Le sujet est piégé. Choisir une architecture microservices pour développement web n'est pas une décision technique isolée : c'est une décision d'organisation, de budget et de tolérance à la douleur opérationnelle. Et dans la majorité des cas que j'ai croisés, cette décision a été prise pour de mauvaises raisons — parce que Netflix le fait, parce qu'un article de blog l'affirmait, ou parce que quelqu'un dans la réunion voulait écrire « microservices » sur un CV.

Points clés à retenir

  • Un microservice est un service déployable indépendamment, autour d'un domaine métier précis ; une API est une interface, pas une unité de déploiement.
  • Le vrai coût des microservices n'est pas la conception, c'est l'exploitation : observabilité, orchestration, debugging distribué.
  • Le modulith (monolithe modulaire) couvre la majorité des besoins, avec une frontière claire prête à être découpée.
  • Le critère de bascule le plus fiable est organisationnel : quand plusieurs équipes se bloquent mutuellement sur un même déploiement.
  • Pour un site web classique avec un front et des pages à indexer, un BFF bien placé résout plus de problèmes qu'une vingtaine de services.

L'architecture microservices, c'est quoi exactement (et pourquoi la plupart des définitions sont fausses)

Une architecture de microservices en informatique, c'est un découpage de l'application en services autonomes, chacun responsable d'un domaine métier, déployable seul, avec sa propre base de données et son propre cycle de vie. Jusque-là, tout le monde est d'accord. Le désaccord commence quand on précise ce que « autonome » veut dire concrètement.

J'ai vu des équipes appeler « microservices » trois applications qui partageaient une base PostgreSQL unique et se déployaient ensemble. Ce n'est pas une architecture microservices. C'est un monolithe distribué, et c'est le pire des deux mondes : la complexité du réseau plus le couplage du monolithe.

Ce que ça implique vraiment dans le code

Un service autonome, ça veut dire qu'il peut être réécrit en Rust par une équipe que vous n'avez jamais rencontrée, sans demander la permission à personne. Trois conditions, pas une de moins :

  • Sa propre persistance — pas de jointure SQL avec la table d'à côté.
  • Une communication explicite par contrat (HTTP, gRPC, message queue), jamais par import de code.
  • Un pipeline de déploiement qui ne dépend d'aucun autre pipeline.

Si l'une de ces trois conditions saute, vous avez fait beaucoup de travail pour un gain nul. Avouons-le : c'est fréquent.

Quelle est la différence entre un microservice et une API ?

Une API est une interface de communication — un ensemble de routes, de contrats, de formats d'échange. Un microservice est une unité de déploiement et de responsabilité métier qui expose souvent une API. La confusion vient de là : tout microservice a une API, mais une API n'est pas un service.

Concrètement : votre monolithe peut exposer une API REST parfaitement propre à une application mobile. C'est une API. Vous n'avez pas de microservice pour autant. En revanche, le service de facturation qui tourne dans son conteneur, avec sa base et son déploiement autonome, est un microservice — et il parle à l'extérieur via une API. L'un est du code exposé, l'autre est du code responsable.

Quels sont les avantages d'une architecture microservice (et leur facture cachée)

Sur mon dernier gros projet, on est passés d'un déploiement mensuel à quatorze déploiements par semaine. Sur ce point précis, les microservices ont tenu leurs promesses. Mais je ne vais pas vous vendre la liste habituelle sans sa facture.

Quels sont les avantages d'une architecture microservice (et leur facture cachée)

Les gains qui se vérifient

Le déploiement indépendant est le seul avantage que je considère comme structurel. Quand une équipe peut livrer sans attendre les autres, le temps de mise en production s'effondre — j'ai mesuré 40 minutes de CI sur le monolithe contre 6 sur le service isolé qu'on venait d'extraire. Pas parce que le code était meilleur, mais parce que la suite de tests ne compilait plus tout le dépôt.

La scalabilité ciblée arrive loin derrière. Oui, on peut faire monter uniquement le service de paiement en pleine période de soldes. En pratique, sur un site web, c'est le cache HTTP et le CDN qui absorbent 90 % de la charge. Le service de paiement, lui, ne prend jamais un pic de 50 000 requêtes.

La facture, poste par poste

Ce que personne ne vous facture dans les articles enthousiastes :

  • L'observabilité — sans traces distribuées, un incident prend une heure à localiser au lieu de cinq minutes.
  • La latence réseau — chaque appel inter-services ajoute des millisecondes. Dix appels en cascade et une page devient lente sans que le code soit en cause.
  • L'orchestration (Kubernetes ou équivalent), qui demande une personne compétente à temps partiel minimum.
  • La cohérence des données. Sans transaction distribuée, il faut des sagas, des compensations, des idempotences. J'ai mis trois semaines à comprendre pourquoi mon service de commande créait des doublons : le consommateur de messages retraitait après un timeout.

Sur notre budget d'infrastructure, on est passés d'environ 300 € par mois à un peu plus du triple. Ce n'est pas scandaleux à notre échelle. Ça le devient quand l'équipe fait deux personnes.

Comment choisir son architecture sans se tromper

Le tableau que je montre en réunion, et qui coupe court à 80 % des débats.

Comment choisir son architecture sans se tromper
CritèreMonolitheModulithMicroservices
Nombre d'équipes11 à 33 et plus
Fréquence de déploiementHebdo à mensuelQuotidienPlusieurs fois par jour
Debug d'incidentSimpleSimpleNécessite des traces
Coût infra relatif1×1×2 à 4×
Coût humainFaibleFaibleÉlevé, permanent
Réversible facilement—OuiDifficilement

Le modulith : l'option que vous cherchez probablement

Un monolithe modulaire, c'est un seul déploiement, mais des modules aux frontières explicites — chaque module a ses propres objets, son API interne, et interdit à ses voisins d'accéder directement à ses tables. On obtient 80 % de la rigueur des microservices pour 10 % de la complexité.

Et le meilleur dans l'histoire ? Quand un module devient réellement indépendant, l'extraire en service prend du temps, mais ne demande pas de refonte conceptuelle. J'ai fait l'exercice sur un module de notifications : deux jours de travail, pas six mois. C'est le chemin que je recommande, et je l'assume complètement.

À quel moment basculer concrètement ?

Le signal que je guette n'est pas technique. C'est quand deux équipes veulent livrer la même semaine et se marchent dessus : merges conflictuels à répétition, file d'attente de pull requests, craintes de casser le travail des autres. À ce moment-là, découper a du sens.

Le second signal : un domaine métier a un profil de charge radicalement différent du reste. Si votre moteur de recherche doit tourner en quatre exemplaires quand le back-office suffit en un, vous avez un candidat sérieux. Mais un seul.

Le troisième — et personne ne le dit jamais assez — c'est quand vous avez l'équipe pour l'exploiter. Pas deux développeurs et un stagiaire.

Ce qui change quand on parle développement web

Les articles sur les microservices parlent de plateformes à millions d'utilisateurs. Un site web, c'est autre chose : un front, du rendu, des sessions, du SEO. Et là, le découpage en services crée des problèmes spécifiques.

Ce qui change quand on parle développement web

Le BFF, l'outil dont personne ne parle assez

Un Backend for Frontend, c'est une couche dédiée qui agrège les appels aux services internes et renvoie au navigateur exactement ce dont la page a besoin. Dans une architecture microservices exposée à un site web, cette couche est quasiment obligatoire. Sans elle, votre front fait huit appels séquentiels au chargement et votre temps d'affichage explose.

J'ai testé les deux : front qui appelle directement six services, puis même page derrière un BFF. Le nombre d'appels réseau côté navigateur est passé de six à un, et le temps de rendu serveur a chuté de façon nette. Ce n'est pas de l'optimisation fine, c'est de la survie.

Sessions et rendu côté serveur

Deux pièges concrets. La gestion de session : si votre authentification vit dans un service et vos pages dans un autre, chaque requête paye un aller-retour réseau avant même de rendre le HTML. La solution habituelle est un token signé vérifiable localement, pas un appel de validation à chaque requête.

Le rendu côté serveur, ensuite. Un SSR qui doit interroger quatre services pour composer une page sera toujours plus lent que le même SSR sur un monolithe. Le remède est le cache — et il faut penser le cache dès la conception du service, pas après.

Quels sont les différents types d'architecture en informatique ?

La question revient souvent, et la réponse courte est qu'il existe quatre grandes familles, chacune répondant à une contrainte différente :

  1. Monolithique — un seul déploiement, un seul code. Simple, rapide à démarrer, de plus en plus pénible à mesure que l'équipe grandit.
  2. Modulaire (modulith) — même déploiement, mais des modules cloisonnés. Le meilleur compromis pour la majorité des projets web.
  3. Orientée services (SOA) — des services plus gros, souvent orchestrés par un bus de messages centralisé, partageant parfois des ressources. Une approche d'entreprise, plus lourde, où le bus devient vite un point de passage obligé.
  4. Microservices — services fins, autonomes, sans coordinateur central.

Il faut y ajouter les styles transverses (événementiel, serverless), mais pour un site web, le choix se joue presque toujours entre les deux premiers.

Mon avis, et je le maintiens

Commencez par un modulith. Toujours. Découpez le premier service le jour où une équipe est réellement bloquée par une autre, pas avant. Et prévoyez le budget d'observabilité dès la première extraction — c'est la seule ligne que les gens oublient systématiquement, et c'est celle qui vous sauvera à trois heures du matin.

Ce que je n'avais pas anticipé, en revanche : le coût culturel. Dans un monolithe, une erreur se corrige en ouvrant un fichier. En microservices, il faut parfois une réunion pour décider qui possède la donnée. Trois mois après notre migration, on a passé une demi-journée à débattre de l'endroit où devait vivre le champ « adresse de livraison ». Ce n'est pas un détail d'implémentation. C'est le vrai visage de l'architecture distribuée.

La question à se poser n'est jamais « quelle est l'architecture la plus moderne ». C'est « quel problème je cherche à résoudre, et combien je suis prêt à payer pour ça ». Si vous n'avez pas de réponse chiffrée à la seconde partie, gardez le monolithe. Il vous remerciera.

Clémence Duval

Clémence Duval

Clémence Duval est une experte reconnue dans les domaines du développement web, de l'architecture logicielle et du DevOps. Elle accompagne depuis plusieurs années des équipes techniques dans la conception de systèmes robustes et évolutifs, en mettant l'accent sur l'automatisation et les bonnes pratiques. Passionnée par la transmission, elle partage volontiers son expérience pour aider les développeurs à monter en compétences.

Voir tous les articles →

Articles similaires