Déploiement Symfony
Déploiement Symfony en production : méthodes, outils et comparatif
Mettre en production une application Symfony, c’est livrer du code neuf sans perdre de requêtes ni de données. Ce guide présente les étapes documentées par Symfony, les méthodes pour livrer sans interruption, les outils de déploiement et les contrôles avant et après chaque livraison.
Livrer souvent, sans y penser.
Une mise en production Symfony scriptée se rejoue à l’identique à chaque fois. Elle se vérifie en quelques contrôles et s’annule en revenant à la release précédente.
En bref
Le déploiement Symfony en production installe une nouvelle version d’une application sur le serveur, puis la prépare à servir le trafic réel. Les étapes documentées par Symfony sont toujours les mêmes : vérifier les prérequis du serveur, configurer l’environnement (APP_ENV=prod, APP_DEBUG=0), installer les dépendances avec composer install --no-dev --optimize-autoloader, vider et préchauffer le cache, compiler les assets, exécuter les migrations Doctrine et redémarrer les workers Messenger. Pour livrer sans interruption, on prépare chaque version dans un répertoire de release séparé, puis on bascule un lien symbolique, avec des migrations de base compatibles avec l’ancien et le nouveau code. Le bon outil (script, Deployer, Ansible, pipeline CI/CD, conteneurs) est celui qui rend ces étapes scriptées, répétables et réversibles.
Définition
Qu’est-ce qu’une mise en production Symfony ?
Une mise en production Symfony, ou livraison en production, fait passer l’application d’une version du code à la suivante sur le serveur qui reçoit les vrais utilisateurs. Copier les fichiers ne suffit pas : Symfony compile son conteneur dans un cache, lit sa configuration dans l’environnement et attend un schéma de base à jour.
L’environnement d’exécution se règle d’abord. En production, APP_ENV vaut prod et APP_DEBUG vaut 0. Les valeurs propres au serveur viennent de vraies variables d’environnement ou d’un fichier .env.local non versionné ; la commande composer dump-env prod les regroupe dans un fichier .env.local.php. Les données sensibles peuvent être rangées dans le coffre de secrets de Symfony, chiffré et distinct pour chaque environnement ; la clé de déchiffrement de production ne se versionne pas.
Le code se prépare ensuite. composer install --no-dev --optimize-autoloader installe les dépendances sans outils de développement et génère un chargement de classes optimisé. php bin/console cache:clear, lancé en environnement de production, vide le cache et le préchauffe. Les assets se compilent avec Webpack Encore ou, avec AssetMapper, via php bin/console asset-map:compile.
Les données et les processus suivent. php bin/console doctrine:migrations:migrate applique les migrations de base en attente. Les workers Messenger, qui gardent l’ancien code en mémoire, reçoivent un signal d’arrêt avec messenger:stop-workers ; Supervisor ou systemd les relance avec le nouveau code. Enfin, le cache OPcache est réinitialisé, en général par un rechargement de PHP-FPM, et le préchargement PHP (preloading) est régénéré s’il est utilisé.
Cette page traite de la façon de livrer. Le changement de version du framework est détaillé dans notre guide montée de version Symfony, et le suivi courant de l’application dans notre page maintenance Symfony.
Enjeux
Pourquoi le déploiement d’une application Symfony mérite une méthode
Un déploiement Symfony mal préparé coupe le service, désaligne le code et la base ou laisse des processus sur l’ancienne version. Une méthode outillée réduit ces risques.
Coupure de service
Installer les dépendances et vider le cache dans le répertoire servi rend l’application instable pendant quelques instants.
Code et schéma désalignés
Une migration qui renomme une colonne casse l’ancien code encore en service. Une migration oubliée casse le nouveau.
Workers sur l’ancien code
Un worker Messenger lancé avant la livraison continue d’exécuter l’ancienne version. Les messages sont traités avec une logique périmée tant qu’il n’est pas redémarré.
Secrets exposés
Un mot de passe dans le dépôt ou un mode debug resté actif expose l’application.
Premières requêtes lentes
Un cache froid ou un OPcache périmé ralentit les premières pages après la bascule. Le préchauffage fait partie de la livraison.
Retour arrière
Sans release précédente conservée ni sauvegarde, un incident en production se corrige dans l’urgence au lieu de s’annuler en une commande.
Sans interruption
Déployer une application Symfony sans interruption
Pour déployer une application Symfony sans interruption, on prépare la nouvelle version à côté de celle en service, puis on bascule d’un coup. Trois principes le permettent.
Des répertoires de release. Chaque livraison est installée dans un nouveau répertoire, par exemple releases/ suivi d’un identifiant. Tout y est préparé pendant que l’ancienne version sert le trafic. Les éléments qui doivent survivre aux livraisons sont placés dans un dossier partagé et reliés à chaque release : var/log, les fichiers envoyés par les utilisateurs comme public/uploads, et le fichier .env.local. Quand tout est prêt, un lien symbolique current est basculé vers la nouvelle release. Un rechargement de PHP-FPM fait ensuite servir le nouveau chemin et réinitialise OPcache.
Des migrations compatibles dans les deux sens. Pendant la bascule, ancien et nouveau code partagent la même base. Les migrations suivent donc le schéma « élargir puis réduire » (expand/contract) : on ajoute d’abord une colonne ou une table sans retirer l’ancienne, on livre le code qui sait lire les deux, puis on supprime l’ancienne structure dans une livraison suivante.
Des contrôles et un retour arrière prêts. Juste après la bascule, des tests de santé (une route qui vérifie la base, le cache et les services externes) confirment que la version répond. En cas d’échec, on rebascule le lien vers la release précédente, gardée sur le serveur. Revenir sur la base est plus délicat : une migration descendante (down) n’est pas toujours sûre, car elle peut supprimer des données écrites entre-temps.
Les mêmes principes s’appliquent à d’autres plateformes, avec leurs commandes propres : voir notre guide déploiement Magento 2 en production et notre page mise en production PrestaShop.
Méthodes
Méthodes de déploiement Symfony : laquelle choisir ?
La méthode de déploiement Symfony dépend de la coupure acceptable, du rythme des livraisons et de l’infrastructure.
| Méthode | Interruption | Complexité | Quand la choisir |
|---|---|---|---|
| En place avec page de maintenance | Application indisponible le temps de l’installation, du cache et des migrations | Faible | Application interne, livraisons peu fréquentes, coupure planifiée acceptée par les utilisateurs |
| Release et lien symbolique | Quasi nulle si les migrations sont compatibles ; limitée à la bascule sinon | Moyenne | La plupart des applications Symfony sur un ou quelques serveurs |
| Build en CI et artefact | Quasi nulle ; aucune installation Composer ni compilation d’assets sur la production | Moyenne à élevée | Livraisons fréquentes, plusieurs serveurs, besoin de livrer exactement l’artefact testé |
| Blue-green | Quasi nulle : le trafic passe d’un environnement complet à un autre | Élevée | Application critique, infrastructure capable de doubler l’environnement ; base partagée à migrer avec soin |
| Conteneurs avec déploiement progressif | Quasi nulle : les nouvelles instances remplacent les anciennes au fil des tests de santé | Élevée | Infrastructure déjà orchestrée, équipe à l’aise avec Docker et Kubernetes |
Grille qualitative établie par Agillia. Quelle que soit la méthode, les migrations de base de données restent le facteur qui décide de l’interruption réelle.
Outils
Outils de déploiement Symfony : le comparatif
Aucun outil de déploiement Symfony ne s’impose partout : le bon est celui que votre équipe maîtrise et qui rejoue les mêmes étapes, avec un retour arrière prévu.
| Outil | Principe | Points forts | Points de vigilance |
|---|---|---|---|
| Manuel par SSH et Git | Un git pull et des commandes lancées à la main sur le serveur | Rien à installer, compréhensible par tous | Étapes oubliées, ordre variable, coupure pendant l’installation, aucune trace de qui a livré quoi |
| Scripts shell | Les commandes de mise en production réunies dans un script versionné avec le projet | Simple, sur mesure, répétable | Releases, dossiers partagés et retour arrière à écrire et à maintenir soi-même |
| Deployer | Outil de déploiement écrit en PHP, fondé sur des recettes, dont une recette Symfony | Même langage que l’application, releases et dossiers partagés gérés, retour arrière intégré | Recette à adapter au projet (workers, assets, migrations) ; outil à tenir à jour |
| Ansible | Automatisation de serveurs décrite dans des fichiers déclaratifs | Gère à la fois la configuration des serveurs et la livraison, adapté à plusieurs machines | Courbe d’apprentissage ; logique de release à structurer soi-même ou avec un rôle dédié |
| Pipelines CI/CD (GitLab CI, GitHub Actions, Jenkins) | Tests, build et déploiement déclenchés depuis le dépôt de code | Tests obligatoires avant livraison, artefact unique, historique des déploiements, accès SSH limités | Pipeline à maintenir ; il lance souvent un script ou Deployer pour l’étape finale |
| Conteneurs (Docker, Kubernetes) | L’application livrée sous forme d’images, remplacées par l’orchestrateur | Environnements identiques de la CI à la production, déploiement progressif | Exploitation plus lourde ; fichiers envoyés, sessions, migrations et workers à penser hors des conteneurs |
| Platform-as-a-Service (par exemple platform.sh / Upsun) | Une plateforme hébergée qui construit et déploie l’application à partir du dépôt | Infrastructure prise en charge par la plateforme | Dépendance à la plateforme et à sa configuration ; fonctions et conditions à vérifier dans sa documentation |
Comparatif qualitatif et neutre établi par Agillia. Les outils se combinent : un pipeline CI/CD peut appeler Deployer ou Ansible.
Méthode
Les quatre étapes d’une livraison en production Symfony
01
Préparer
La version est fusionnée dans la branche de production, testée et validée en préproduction. Les migrations sont relues, la base sauvegardée et le créneau annoncé.
02
Construire
Les dépendances sont installées sans outils de développement, l’autoloader optimisé et les assets compilés. Le résultat forme une release complète, prête à servir.
03
Déployer
La release est installée dans son répertoire et reliée aux dossiers partagés. Le cache est préchauffé, les migrations appliquées, puis le lien symbolique bascule et PHP-FPM est rechargé.
04
Vérifier
Les workers Messenger sont redémarrés, les tests de santé lancés et les journaux lus. Si un contrôle échoue, on revient à la release précédente.
Avant
Check-list avant un déploiement Symfony
Avant chaque déploiement Symfony en production, vérifiez ces points :
- Tests : tests unitaires et fonctionnels passés sur la version à livrer, recette validée.
- Analyse statique : outil d’analyse (PHPStan, Psalm ou équivalent) et contrôle du code exécutés dans l’intégration continue.
- Préproduction identique : mêmes versions de PHP, de base de données, de cache et de transport Messenger qu’en production.
- Migrations relues et compatibles : chaque migration lue avant livraison, compatible avec le code encore en service.
- Configuration de production : variables d’environnement et secrets présents pour cet environnement, mode debug désactivé.
- Sauvegarde : sauvegarde de la base faite juste avant la livraison et restauration déjà testée.
- Plan de retour arrière : critère d’annulation défini, release précédente conservée, personne qui décide identifiée.
Après
Check-list après un déploiement Symfony
Une livraison en production Symfony n’est terminée qu’après ces contrôles :
-
Workers relancés :
messenger:stop-workersexécuté et processus redémarrés par Supervisor ou systemd sur le nouveau code. - Files Messenger : messages consommés normalement, file des messages en échec surveillée.
- Cache chaud : cache de production préchauffé, OPcache réinitialisé, pages principales appelées une première fois.
- Tâches planifiées : tâches cron ou du Scheduler qui tournent sur la nouvelle release, sans doublon.
- Tests de santé : route de contrôle et parcours clés (connexion, formulaires, API) testés en production.
- Journaux : journaux de l’application, de PHP-FPM et du serveur web lus après la bascule.
- Temps de réponse : temps de réponse comparés à ceux d’avant la livraison.
Une lenteur après livraison se diagnostique avec notre guide performance d’une application Symfony. La configuration sûre est détaillée dans sécurité d’une application Symfony.
Agillia
Vos déploiements Symfony avec Agillia
Agillia scripte et assure les mises en production d’applications Symfony : livraisons testées en préproduction, sauvegarde avant chaque déploiement et retour arrière prévu. Agence web depuis plus de 20 ans, nous nous appuyons sur des experts seniors qui maintiennent des sites et des applications depuis plus de 16 ans. Symfony fait partie de notre quotidien : c’est le socle de PrestaShop 8 et 9, sur lequel reposent nos modules.
Nous travaillons en méthode agile, avec des livraisons fréquentes qui exigent un déploiement fiable. Pour une application dont nous héritons, nous commençons par un audit d’application Symfony, livraison comprise ; voir aussi notre guide reprise d’une application Symfony.
Les déploiements s’inscrivent ensuite dans une TMA Symfony, une offre de maintenance d’application Symfony ou un projet d’évolution Symfony. Voir aussi nos pages développement et maintenance Symfony, experts seniors, maintenance Laravel, notre lexique et notre demande de devis.
Pour aller plus loin
Pour aller plus loin sur le déploiement Symfony
- Audit d’application Symfony : l’état des lieux du code, des dépendances et de la chaîne de livraison.
- Maintenance d’application Symfony : des livraisons régulières et suivies.
- Maintenance Symfony : interventions et évolutions en méthode agile.
- Montée de version Symfony : migrer le framework étape par étape.
- TMA Symfony : la maintenance applicative confiée à une équipe senior.
- Sécurité d’une application Symfony : correctifs, secrets et configuration de production.
- Déploiement Magento 2 en production : les mêmes principes appliqués à Magento 2.
- Mise en production PrestaShop : livrer une boutique PrestaShop sans la fermer.
- Lexique de la maintenance : les définitions des termes employés dans ce guide.
Questions fréquentes
Vos questions sur le déploiement Symfony
Comment déployer une application Symfony en production ?
On configure l’environnement de production, on installe les dépendances sans outils de développement, puis on prépare le cache, les assets et la base. Les commandes clés sont composer install --no-dev --optimize-autoloader, cache:clear, la compilation des assets et doctrine:migrations:migrate. Puis on redémarre les workers Messenger.
Peut-on déployer une application Symfony sans interruption ?
Oui, en préparant chaque version dans un répertoire de release séparé puis en basculant un lien symbolique. Les migrations doivent rester compatibles avec l’ancien code pendant la bascule, selon le schéma élargir puis réduire. PHP-FPM est ensuite rechargé pour servir la nouvelle release.
Quel outil choisir pour déployer Symfony ?
Choisissez l’outil que votre équipe maîtrise et qui rend la livraison scriptée, répétable et réversible. Deployer, écrit en PHP et doté d’une recette Symfony, convient à beaucoup de projets ; Ansible, un pipeline CI/CD ou des conteneurs répondent à d’autres contextes.
Quelles variables d’environnement définir pour Symfony en production ?
Au minimum APP_ENV=prod et APP_DEBUG=0, plus les accès propres au serveur comme la base de données. Ces valeurs viennent de vraies variables d’environnement ou d’un fichier .env.local non versionné. Les données sensibles peuvent aller dans le coffre de secrets Symfony de l’environnement de production.
Faut-il vider le cache Symfony à chaque déploiement ?
Oui, le cache de production doit être reconstruit pour chaque nouvelle version du code. php bin/console cache:clear en environnement de production le vide et le préchauffe. Dans un répertoire de release, cela se fait avant la bascule.
Quand lancer les migrations Doctrine lors d’un déploiement Symfony ?
Lancez doctrine:migrations:migrate pendant le déploiement, une fois la release prête et la base sauvegardée. Si la migration est compatible avec l’ancien code, elle peut passer avant la bascule sans coupure. Sinon, découpez-la en plusieurs livraisons.
Pourquoi redémarrer les workers Messenger après une livraison Symfony ?
Parce qu’un worker Messenger garde en mémoire le code chargé à son lancement. Sans redémarrage, il traite les messages avec l’ancienne version. messenger:stop-workers leur demande de s’arrêter proprement, et Supervisor ou systemd les relance sur le nouveau code.
Comment annuler une mise en production Symfony qui pose problème ?
On rebascule le lien symbolique vers la release précédente, conservée sur le serveur, puis on recharge PHP-FPM et on redémarre les workers. Si la base a été modifiée de façon incompatible, une restauration de sauvegarde peut être nécessaire.
Fiabiliser vos mises en production Symfony
Décrivez-nous la façon dont votre application Symfony est livrée aujourd’hui : nous vous proposons une méthode de déploiement scriptée, testée en préproduction et réversible.
