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 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, fetch 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 Deployment Tasks).

Using Platforms as a Service

Using a Platform as a Service (PaaS) can be a great way to deploy your Symfony app quickly. There are many PaaS, but we recommend Platform.sh as it provides a dedicated Symfony integration and helps fund the Symfony development.

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.

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

There are some technical requirements for running Symfony applications. In your development machine, the recommended way to check these requirements is to use Symfony CLI. However, in your production server you might prefer to not install the Symfony CLI tool. In those cases, install this other package in your application:

1

$ composer require symfony/requirements-checker

Then, make sure that the checker is included in your Composer scripts:

1
2
3
4
5
6
7
8
9
10
11
12

{
    "...": "...",

    "scripts": {
        "auto-scripts": {
            "vendor/bin/requirements-checker": "php-script",
            "...": "..."
        },

        "...": "..."
    }
}

B) Configure your Environment Variables

Most Symfony applications read their configuration from environment variables. While developing locally, you'll usually store these in .env and .env.local (for local overrides). On production, you have two options:

1. Create "real" environment variables. How you set environment variables, depends on your setup: they can be set at the command line, in your Nginx configuration, or via other methods provided by your hosting service;
2. Or, create a .env.local file like your local development.

There is no significant advantage to either of the two options: use whatever is most natural in your hosting environment.

1

$ composer dump-env prod

1

$ composer dump-env prod --empty

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, 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

$ APP_ENV=prod APP_DEBUG=0 php bin/console cache:clear

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 APCu cache
• Add/edit CRON jobs
• Restarting your workers
• Building and minifying your assets with Webpack Encore
• Compile your assets if you're using the AssetMapper component
• Pushing assets to a CDN
• On a shared hosting platform using the Apache web server, you may need to install the symfony/apache-pack package
• etc.

Deployments not Using the composer.json File

The project root directory (whose value is used via the kernel.project_dir parameter and the getProjectDir() method) is calculated automatically by Symfony as the directory where the main composer.json file is stored.

In deployments not using the composer.json file, you'll need to override the getProjectDir() method as explained in this section.