L'architecture microservices consiste à décomposer une application en services indépendants, chacun responsable d'une capacité métier précise (commandes, catalogue, facturation, notifications). Chaque service possède ses données, son cycle de déploiement et communique avec les autres par API ou par messages. C'est une réponse à des problèmes d'échelle — organisationnelle autant que technique — qui a un coût élevé.
Échelle & Autonomie
Chaque service peut être déployé et mis à l'échelle indépendamment, les équipes travaillent en autonomie sur leur périmètre, et une panne peut rester confinée à un service — à condition que les autres sachent fonctionner sans lui.
Complexité & Surcoût
Réseau, supervision distribuée, cohérence des données entre services, versions d'API à maintenir, déploiements coordonnés : la complexité opérationnelle est majeure. Pour la plupart des PME, un monolithe modulaire reste plus pertinent.
Ce que les microservices résolvent vraiment
L'argument le plus solide en faveur des microservices n'est pas technique, il est organisationnel : permettre à plusieurs équipes de livrer indépendamment, sans se bloquer sur une base de code et un calendrier de déploiement communs. Le second argument est la mise à l'échelle différenciée, quand une partie du système subit une charge sans commune mesure avec le reste. Si aucune de ces deux situations n'existe, les microservices apportent surtout leurs coûts.
Le prix d'une architecture distribuée
- La cohérence des données : une opération qui touchait deux tables dans une transaction devient un échange entre deux services, avec des états intermédiaires, des compensations et de l'idempotence partout.
- Le réseau : chaque appel peut échouer, expirer ou arriver deux fois. Timeouts, retries et coupe-circuits deviennent obligatoires.
- L'observabilité : suivre une requête à travers plusieurs services exige des identifiants de corrélation, des journaux centralisés et des métriques par service.
- Les contrats : chaque API interne est un contrat à versionner, et chaque changement doit rester compatible avec les consommateurs existants.
- L'exploitation : autant de pipelines, d'images, de configurations et de mises à jour de sécurité que de services.
Mon approche : découper quand le besoin est réel
Je pars d'un monolithe modulaire et n'extrais un service que lorsqu'une raison concrète l'impose. Sur la mission que je mène depuis plus de dix ans pour la direction technique d'Orange, le paysage compte cinq applications Symfony distinctes, chacune avec son périmètre métier — dont un bridge inter-systèmes qui synchronise deux plateformes par messages asynchrones. Ce sont des applications autonomes, pas un monolithe découpé artificiellement.
Leur coexistence montre aussi le vrai défi d'un système distribué : partager du code sans coupler les applications. Une librairie interne fournit des ponts vers les services du groupe (SMS, stockage objet, jetons OAuth), chacun avec une interface, une implémentation réelle et une implémentation hors-ligne pour les tests. Elle repose sur une règle stricte de rétrocompatibilité : en trois ans et vingt-sept versions publiées, un seul changement cassant dans l'API du quotidien, et aucune application n'a été forcée de migrer à une date imposée. C'est le détail que je raconte dans Partager du code entre applications sans les coupler.
Quand les microservices se justifient
- Plusieurs équipes autonomes travaillent sur des domaines métier clairement séparés.
- Une partie du système a des besoins de charge, de disponibilité ou de sécurité très différents du reste.
- L'organisation dispose de l'outillage et des compétences pour exploiter un système distribué : CI/CD par service, orchestration de conteneurs, supervision centralisée.
Les pièges à éviter
- Le monolithe distribué : des services qui partagent la même base de données ou doivent être déployés ensemble cumulent les inconvénients des deux architectures.
- Découper par couche technique (un service « base de données », un service « API ») au lieu de découper par domaine métier.
- Des appels synchrones en chaîne : si le service A attend B qui attend C, la disponibilité de l'ensemble est le produit des trois.
- Migrer d'un coup : un monolithe se découpe progressivement, service par service, derrière une couche de routage.
Les microservices sont une solution à des problèmes d'échelle humaine et technique massifs ; les adopter prématurément, c'est s'injecter une complexité coûteuse sans en retirer les bénéfices.
J'accompagne ces choix d'architecture dans le cadre de mes missions d'architecture et performance applicative. Pour extraire progressivement des composants d'une application existante, voir le strangler fig pattern.