Du monolithe aux microservices : une stratégie de migration étape par étape

La plupart des migrations vers les microservices échouent pour les mêmes quelques raisons : de mauvaises frontières, une réécriture d'un seul coup et une couche de données que personne n'a planifiée. Voici un manuel séquencé qui livre de la valeur toutes les quelques semaines et vous laisse vous arrêter dès que le calcul cesse de tenir.

5 min de lecture7 sections22 juin 2026

Écrit par

Kostadin Stamboliev

Fondateur et Imaginator

Fondateur et Imaginator de Pineido. Il travaille dans le conseil informatique, le développement d’applications et de sites web, le SEO technique, l’IA et l’automatisation. Il livre du code en production en sprints de 30 jours, avec un périmètre fixe et des responsabilités claires.

LinkedIn

D'abord, décidez si vous devriez seulement migrer

La réponse honnête pour beaucoup d'équipes est : pas encore. L'enquête CNCF 2025 a constaté qu'environ 42% des organisations ayant adopté les microservices ramènent certains services dans des unités plus grandes parce que le coût opérationnel a dépassé le bénéfice. Un seuil courant chez les praticiens : sous environ 30 développeurs ou un monolithe de moins de 100 000 lignes, les microservices ajoutent généralement du coût pour peu de retour. Migrez quand plusieurs équipes sont bloquées à éditer la même base de code, quand une fonctionnalité a des besoins de mise à l'échelle réellement différents du reste, ou quand une capacité a besoin de sa propre équipe dédiée et de sa propre cadence de livraison. Si le moteur est seulement que les monolithes font vieux jeu, corrigez d'abord la modularité à l'intérieur du monolithe (un monolithe modulaire) et épargnez-vous l'impôt des systèmes distribués.

Utilisez le pattern strangler fig, pas une réécriture d'un seul coup

Les réécritures complètes sont la manière la plus fiable d'échouer : des calendriers longs, des factures cloud triplées et des pannes en production que personne ne peut isoler parce que tout a changé en même temps. Le pattern strangler fig, baptisé par Martin Fowler dès 2004, fait croître le nouveau système autour de l'ancien et retire le monolithe pièce par pièce. Vous introduisez une façade (généralement votre passerelle d'API ou une couche de routage comme Istio ou un proxy basé sur Envoy) qui intercepte chaque requête. Au début, elle route presque tout vers le monolithe. À mesure que vous extrayez chaque fonctionnalité, vous basculez sa route vers le nouveau service. Les utilisateurs ne voient jamais de jour de bascule. Et à chaque étape, l'ancien chemin de code est toujours là, ce qui constitue votre rollback instantané si le nouveau service se comporte mal.

Tracez les frontières par domaine métier, pas par couche technique

La cause numéro un des migrations ratées est le découpage par couche technique : un service UI, un service de logique, un service de base de données. Cela produit un monolithe distribué, toute la surcharge réseau sans aucune indépendance. Découpez plutôt par capacité métier : Commandes, Stock, Paiements, Notifications. Le moyen le plus rapide de trouver ces lignes est un atelier d'Event Storming (la technique d'Alberto Brandolini) : réunissez experts du domaine et ingénieurs dans une salle, cartographiez ce qui se passe dans le système comme une ligne de temps d'événements, puis regroupez-les. Les contextes délimités émergent là où le langage change. Le Produit dans un contexte de catalogue (nom, images, SEO) est une chose différente du Produit dans le stock (SKU, entrepôt, seuil de réapprovisionnement). Dimensionnez-les autour du comportement, pas des entités, sinon vous vous retrouvez avec des services anémiques qui ne font rien par eux-mêmes.

Commencez par les bords, puis avancez vers l'intérieur

L'instinct est d'extraire d'abord le cœur facile : l'authentification, la gestion des utilisateurs, le modèle de domaine central. Résistez-y. Ce sont exactement les pièces dont tout le reste dépend, donc les casser casse le système entier. Commencez par les bords, les fonctionnalités feuilles avec peu de dépendances entrantes et des frontières d'API claires. Un endpoint de reporting, un worker de notifications, une tâche de PDF ou d'export, une API publique en lecture seule. Celles-ci vous donnent une vraie victoire en production, prouvent le pipeline (routage de passerelle, déploiement, observabilité) et construisent l'adhésion de la direction dont vous avez besoin pour terminer. Choisir une première tranche à faible risque est aussi ce qui empêche une migration de s'enliser dans un Frankenstein permanent à moitié-moitié, la façon la plus courante dont ces projets meurent en silence.

Séparez les données avec le CDC, pas avec des doubles écritures

Les données sont la partie la plus difficile de chaque migration, et les doubles écritures (faire écrire l'application à la fois dans l'ancienne et la nouvelle base) sont un piège : les écritures concurrentes perdent silencieusement des données et vous n'avez aucune garantie transactionnelle entre deux stockages. Utilisez plutôt la capture de données de changement basée sur le journal. Debezium (2.x et plus récent, avec des connecteurs PostgreSQL, MySQL, MongoDB, SQL Server et Oracle) lit le journal de transactions de la base et émet un événement pour chaque changement validé, de sorte que le nouveau service peut construire et garder synchronisé son propre stockage sans toucher au chemin d'écriture du monolithe. Les versions récentes ont ajouté des snapshots incrémentaux sans verrou et une meilleure sémantique exactement-une-fois. Pour les nouveaux services qui doivent publier leurs propres événements de façon fiable, associez le CDC au pattern outbox : écrivez la ligne métier et la ligne d'événement dans une seule transaction locale, et laissez le CDC la propager. Et acceptez le vrai compromis d'emblée : les transactions ACID inter-services ont disparu. Là où vous enveloppiez tout dans une transaction, vous concevez désormais pour une cohérence à terme avec des sagas.

Basculez une fonctionnalité à la fois et vérifiez en parallèle

Par fonctionnalité, la boucle est : extrayez le service, dirigez une petite tranche de trafic vers lui via la passerelle, et faites tourner l'ancien et le nouveau chemin côte à côte pendant que vous comparez les résultats. L'outillage de répartition du trafic (Istio, Linkerd ou une passerelle Envoy) vous permet de déplacer 1%, puis 10%, puis 100%, et de revenir en arrière en quelques secondes en annulant la route. Mettez en place l'observabilité avant l'extraction, pas après le premier incident : journaux structurés, traçage distribué (OpenTelemetry) et métriques par service dans Prometheus ou l'APM de votre choix. La raison pour laquelle les équipes regrettent les microservices est généralement opérationnelle : remplacer une application par cinquante signifie environ cinquante fois les déploiements, les journaux et les tableaux de bord, donc la plateforme doit être prête avant que les services n'arrivent. Une fois qu'une fonctionnalité a tourné proprement à plein trafic, supprimez le chemin de code mort dans le monolithe. Ce n'est que lorsque la dernière fonctionnalité est sortie que vous décommissionnez le monolithe. L'objectif est une fin de partie claire, pas deux systèmes que vous gardez à vie.

Fixez des calendriers réalistes et une condition d'arrêt

Des analyses indépendantes des migrations d'entreprise situent le calendrier typique de bout en bout à environ 18-36 mois pour un grand système, avec une poignée de facteurs de risque (frontières, données, maturité opérationnelle) responsables de la plupart des échecs. Budgétez le travail de plateforme, pas seulement les services : CI/CD, orchestration de conteneurs, traçage et astreinte doivent tous mûrir en parallèle. Tout aussi important, définissez une condition d'arrêt à l'avance. Parce que l'approche strangler livre un logiciel fonctionnel toutes les quelques semaines, vous avez le droit de faire une pause une fois que les parties douloureuses sont sorties et que le reste du monolithe est très bien là où il est. Une migration partielle est un résultat légitime, souvent optimal. L'échec n'est pas de s'arrêter tôt, c'est de s'acharner sur des services qui n'avaient jamais besoin de bouger.

Des idées opérationnelles chaque semaine

Rejoignez les dirigeants d’entreprises de services qui reçoivent chaque semaine une idée concrète sur les opérations, l’automatisation et la croissance.

Nous vérifions que vous êtes humain. Vous pourrez envoyer dans un instant.

Pas de spam. Désabonnement à tout moment.

Vous êtes inscrit ! Surveillez votre boîte de réception pour le prochain numéro.

Questions fréquentes

Qu'est-ce que le pattern strangler fig dans une migration ?

C'est une approche incrémentale où vous faites croître de nouveaux services autour du monolithe existant et le retirez pièce par pièce. Une couche de routage (généralement votre passerelle d'API) se place devant, envoie l'essentiel du trafic vers le monolithe, et vous basculez la route de chaque fonctionnalité vers un nouveau service une fois qu'il est prêt et vérifié. Il n'y a pas de jour de bascule, et l'ancien chemin de code est votre rollback à chaque étape.

Combien de temps prend une migration du monolithe vers les microservices ?

Pour un grand système d'entreprise, des analyses indépendantes situent le calendrier typique à environ 18-36 mois de bout en bout, y compris le travail de plateforme (CI/CD, orchestration, observabilité) dont les services dépendent. Parce que l'approche strangler livre de la valeur toutes les quelques semaines, vous obtenez des bénéfices bien avant que la migration complète soit terminée, et vous pouvez vous arrêter une fois les services à forte valeur sortis.

Comment séparer une base de données partagée entre les services ?

Évitez les doubles écritures, qui perdent des données en cas de concurrence. Utilisez la capture de données de changement basée sur le journal (par exemple Debezium lisant le journal de transactions) pour qu'un nouveau service puisse construire et synchroniser son propre stockage sans toucher aux écritures du monolithe. Associez-la au pattern outbox pour une publication d'événements fiable, et concevez pour une cohérence à terme avec des sagas plutôt que des transactions inter-services.

Quel service devrais-je extraire en premier ?

Commencez par les bords, pas par le cœur. Choisissez une fonctionnalité feuille avec peu de dépendances entrantes et une frontière nette, comme le reporting, les notifications ou une tâche d'export. Extraire l'authentification ou le modèle de domaine central en premier est risqué parce que tout en dépend. Une victoire précoce et à faible risque prouve le pipeline et empêche la migration de s'enliser.

Devrais-je seulement migrer vers les microservices ?

Seulement si vous avez un vrai problème que les microservices résolvent : plusieurs équipes bloquées sur une base de code, une fonctionnalité avec des besoins de mise à l'échelle réellement différents, ou une capacité qui a besoin de sa propre équipe et de sa propre cadence. Environ 42% des adoptants (CNCF 2025) reconsolident des services. Si votre équipe est petite ou le monolithe modeste, un monolithe modulaire livre généralement l'essentiel du bénéfice sans aucune surcharge des systèmes distribués.

Pourquoi la plupart des migrations vers les microservices échouent-elles ?

Trois causes récurrentes : le découpage par couche technique au lieu du domaine métier (créant un monolithe distribué), la tentative d'une réécriture d'un seul coup où aucune panne ne peut être isolée, et la sous-estimation de la complexité des données et de l'exploitation. De mauvaises frontières sont les plus courantes. Utilisez l'Event Storming pour trouver les frontières de domaine, le pattern strangler pour migrer de façon incrémentale, et mettez en place l'observabilité avant d'extraire quoi que ce soit.

Prêt à livrer ?

Dites-nous où vous bloquez. Nous l’examinons et vous envoyons une recommandation ciblée sous un jour ouvré.