Maintenance Symfony
Montée de version Symfony : comment migrer sans casser votre application ?
Une montée de version Symfony se prépare : elle suit un chemin balisé par le framework lui-même, celui des dépréciations. Ce guide d’upgrade Symfony explique quand mettre à jour le framework, comment migrer vers une version LTS étape par étape et quels pièges éviter.
Monter de version, pas réécrire.
Symfony annonce à l’avance ce qui va disparaître. Une application qui corrige ses dépréciations au fil de l’eau passe d’une version majeure à la suivante sans chantier de réécriture.
En bref
Une montée de version Symfony (ou upgrade Symfony) consiste à passer une application d’une version du framework à une version plus récente, mineure ou majeure, pour rester sur une version maintenue qui reçoit les correctifs de sécurité. Elle se fait par étapes : monter jusqu’à la dernière version mineure de la branche actuelle, corriger toutes les dépréciations signalées, mettre à jour les dépendances, puis passer à la version majeure suivante. Symfony publie des versions mineures régulières et des versions LTS (support à long terme) dont la période de maintenance est connue à l’avance, ce qui permet de planifier la migration avant la fin de support. Des tests automatisés, une préproduction et une recette fonctionnelle évitent les régressions.
Définition
Montée de version Symfony : de quoi parle-t-on et pourquoi la faire ?
Une montée de version Symfony, ou mise à jour Symfony, remplace la version du framework utilisée par une application par une version plus récente, avec les adaptations de code que cela demande. Elle touche aussi les dépendances installées par Composer et, souvent, la version de PHP.
On la fait pour trois raisons principales. La sécurité d’abord : une version arrivée en fin de maintenance ne reçoit plus de correctifs, même quand une faille est publiée. PHP ensuite : chaque version de PHP a sa propre fin de support, et les versions récentes de Symfony exigent des versions récentes de PHP ; les deux montées se planifient ensemble. La durabilité enfin : plus l’écart avec la version courante grandit, plus les bibliothèques tierces cessent d’être compatibles et plus la mise à jour devient coûteuse.
Cette page détaille la méthode de migration. Pour la maintenance au quotidien, voir notre page maintenance Symfony ; pour les failles et les correctifs, notre guide sécurité d’une application Symfony.
Versions
Mineure, majeure, LTS : les types de versions Symfony
Symfony suit un processus de publication documenté et une promesse de compatibilité ascendante entre versions mineures. Le type de version visé détermine l’ampleur de la montée de version.
| Type de version | Ce qu’elle apporte | Compatibilité | Effort de migration |
|---|---|---|---|
| Correctif (patch) | Corrections d’anomalies et de sécurité sur une version donnée | Aucun changement incompatible attendu | Faible : mise à jour Composer et tests |
| Mineure | Nouvelles fonctionnalités et nouvelles dépréciations, à intervalle régulier | Compatible avec les versions mineures précédentes de la même branche | Modéré : tests, lecture des dépréciations ajoutées |
| Majeure | Suppression du code déprécié dans la branche précédente, exigences PHP relevées | Changements incompatibles annoncés par les dépréciations | Important si les dépréciations n’ont pas été corrigées avant |
| LTS (support à long terme) | Dernière version mineure d’une branche majeure, maintenue plus longtemps | Identique à la mineure qu’elle est | Cible privilégiée des applications métier |
Synthèse du processus de publication de Symfony. Les dates de fin de maintenance et de fin de support de sécurité de chaque version sont publiées par Symfony : vérifiez-les pour votre version avant de planifier.
Dépréciations
Le chemin des dépréciations : la règle qui rend la migration prévisible
Une dépréciation est un avertissement : une classe, une méthode ou une option fonctionne encore, mais elle disparaîtra à la prochaine version majeure. Symfony l’annonce dans une version mineure, avec l’alternative à utiliser, et ne la supprime qu’à la version majeure suivante.
Conséquence directe : une application qui ne déclenche plus aucune dépréciation sur la dernière version mineure d’une branche est prête pour la version majeure suivante. La version majeure apporte les mêmes fonctionnalités que cette dernière mineure, sans le code déprécié. Le gros du travail se fait donc avant le changement de version majeure, pas après.
Les dépréciations se lisent à plusieurs endroits : la barre de débogage et le profiler en environnement de développement, le canal de journalisation dédié de Monolog, et le rapport produit en fin de tests par le pont PHPUnit de Symfony. Les bundles tiers déclenchent eux aussi des dépréciations : ils doivent être mis à jour ou remplacés.
Check-list
Check-list de préparation avant une montée de version Symfony
Une mise à jour Symfony réussie se joue avant la première commande. Voici les points à vérifier :
- Version de départ et version cible : la version actuelle, sa date de fin de support, et la version visée, de préférence une LTS encore maintenue.
- Version de PHP : celle du serveur, celle qu’exige la version cible, et la fin de support de chacune ; l’hébergement doit suivre.
- Tests automatisés : des tests PHPUnit sur les parcours critiques ; s’ils manquent, on les écrit avant de migrer.
- Journal des dépréciations : la liste complète des dépréciations déclenchées par l’application, les tests et les bundles.
-
Compatibilité des dépendances : pour chaque paquet du
composer.json, une version compatible avec la cible existe-t-elle ? - Bundles abandonnés : repérer les paquets qui ne sont plus maintenus et choisir un remplaçant ou une réécriture.
-
Code qui contourne le framework : surcharges de classes internes, accès à des services privés, modifications dans le dossier
vendor. - Fichier composer.lock versionné : il fige l’état de départ et permet de revenir en arrière.
- Préproduction : un environnement proche de la production, avec des données représentatives, pour la recette.
- Sauvegardes et retour arrière : base de données sauvegardée et procédure de retour testée avant la mise en production.
Méthode
Comment migrer vers une version LTS de Symfony, étape par étape
01
Inventaire et audit
Relevé des versions de Symfony, de PHP et des dépendances, des dépréciations, des bundles abandonnés et de la couverture de tests. Le résultat est un plan de migration et une estimation de l’effort.
02
Correction des dépréciations
Chaque dépréciation est corrigée selon l’alternative indiquée par Symfony, dans une branche dédiée, sous couvert des tests. Les changements répétitifs peuvent être automatisés, puis relus.
03
Montée mineure par mineure, puis majeure
On monte jusqu’à la dernière version mineure de la branche actuelle, en corrigeant les nouvelles dépréciations à chaque étape. Quand il n’en reste plus, on passe à la version majeure suivante, et on recommence si la cible est plus loin.
04
Recette et mise en production
Tests automatisés, recette fonctionnelle en préproduction par vos équipes, puis déploiement scripté avec sauvegarde. Un suivi des journaux après la mise en production vérifie qu’aucune erreur nouvelle n’apparaît.
Outils
Les outils d’une mise à jour Symfony
Une montée de version Symfony s’appuie sur des outils de l’écosystème. Aucun ne remplace la lecture du code et les tests, mais chacun accélère une partie du travail.
| Outil | À quoi il sert | Point de vigilance |
|---|---|---|
| Guides de mise à jour (fichiers UPGRADE) | Le dépôt Symfony publie, pour chaque version, la liste des changements à appliquer au code | À lire pour chaque version franchie, pas seulement pour la cible |
| Journal des dépréciations | Profiler, canal Monolog dédié et pont PHPUnit listent les appels à remplacer | Lancer toute la suite de tests pour voir les dépréciations des parcours rarement utilisés |
composer why-not | Indique quel paquet empêche l’installation d’une version donnée | Révèle souvent un bundle tiers non maintenu |
composer outdated et composer audit | Listent les dépendances en retard et celles concernées par une faille publiée | Toute mise à jour se teste, jamais directement en production |
| Symfony Flex | Contraint la version des paquets Symfony dans le composer.json et met à jour les recettes de configuration | Relire chaque fichier de configuration modifié par une recette |
| Rector | Refactoring automatisé des changements répétitifs, avec des règles dédiées à Symfony et à PHP | Chaque modification produite reste relue et testée |
| PHPStan | Analyse statique : détecte les appels à des méthodes disparues ou mal typées | Monter le niveau d’analyse progressivement sur un code ancien |
Outils couramment utilisés dans l’écosystème Symfony, cités à titre d’exemples. Rector et PHPStan sont des choix possibles parmi d’autres.
Pièges
Les risques d’une montée de version Symfony et comment les éviter
La plupart des migrations difficiles butent sur les mêmes obstacles. Les connaître à l’avance permet de les traiter dans le plan, plutôt qu’en cours de route.
Sauter des étapes
Passer directement à une version lointaine sans corriger les dépréciations des branches intermédiaires mène à une application qui ne démarre plus. Le chemin passe par chaque dernière version mineure.
Bundle tiers abandonné
Un paquet qui n’est plus maintenu bloque toute la mise à jour. Il faut le remplacer par une alternative ou réécrire la partie utile, ce qui se décide dès l’audit.
Absence de tests
Sans tests, chaque régression se découvre en production. Écrire d’abord des tests sur les parcours critiques coûte moins cher que de corriger après coup.
PHP oublié
La version cible de Symfony exige une version de PHP que le serveur n’a pas toujours. La montée de PHP se planifie avec l’hébergement, sur tous les environnements.
Configuration et recettes
Les fichiers de configuration évoluent d’une version à l’autre. Une recette mise à jour sans relecture peut écraser un réglage propre à votre application.
Branche trop longue
Une migration menée à l’écart pendant des mois diverge du code en production. Mieux vaut livrer la correction des dépréciations par petits lots, au fil de l’eau.
Questions fréquentes
Migrer vers une version LTS : vos questions
Faut-il viser la dernière version ou une version LTS ?
Pour une application métier, une version LTS est généralement le choix le plus stable. Elle reste maintenue plus longtemps et limite la fréquence des migrations majeures. La dernière version mineure convient si vous mettez à jour régulièrement.
Peut-on continuer à livrer des évolutions pendant la migration ?
Oui, à condition d’organiser le travail. Les corrections de dépréciations sont livrées par petits lots sur la version en production, et seul le changement de version majeure se fait dans une branche courte. Les évolutions lourdes peuvent être décalées pour ne pas être développées deux fois.
Que faire d’un bundle qui ne suit pas la nouvelle version ?
Le remplacer par un paquet maintenu, ou réécrire la partie réellement utilisée dans l’application. La commande composer why-not aide à repérer ces blocages tôt. Le choix se fait pendant l’audit, pas en fin de migration.
Agillia
Votre montée de version Symfony avec Agillia
Agillia est une agence web présente depuis plus de 20 ans, avec des experts seniors qui maintiennent des sites et des applications depuis plus de 16 ans. Nous utilisons Symfony au quotidien : c’est le socle de PrestaShop 8 et 9, sur lequel reposent nos modules. Suivre les versions du framework et corriger les dépréciations fait partie de notre travail courant. Nous intervenons aussi sur Laravel, voir maintenance et évolution Laravel.
Une montée de version commence par un audit de votre application Symfony : versions, dépendances, dépréciations, tests et risques. Elle se mène ensuite en méthode agile, par lots livrés et recettés, et peut s’inscrire dans notre prestation de maintenance d’application Symfony pour que l’application reste à jour ensuite.
Pour estimer l’effort, voir notre guide sur le coût de la maintenance Symfony ; si l’application vient d’un autre prestataire, notre guide sur la reprise d’une application Symfony.
Pour aller plus loin
Pour aller plus loin
- Audit d’application Symfony : l’état des lieux technique avant de planifier la migration.
- Maintenance d’application Symfony : garder l’application à jour après la montée de version.
- Maintenance Symfony : interventions et évolutions en méthode agile.
- Sécurité d’une application Symfony : correctifs, avis de sécurité et dépendances vulnérables.
- Performance d’une application Symfony : mesurer et améliorer les temps de réponse.
- Évolution Symfony : faire grandir l’application sans casser l’existant.
- Lexique de la maintenance : les définitions des termes de la maintenance applicative.
- Experts seniors pour votre maintenance : notre équipe et sa façon de travailler.
- Hébergement cloud dédié : une infrastructure qui suit les versions de PHP.
Questions fréquentes
Vos questions sur la montée de version Symfony
Comment faire une montée de version Symfony ?
On monte d’abord jusqu’à la dernière version mineure de la branche actuelle, puis on corrige toutes les dépréciations signalées. Ensuite on met à jour les dépendances et on passe à la version majeure suivante. Chaque étape est testée en préproduction et recettée avant la mise en production.
Quand faut-il mettre à jour Symfony ?
Il faut mettre à jour Symfony avant la fin de support de sécurité de votre version. Symfony publie ces dates à l’avance, ce qui laisse le temps de planifier. Les correctifs de sécurité d’une version maintenue s’appliquent, eux, dès leur publication, ce que prévoit une maintenance Symfony suivie.
Qu’est-ce qu’une version LTS de Symfony ?
Une version LTS (support à long terme) est la dernière version mineure d’une branche majeure de Symfony. Elle est maintenue plus longtemps que les autres versions mineures. C’est la cible habituelle des applications métier qui veulent espacer les migrations.
Qu’est-ce qu’une dépréciation dans Symfony ?
Une dépréciation signale une fonctionnalité qui marche encore mais sera supprimée à la prochaine version majeure. Symfony indique l’alternative à utiliser. Les corriger toutes avant le changement de version majeure rend la migration prévisible.
Combien de temps prend une montée de version Symfony ?
La durée dépend de l’écart entre les versions, du nombre de dépréciations, des bundles tiers et de la couverture de tests. Une montée mineure sur une application à jour reste un lot court ; plusieurs versions majeures de retard représentent un chantier de plusieurs semaines ou plus. Un audit Symfony donne l’estimation.
Faut-il mettre à jour PHP lors d’un upgrade Symfony ?
Souvent oui. Les versions récentes de Symfony exigent des versions récentes de PHP, et chaque version de PHP a sa propre fin de support. Les deux montées de version se planifient ensemble, avec l’hébergement.
Rector suffit-il pour faire un upgrade Symfony ?
Non. Rector automatise les changements de code répétitifs, ce qui fait gagner du temps. Il ne remplace ni la lecture des guides de mise à jour, ni le remplacement des bundles abandonnés, ni les tests et la recette.
Peut-on sauter une version majeure de Symfony ?
On peut viser une version lointaine, mais le chemin passe par chaque branche intermédiaire : dernière mineure, correction des dépréciations, majeure suivante. Sauter ces étapes fait disparaître les avertissements qui guident la migration. Plus l’écart est grand, plus le chantier est long.
Planifier la montée de version de votre application
Indiquez-nous la version de Symfony et de PHP de votre application : nous commençons par un audit et vous proposons un plan de migration par étapes.
