How to Deploy a Symfony ApplicationEdit this page
Warning: You are browsing the documentation for Symfony 2.8, which is no longer maintained.
Read the updated version of this page for Symfony 6.1 (the current stable version).
- Symfony Deployment Basics
- How to Deploy a Symfony Application
- Common Post-Deployment Tasks
- Application Lifecycle: Continuous Integration, QA, etc.
Deploying a Symfony application can be a complex and varied task depending on the setup and the requirements of your application. This article is not a step- by-step guide, but is a general list of the most common requirements and ideas for deployment.
The typical steps taken while deploying a Symfony application include:
- Upload your code to the production server;
- Install your vendor dependencies (typically done via Composer and may be done before uploading);
- Running database migrations or similar tasks to update any changed data structures;
- Clearing (and optionally, warming up) your cache.
A deployment may also include other tasks, such as:
- Tagging a particular version of your code as a release in your source control repository;
- Creating a temporary staging area to build your updated setup "offline";
- Running any tests available to ensure code and/or server stability;
- Removal of any unnecessary files from the
web/directory to keep your production environment clean;
- Clearing of external cache systems (like Memcached or Redis).
There are several ways you can deploy a Symfony application. Start with a few basic deployment strategies and build up from there.
The most basic way of deploying an application is copying the files manually via FTP/SCP (or similar method). This has its disadvantages as you lack control over the system as the upgrade progresses. This method also requires you to take some manual steps after transferring the files (see Common Post-Deployment Tasks)
If you're using source control (e.g. Git or SVN), you can simplify by having your live installation also be a copy of your repository. When you're ready to upgrade it is as simple as fetching the latest updates from your source control system. When using Git, a common approach is to create a tag for each release and check out the appropriate tag on deployment (see Git Tagging).
This makes updating your files easier, but you still need to worry about manually taking other steps (see Common Post-Deployment Tasks).
The specific deployment steps vary greatly from one service provider to another, so check out the dedicated article for the service of your choose:
There are also tools to help ease the pain of deployment. Some of them have been specifically tailored to the requirements of Symfony.
- A Symfony bundle that adds easy deploy tools to your application.
- This is another native PHP rewrite of Capistrano, with some ready recipes for Symfony.
- An Ansible role that allows you to configure a powerful deploy via YAML files.
- This Capistrano-like deployment tool is built in PHP, and may be easier for PHP developers to extend for their needs.
- This Python-based library provides a basic suite of operations for executing local or remote shell commands and uploading/downloading files.
- Capistrano with Symfony plugin
- Capistrano is a remote server automation and deployment tool written in Ruby. Symfony plugin is a plugin to ease Symfony related tasks, inspired by Capifony (which works only with Capistrano 2).
- Helps you build a native Debian package for your Symfony project.
- Basic scripting
- You can of course use shell, Ant or any other build tool to script the deploying of your project.
After deploying your actual source code, there are a number of common things you'll need to do:
Check if your server meets the requirements by running:
$ php app/check.php
Most Symfony applications define configuration parameters in a file called
app/config/parameters.yml. This file should not be deployed, because
Symfony generates it automatically using the
file as a template (that's why
parameters.yml.dist must be committed and
If your application uses environment variables instead of these parameters, you must define those env vars in your production server using the tools provided by your hosting service.
Your vendors can be updated before transferring your source code (i.e.
vendor/ directory, then transfer that with your source
code) or afterwards on the server. Either way, just update your vendors
as you normally do:
$ composer install --no-dev --optimize-autoloader
--optimize-autoloader flag improves Composer's autoloader performance
significantly by building a "class map". The
--no-dev flag ensures that
development packages are not installed in the production environment.
If you get a "class not found" error during this step, you may need to
export SYMFONY_ENV=prod before running this command so that
post-install-cmd scripts run in the
Make sure you clear (and warm-up) your Symfony cache:
$ php app/console cache:clear --env=prod --no-debug
If you're using Assetic, you'll also want to dump your assets:
$ php app/console assetic:dump --env=prod --no-debug
There may be lots of other things that you need to do, depending on your setup:
- Running any database migrations
- Clearing your APC cache
assets:install(already taken care of in
- Add/edit CRON jobs
- Pushing assets to a CDN
While this article covers the technical details of deploying, the full lifecycle of taking code from development up to production may have more steps: deploying to staging, QA (Quality Assurance), running tests, etc.
The use of staging, testing, QA, continuous integration, database migrations and the capability to roll back in case of failure are all strongly advised. There are simple and more complex tools and one can make the deployment as easy (or sophisticated) as your environment requires.
Don't forget that deploying your application also involves updating any dependency (typically via Composer), migrating your database, clearing your cache and other potential things like pushing assets to a CDN (see Common Post-Deployment Tasks).