Aller au contenu principal

Architecture

Microservices

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

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

Les pièges à éviter

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.

Contact

Un projet en lien avec microservices ?

Échangeons sur vos enjeux techniques. Pas de discours commercial, pas de jargon inutile : un diagnostic clair et des solutions concrètes.

Démarrer votre projet arrow_forward