Comment savoir quand moderniser un système legacy

Quand moderniser un système legacy : signaux d’alerte, risques d’attendre, moderniser ou remplacer, pattern strangler fig et plan par étapes sans interruption.

8 min de lecture

  • Modernisation legacy
  • Systèmes legacy
  • Modernisation
  • Architecture
  • Strangler fig
  • Migration de données
  • Dette technique
Comment savoir quand moderniser un système legacy

Presque toutes les entreprises avec lesquelles je travaille ont un système qui « fonctionne, mais auquel personne ne veut toucher ». Il a été construit il y a dix ou quinze ans, il porte la facturation, les stocks ou l’activité quotidienne, et chaque petite modification devient une semaine de tension. La question qu’on me pose n’est pas technique : faut-il investir maintenant dans sa modernisation, ou peut-on tenir encore un an ?

Après plus de 20 ans à développer, intégrer et maintenir des systèmes d’entreprise, ma réponse n’est presque jamais « on réécrit tout ». Ce n’est pas non plus « on n’y touche pas ». Ce qui compte, c’est de savoir lire les signaux, de comprendre le risque que l’on accepte en attendant et de choisir une trajectoire qui n’arrête pas l’activité. Voici comment je m’y prends.

Les signaux qu’un système doit être modernisé

Aucun signal isolé n’impose une modernisation. Ce qui compte, c’est leur accumulation et leur proximité avec les parties critiques de l’activité. Voici les cinq que je vérifie en premier.

Des versions qui ne sont plus supportées

Si l’application tourne sur PHP 5.6 ou 7.x, sur une version de Node.js sortie de son cycle LTS, sur un framework abandonné ou sur un système d’exploitation sans correctifs, elle ne reçoit plus de mises à jour de sécurité. PHP 7.4 n’est plus supporté officiellement depuis fin 2022, et les versions antérieures depuis bien plus longtemps. La faille n’est qu’une partie du problème : les nouvelles bibliothèques cessent d’être compatibles, les hébergeurs retirent ces versions, et toute intégration moderne (une passerelle de paiement, un SDK cloud) exige un runtime que votre système ne peut pas utiliser.

La dette de sécurité

La dette de sécurité se lit dans les détails : mots de passe stockés en MD5 ou SHA-1 sans sel, requêtes SQL construites par concaténation, sessions qui n’expirent jamais, identifiants écrits en dur dans le code, absence de journaux d’audit. Chaque point se corrige, mais quand ils apparaissent tous ensemble, c’est en général le signe d’un système conçu pour une autre époque, où corriger un à un coûte plus cher que reconstruire la couche concernée.

Le coût du changement

C’est le signal le plus parlant pour le métier. Un ajustement qui devrait prendre une journée en prend deux semaines, parce que personne ne sait ce qui risque de casser ailleurs. Pas de tests automatisés, un déploiement manuel, et chaque mise en production se fait en croisant les doigts. Quand l’équipe commence à répondre « ce n’est pas possible » à des demandes raisonnables, le système freine déjà les décisions commerciales.

La dépendance à une seule personne

Si une seule personne sait comment se calcule une commission, comment se fait la clôture mensuelle ou pourquoi telle table existe, l’entreprise court un risque opérationnel, pas seulement technique. Cette personne tombe malade, part ou s’épuise, et le savoir disparaît avec elle. On peut le récupérer, mais il faut le documenter délibérément avant de toucher au code.

Des performances qui se dégradent

Des rapports qui prennent plusieurs minutes, des écrans qui se figent en fin de mois, des bases de données qui ont grossi sans index adaptés ni archivage. Parfois, une optimisation ciblée suffit : index, cache, requêtes réécrites. Mais si l’architecture oblige à tout traiter de façon synchrone, ou sur un serveur unique qui ne passe pas à l’échelle, la limite est structurelle.

Les risques de l’immobilisme

Garder un système legacy n’est pas gratuit sous prétexte qu’il n’apparaît pas au budget. Le coût est diffus, caché, et il augmente généralement avec le temps :

  • Incidents de sécurité : une faille connue dans une version non supportée est la porte d’entrée la plus simple pour un attaquant.
  • Arrêts imprévus : un vieux serveur qui lâche n’a pas toujours de remplaçant compatible, et la restauration prend des jours.
  • Opportunités manquées : ajouter des paiements, un canal WhatsApp, une boutique en ligne ou de l’IA devient coûteux, voire impossible.
  • Compétences : il est chaque année plus difficile de trouver des personnes prêtes à maintenir des technologies anciennes et capables de le faire.
  • Conformité : auditeurs, banques et grands comptes exigent des contrôles que le système ne peut pas démontrer.

Moderniser ou remplacer ?

Tout vieux système ne doit pas être modernisé. Parfois, la bonne décision est de le remplacer par un produit du marché ; d’autres fois, il vaut mieux reconstruire certaines parties et garder le reste. Je tranche selon deux axes : la valeur métier propre que contient le système et la santé de sa base technique. Un ERP générique peu personnalisé peut être remplacé ; un système qui renferme des années de règles métier maison ne devrait presque jamais être jeté.

SituationCe que je recommande en généralPourquoi
Code correct, mais qui tourne sur des versions non supportéesMettre à niveau la plateforme (runtime, framework, serveur)Le risque est dans l’infrastructure, pas dans la logique
Règles métier propres et précieuses, code difficile à maintenirModernisation incrémentale, module par moduleOn préserve le savoir et on réduit le risque à chaque étape
Processus standard (comptabilité, paie) peu personnalisésRemplacer par un produit existant et l’intégrerReconstruire ce qui existe déjà n’apporte aucun avantage
Système stable, qui évolue peu et n’est pas exposé à internetMaintenir et isoler, avec supervision et sauvegardesModerniser ne se rentabilise pas si on n’y touche presque jamais
Performances insuffisantes sur une partie préciseExtraire ce module ou l’optimiserLe problème est localisé
Personne ne comprend le système et les données ne sont pas fiablesAudit et documentation d’abordSans diagnostic, toute décision est un pari

La réécriture complète à partir de zéro est l’option la plus enthousiasmante, et celle que j’ai vue échouer le plus souvent. Pendant des mois, l’activité dépend toujours de l’ancien système, qui continue lui aussi d’évoluer ; le nouveau poursuit une cible mouvante, et à la fin surgissent des règles que personne n’avait jamais documentées.

L’approche incrémentale : le pattern strangler fig

Le pattern strangler fig, décrit par Martin Fowler, consiste à construire le nouveau système autour de l’ancien et à transférer les fonctionnalités par morceaux, jusqu’à ce que le legacy ne reçoive plus de trafic. La pièce maîtresse est une façade : un proxy, une API gateway ou une couche de routage qui décide, route par route, quel système traite chaque requête.

# Façade Nginx : ce qui est migré va au nouveau service, le reste reste sur le legacy
location /api/factures/ {
    proxy_pass http://facturation-nouvelle:8080;
}

location / {
    proxy_pass http://legacy-app:80;
}

Chaque module migré passe ainsi en production séparément, et en cas de problème on revient en arrière en modifiant une route, pas en restaurant tout un système. J’associe la façade à des feature flags pour activer le nouveau module d’abord pour les utilisateurs internes ou pour une partie du trafic. L’utilisateur final ne vit pas une « grande migration » ; il voit un système qui s’améliore.

Préserver les règles métier et les données

La vraie valeur d’un système legacy n’est pas dans son code, mais dans les règles que ce code applique : l’arrondi des taxes, les remises cumulables, le sort d’une facture annulée après la clôture. Beaucoup de ces règles ne sont écrites nulle part ailleurs. Avant de déplacer un module, je fais trois choses :

  • Tests de caractérisation : des tests qui enregistrent ce que fait le système aujourd’hui, même si cela paraît faux, pour repérer toute différence dans le nouveau.
  • Inventaire des règles : un document relu avec les équipes métier qui explique chaque calcul et chaque exception.
  • Stratégie de données : correspondance des tables, dédoublonnage et, quand les deux systèmes doivent cohabiter, synchronisation par change data capture ou par événements pour qu’aucun ne travaille sur des données périmées.

Les données méritent une attention particulière. Une migration n’est pas terminée quand les enregistrements sont copiés, mais quand les chiffres concordent : totaux par période, soldes par client, stocks par entrepôt. J’automatise les rapprochements entre l’ancien et le nouveau système, et je ne clôture pas un module tant qu’ils ne coïncident pas.

Un plan étape par étape

1. Auditer

J’examine le code, l’infrastructure, la base de données, les intégrations, la sécurité et le processus de déploiement, et je parle avec ceux qui utilisent le système tous les jours. Le résultat est une carte : modules, dépendances, risques connus et zones où personne n’ose s’aventurer.

2. Prioriser

Je croise le risque technique avec l’impact métier. Je commence par ce qui fait le plus mal ou expose le plus, pas par le plus facile ni par le plus intéressant techniquement. Je découpe en petites livraisons, chacune utile en elle-même.

3. Stabiliser

Avant de migrer, le système actuel doit cesser d’être fragile : sauvegardes vérifiées, gestion de versions, environnement de recette, supervision des erreurs, correctifs de sécurité urgents et déploiement reproductible. Cette phase suffit souvent à réduire les incidents et donne de la marge pour la suite.

4. Migrer module par module

Une fois la façade en place, j’extrais un module à la fois : sa logique, ses données et ses intégrations. Pour le premier, je choisis un module aux frontières nettes et aux conséquences limitées, afin de valider la méthode avant de toucher au cœur.

5. Valider

Chaque module passe par les tests de caractérisation, le rapprochement des données et, quand le risque le justifie, une période d’exécution en parallèle : les deux systèmes traitent la même chose et je compare les résultats avant d’éteindre l’ancien. Les équipes métier valident sur des cas réels, pas sur des démonstrations.

6. Faire évoluer

La modernisation ne s’arrête pas à la dernière migration. L’objectif est un système capable d’évoluer sans risque : tests automatisés, CI/CD, documentation vivante et dépendances mises à jour régulièrement. Ainsi, il ne redevient pas un legacy dans cinq ans.

Les questions à se poser cette semaine

  1. Quelles versions de langage, de framework et de système d’exploitation utilisons-nous, et reçoivent-elles encore des correctifs de sécurité ?
  2. Combien de temps prend aujourd’hui un petit changement, de la demande à la mise en production ?
  3. Combien de personnes comprennent vraiment les processus critiques du système ?
  4. De quelles intégrations l’activité aura-t-elle besoin dans les douze prochains mois, qui sont impossibles aujourd’hui ?
  5. Avons-nous des sauvegardes dont nous avons réellement testé la restauration ?

Si deux réponses ou plus vous mettent mal à l’aise, inutile de décider une réécriture. Il faut un diagnostic. Avec lui, on peut planifier une modernisation par étapes, avec des coûts visibles et sans arrêter l’activité.

Questions fréquentes

Combien de temps faut-il pour moderniser un système legacy ?

Cela dépend de la taille et de l’état du système. L’audit prend en général une à trois semaines ; la modernisation se fait par étapes et chaque module passe en production séparément, si bien que l’entreprise voit des résultats sans attendre la fin du projet.

Faut-il arrêter l’activité pendant la migration ?

Non, si elle est menée de façon incrémentale. Avec une façade qui route les requêtes, une synchronisation des données et une exécution en parallèle quand c’est nécessaire, l’ancien système continue de servir pendant que le nouveau reprend chaque module.

Peut-on conserver les données historiques ?

Oui. Elles sont mises en correspondance, nettoyées et migrées avec des rapprochements qui vérifient totaux et soldes. Quand une ancienne donnée ne rentre pas dans le nouveau modèle, le métier décide s’il faut la transformer, l’archiver ou la garder consultable en lecture seule.

Ne vaut-il pas mieux tout réécrire avec une technologie moderne ?

Rarement. Une réécriture complète perd les règles non documentées et oblige à maintenir deux systèmes pendant longtemps. Je ne réécris des modules précis que lorsque le code existant n’est pas récupérable, et toujours derrière des tests qui comparent les résultats.