Configuration

Warning: You are browsing the documentation for Symfony 3.x, which is no longer maintained.

Read the updated version of this page for Symfony 7.1 (the current stable version).

Configuration usually involves different application parts (such as infrastructure and security credentials) and different environments (development, production). That's why Symfony recommends that you split the application configuration into three parts.

Best Practice

Define the infrastructure-related configuration options in the app/config/parameters.yml file.

The default parameters.yml file follows this recommendation and defines the options related to the database and mail server infrastructure:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# app/config/parameters.yml
parameters:
    database_driver:   pdo_mysql
    database_host:     127.0.0.1
    database_port:     ~
    database_name:     symfony
    database_user:     root
    database_password: ~

    mailer_transport:  smtp
    mailer_host:       127.0.0.1
    mailer_user:       ~
    mailer_password:   ~

    # ...

These options aren't defined inside the app/config/config.yml file because they have nothing to do with the application's behavior. In other words, your application doesn't care about the location of your database or the credentials to access to it, as long as the database is correctly configured.

Canonical Parameters

Best Practice

Define all your application's parameters in the app/config/parameters.yml.dist file.

Symfony includes a configuration file called parameters.yml.dist, which stores the canonical list of configuration parameters for the application.

Whenever a new configuration parameter is defined for the application, you should also add it to this file and submit the changes to your version control system. Then, whenever a developer updates the project or deploys it to a server, Symfony will check if there is any difference between the canonical parameters.yml.dist file and your local parameters.yml file. If there is a difference, Symfony will ask you to provide a value for the new parameter and it will add it to your local parameters.yml file.

Best Practice

Define the application behavior related configuration options in the app/config/config.yml file.

The config.yml file contains the options used by the application to modify its behavior, such as the sender of email notifications, or the enabled feature toggles. Defining these values in parameters.yml file would add an extra layer of configuration that's not needed because you don't need or want these configuration values to change on each server.

The configuration options defined in the config.yml file usually vary from one environment to another. That's why Symfony already includes app/config/config_dev.yml and app/config/config_prod.yml files so that you can override specific values for each environment.

Constants vs Configuration Options

One of the most common errors when defining application configuration is to create new options for values that never change, such as the number of items for paginated results.

Best Practice

Use constants to define configuration options that rarely change.

The traditional approach for defining configuration options has caused many Symfony applications to include an option like the following, which would be used to control the number of posts to display on the blog homepage:

1
2
3
# app/config/config.yml
parameters:
    homepage.number_of_items: 10

If you've done something like this in the past, it's likely that you've in fact never actually needed to change that value. Creating a configuration option for a value that you are never going to configure just isn't necessary. Our recommendation is to define these values as constants in your application. You could, for example, define a NUMBER_OF_ITEMS constant in the Post entity:

1
2
3
4
5
6
7
8
9
// src/AppBundle/Entity/Post.php
namespace AppBundle\Entity;

class Post
{
    const NUMBER_OF_ITEMS = 10;

    // ...
}

The main advantage of defining constants is that you can use their values everywhere in your application. When using parameters, they are only available from places with access to the Symfony container.

Constants can be used for example in your Twig templates thanks to the constant() function:

1
2
3
<p>
    Displaying the {{ constant('NUMBER_OF_ITEMS', post) }} most recent results.
</p>

And Doctrine entities and repositories can access these values too, whereas they cannot access the container parameters:

1
2
3
4
5
6
7
8
9
10
11
12
namespace AppBundle\Repository;

use AppBundle\Entity\Post;
use Doctrine\ORM\EntityRepository;

class PostRepository extends EntityRepository
{
    public function findLatest($limit = Post::NUMBER_OF_ITEMS)
    {
        // ...
    }
}

The only notable disadvantage of using constants for this kind of configuration values is that it's complicated to redefine their values in your tests.

Parameter Naming

Best Practice

The name of your configuration parameters should be as short as possible and should include a common prefix for the entire application.

Using app. as the prefix of your parameters is a common practice to avoid collisions with Symfony and third-party bundles/libraries parameters. Then, use just one or two words to describe the purpose of the parameter:

1
2
3
4
5
6
7
8
9
10
# app/config/config.yml
parameters:
    # don't do this: 'dir' is too generic and it doesn't convey any meaning
    app.dir: '...'
    # do this: short but easy to understand names
    app.contents_dir: '...'
    # it's OK to use dots, underscores, dashes or nothing, but always
    # be consistent and use the same format for all the parameters
    app.dir.contents: '...'
    app.contents-dir: '...'

Semantic Configuration: Don't Do It

Best Practice

Don't define a semantic dependency injection configuration for your bundles.

As explained in How to Load Service Configuration inside a Bundle article, Symfony bundles have two choices on how to handle configuration: normal service configuration through the services.yml file and semantic configuration through a special *Extension class.

Although semantic configuration is much more powerful and provides nice features such as configuration validation, the amount of work needed to define that configuration isn't worth it for bundles that aren't meant to be shared as third-party bundles.

Moving Sensitive Options Outside of Symfony Entirely

When dealing with sensitive options, like database credentials, we also recommend that you store them outside the Symfony project and make them available through environment variables:

1
2
3
4
5
# app/config/config.yml
doctrine:
    dbal:
        # ...
        password: "%env(DB_PASSWORD)%"

3.2

Support for runtime environment variables via the %env(...)% syntax was introduced in Symfony 3.2. Prior to version 3.2, you needed to use the special SYMFONY__ variables.

Next: Organizing Your Business Logic

This work, including the code samples, is licensed under a Creative Commons BY-SA 3.0 license.
TOC
    Version