How to Deploy a Symfony Application

Basic File Transfer

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)

Using Source Control

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).

Using Platforms as a Service

The specific deployment steps vary greatly from one service provider to another, so check out the dedicated article for the service of your choose:

Using Build Scripts and other Tools

There are also tools to help ease the pain of deployment. Some of them have been specifically tailored to the requirements of Symfony.

EasyDeployBundle

A Symfony bundle that adds deploy tools to your application.

Deployer

This is another native PHP rewrite of Capistrano, with some ready recipes for Symfony.

Ansistrano

An Ansible role that allows you to configure a powerful deploy via YAML files.

Magallanes

This Capistrano-like deployment tool is built in PHP, and may be easier for PHP developers to extend for their needs.

Fabric

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).

A) Check Requirements

Check if your server meets the requirements by running the following command provided by the symfony binary created when installing Symfony:

1

$ symfony check:requirements

B) Configure your Parameters File

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 app/config/parameters.yml.dist file as a template (that's why parameters.yml.dist must be committed and deployed).

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.

At the very least you need to define the SYMFONY_ENV=prod (or APP_ENV=prod if you're using Symfony Flex) to run the application in prod mode, but depending on your application you may need to define other env vars too.

C) Install/Update your Vendors

Your vendors can be updated before transferring your source code (i.e. update the vendor/ directory, then transfer that with your source code) or afterwards on the server. Either way, just update your vendors as you normally do:

1

$ composer install --no-dev --optimize-autoloader

D) Clear your Symfony Cache

Make sure you clear and warm-up your Symfony cache:

1

$ php bin/console cache:clear --env=prod --no-debug

E) Other Things!

There may be lots of other things that you need to do, depending on your setup:

• Running any database migrations
• Clearing your APC cache
• Add/edit CRON jobs
• Building and minifying your assets with Webpack Encore
• Pushing assets to a CDN

• ---

Deployments not Using the composer.json File

Symfony applications provide a kernel.project_dir parameter and a related getProjectDir() method. You can use this method to perform operations with file paths relative to your project's root directory. The logic to find that project root directory is based on the location of the main composer.json file.

If your deployment method doesn't use Composer, you may have removed the composer.json file and the application won't work on the production server. The solution is to override the getProjectDir() method in the application kernel and return your project's root directory:

1
2
3
4
5
6
7
8
9
10
11

// app/AppKernel.php
// ...
class AppKernel extends Kernel
{
    // ...

    public function getProjectDir()
    {
        return dirname(__DIR__);
    }
}