TOC

Comment déployer une application Symfony en production sur Ubuntu 14.04

introduction

Symfony est un framework web open source écrit en PHP, adapté à la construction de projets de toutes tailles. Il fournit une structure bien conçue, basée sur des composants réutilisables, sur lesquels vous pouvez construire votre propre application PHP.

Ce tutoriel couvrira les étapes nécessaires au déploiement manuel d’une application Symfony de base sur un serveur Ubuntu 14.04. Nous verrons comment configurer correctement le serveur, en prenant en compte les mesures de sécurité et de performance, afin de réaliser une configuration prête pour la production.

Si vous recherchez un tutoriel d’introduction à Symfony, vous pouvez lire https://www.digitalocean.com/community/tutorials/how-to-install-and-get-started-with-symfony-2-on-ubuntu- 14-04 [comment installer et démarrer avec Symfony sur Ubuntu 14.04].

Conditions préalables

Pour ce tutoriel, vous aurez besoin de:

  • Une nouvelle Droplet Ubuntu 14.04 fonctionnant sous LAMP ou https : //www.digitalocean.com/community/tutorials/how-to-install-linux-nginx-mysql-php-lemp-stack-on-ubuntu-14-04 [LEMP]

  • Un utilisateur sudo non root, que vous pouvez configurer en suivant le tutoriel Initial Server Initial

Il est important de garder à l’esprit que le déploiement est un sujet très vaste car chaque application aura ses propres besoins. Pour que les choses restent simples, nous allons utiliser un exemple d’application de tâches créé avec Symfony. Vous pouvez trouver son code source sur GitHub.

Étape 1 - Installation des dépendances de serveur

Dans cette étape, nous allons installer les dépendances du serveur.

Commencez par mettre à jour le cache du gestionnaire de packages.

sudo apt-get update

Nous aurons besoin de + git + pour extraire les fichiers de l’application, + acl + pour définir les droits appropriés lors de l’installation de l’application, ainsi que deux extensions PHP (+ php5-cli + pour exécuter PHP en ligne de commande et ` + php5-curl + `pour Symfony). Installez les packages requis.

sudo apt-get install git php5-cli php5-curl acl

Enfin, nous aurons besoin de + composer + pour télécharger les dépendances de l’application. Pour installer + composer + à l’échelle du système, exécutez:

sudo curl -sS https://getcomposer.org/installer | sudo php -- --install-dir=/usr/local/bin --filename=composer

Vous devriez maintenant être prêt à partir.

Étape 2 - Configuration de MySQL

Commençons par préparer votre configuration MySQL pour la production. Pour la prochaine étape, vous aurez besoin du mot de passe du compte * root * MySQL. Assurez-vous que vous avez configuré MySQL en toute sécurité (comme indiqué à l’étape 2 de la page https://www.digitalocean.com/community/tutorials/how-to-install-linux-apache-mysql-php-lamp-stack-on). -ubuntu-14-04 # step-two-% E2% 80% 94-install-mysql [LAMP] et https://www.digitalocean.com/community/tutorials/how-to-install-linux-nginx-mysql -php-lemp-stack-on-ubuntu-14-04 # tutoriels-deux-% E2% 80% 94-tutoriels-install-mysql-à-gérer-site-données [LEMP]).

Définition du classement et du jeu de caractères par défaut

Symfony vous recommande de configurer le jeu de caractères et de faire correspondre votre base de données à + ​​utf8 +. La plupart des bases de données utilisent par défaut des classements de type latin, ce qui entraîne des résultats inattendus lors de la récupération de données précédemment stockées dans la base de données, telles que des caractères étranges et du texte illisible. Il n’ya aucun moyen de le configurer au niveau de l’application, nous devons donc éditer le fichier de configuration MySQL pour inclure quelques définitions.

Ouvrez le fichier + / etc / mysql / my.cnf + avec votre éditeur de ligne de commande préféré.

sudo nano /etc/mysql/my.cnf

Maintenant, trouvez le bloc * [mysqld] *. Ajoutez les options + collation-server + et + character-set-server + sous * Paramètres de base *.

/etc/mysql/my.cnf

[mysqld]
#
# * Basic Settings
#


user            = mysql
pid-file        = /var/run/mysqld/mysqld.pid
socket          = /var/run/mysqld/mysqld.sock

. . .

Sauvegarder et quitter. Redémarrez MySQL pour que les modifications prennent effet.

sudo service mysql restart

Création d’un utilisateur et d’une base de données pour l’application

Nous devons maintenant créer une base de données MySQL et un utilisateur pour notre application.

Tout d’abord, accédez au client MySQL en utilisant le compte MySQL * root *.

mysql -u root -p

On vous demandera un mot de passe. Ce devrait être le même mot de passe que vous avez utilisé lors de l’exécution de + mysql_secure_installation +.

Maintenant, créez la base de données d’application.

CREATE DATABASE ;
OutputQuery OK, 1 row affected (0.00 sec)

La base de données est maintenant créée. La prochaine étape consiste à créer un utilisateur MySQL et à lui donner accès à notre base de données nouvellement créée.

CREATE USER ''@'localhost' IDENTIFIED BY '';
OutputQuery OK, 0 rows affected (0.00 sec)

Cela créera un utilisateur nommé * todo-user *, avec le mot de passe * todo-password *. Il est important de noter que ce sont des exemples simples qui doivent être changés et que vous devez utiliser un mot de passe plus complexe pour votre utilisateur MySQL pour une sécurité renforcée.

Nous devons toujours accorder à cet utilisateur les autorisations appropriées sur notre base de données d’applications. Cela peut être fait avec:

GRANT ALL PRIVILEGES ON .* TO ''@'localhost';
OutputQuery OK, 0 rows affected (0.00 sec)

Ceci accordera à l’utilisateur * todo-user * tous les privilèges sur toutes les tables de la base de données + todo +. Pour appliquer les modifications, exécutez:

FLUSH PRIVILEGES;
OutputQuery OK, 0 rows affected (0.00 sec)

Pour vérifier si tout fonctionne comme prévu, quittez le client MySQL.

quit;

Maintenant, connectez-vous à nouveau, cette fois en utilisant le nouvel utilisateur MySQL et le mot de passe que vous venez de créer. Dans cet exemple, nous utilisons le nom d’utilisateur * todo-user *, avec le mot de passe * todo-password *.

mysql -u  -p

Vous pouvez vérifier les bases de données auxquelles cet utilisateur a accès avec:

SHOW DATABASES;

Le résultat devrait ressembler à ceci:

Output+--------------------+
| Database           |
+--------------------+
| information_schema |
|                |
+--------------------+
2 rows in set (0.00 sec)

Cela signifie que le nouvel utilisateur a été créé avec les bons privilèges. Vous ne devriez voir que deux bases de données: + information_schema + et + todo +.

Vous pouvez maintenant quitter le client MySQL.

quit;

Étape 3 - Vérification du code de l’application

Le déploiement est un sujet complexe en raison de la nature unique de la plupart des applications, même si nous ne considérons que les projets Symfony. Il est difficile de généraliser car chaque cas d’utilisation peut nécessiter des étapes de déploiement très spécifiques, telles que la migration d’une base de données ou l’exécution de commandes de configuration supplémentaires.

Afin de simplifier le flux du tutoriel, nous allons utiliser une application de démonstration de base construite avec Symfony. Vous pouvez également utiliser votre propre application Symfony, mais gardez à l’esprit que vous devrez peut-être exécuter des étapes supplémentaires en fonction des besoins de votre application.

Notre application est une simple liste de tâches qui vous permet d’ajouter et de supprimer des éléments et de modifier le statut de chaque élément. Les tâches à faire sont stockées dans une base de données MySQL. Le code source est disponible sur GitHub.

Nous allons utiliser Git pour vérifier le code de l’application. L’étape suivante consiste à choisir un emplacement qui servira de répertoire racine de notre application. Nous configurerons ensuite le serveur Web en conséquence. Pour ce tutoriel, nous allons utiliser + / var / www / todo-symfony +, créez donc ce répertoire maintenant.

sudo mkdir -p /var/www/

Avant de cloner le référentiel, changeons le propriétaire et le groupe du dossier afin que nous puissions utiliser les fichiers de projet avec notre compte utilisateur habituel. Remplacez sammy par votre nom d’utilisateur sudo non root.

sudo chown  /var/www/

Maintenant, déplacez vers le répertoire parent et clonez l’application.

cd /var/www
git clone
OutputCloning into 'todo-symfony'...
remote: Counting objects: 76, done.
remote: Compressing objects: 100% (61/61), done.
remote: Total 76 (delta 6), reused 76 (delta 6), pack-reused 0
Unpacking objects: 100% (76/76), done.
Checking connectivity... done.

Étape 4 - Correction des autorisations de dossier

Les fichiers de l’application se trouvent maintenant dans + / var / www / todo-symfony +, un répertoire appartenant à notre system user (dans ce tutoriel, nous utilisons * sammy * comme exemple). Cependant, le web server user (généralement * www-data *) doit également accéder à ces fichiers. Sinon, le serveur Web ne pourra pas servir l’application. En dehors de cela, deux répertoires nécessitent un arrangement d’autorisations spéciales: + app / cache et` + app / logs`. Ces répertoires doivent être accessibles en écriture à la fois à l’utilisateur système et à l’utilisateur du serveur Web.

Nous utiliserons ACL (listes de contrôle d’accès) pour configurer ces autorisations spéciales. Les ACL permettent d’obtenir des droits d’accès plus détaillés pour les fichiers et les répertoires. C’est ce dont nous avons besoin pour configurer les autorisations adéquates tout en évitant les arrangements trop permissifs.

Premièrement, nous devons autoriser l’utilisateur * www-data * à accéder aux fichiers du dossier de l’application. Donnez à cet utilisateur une permission read + execute (rX) dans tout le répertoire.

sudo setfacl -R -m u:www-data:rX

Ensuite, nous devons définir des autorisations spéciales pour les dossiers + cache et` + log`. Donnez les autorisations read + write + execute (rwX) à l’utilisateur * www-data * afin de permettre au serveur Web d’écrire uniquement dans ces répertoires.

sudo setfacl -R -m u:www-data:rwX /app/cache /app/logs

Enfin, nous définirons que tous les nouveaux fichiers créés dans les dossiers + app / cache + et + app / logs + suivent le même schéma d’autorisation que celui que nous venons de définir, avec des autorisations de lecture, d’écriture et d’exécution sur l’utilisateur du serveur Web. Ceci est fait en répétant la commande + setfacl + que nous venons d’exécuter, mais en ajoutant cette fois l’option + -d +.

sudo setfacl -dR -m u:www-data:rwX /app/cache /app/logs

Si vous voulez vérifier quelles autorisations sont actuellement en place dans un répertoire donné, vous pouvez utiliser + getfacl +.

getfacl /app/cache

Vous devriez obtenir une sortie semblable à ceci:

Output# file: todo-symfony/app/cache
# owner: sammy
# group: sammy
user::rwx
user:www-data:rwx
group::rwx
mask::rwx
other::r-x
default:user::rwx
default:user:www-data:rwx
default:group::rwx
default:mask::rwx
default:other::r-x

A partir de cette sortie, vous pouvez voir que même si le répertoire + app / cache + appartient à l’utilisateur * sammy *, il existe un ensemble d’autorisations supplémentaire pour l’utilisateur * www-data *. Les directives par défaut indiquent les autorisations que les nouveaux fichiers créés dans ce répertoire auront.

Étape 5 - Configuration de l’application

Nous avons maintenant les fichiers d’application en place, mais nous devons encore installer les dépendances du projet et configurer les paramètres de l’application.

Symfony est conçu pour fonctionner correctement dans différents environnements. Par défaut, il utilisera les paramètres de développement, qui influent sur la façon dont il gère le cache et les erreurs. Les environnements de développement ont des journaux plus étendus et détaillés, moins de contenu mis en cache et les erreurs sont exposées de manière évidente pour simplifier le débogage. Ceci est utile pour développer l’application, mais ce n’est pas une bonne pratique pour les environnements de production.

Pour ajuster l’application à la production, nous devons définir une variable d’environnement qui indique à Symfony que nous exécutons l’application dans un environnement de production.

export SYMFONY_ENV=prod

Ensuite, nous devons installer les dépendances du projet. Accédez au dossier de l’application et exécutez + composer install.

cd
composer install --no-dev --optimize-autoloader

À la fin du processus d’installation, vous devriez être invité à fournir des informations permettant de renseigner le fichier + parameters.yml +. Ce fichier contient des informations importantes pour l’application, telles que les paramètres de connexion à la base de données. Vous pouvez appuyer sur + ENTER + pour accepter les valeurs par défaut de toutes, à l’exception du nom de la base de données, du nom d’utilisateur et du mot de passe. Pour ceux-ci, utilisez les valeurs que vous avez créées dans link: # step-2-% E2% 80% 94-configure-mysql [step 2].

OutputCreating the "app/config/parameters.yml" file
Some parameters are missing. Please provide them.
database_host (127.0.0.1):
database_port (null):
database_name (symfony):
database_user (root):
database_password (null):
. . .

Lorsque l’installation est terminée, nous pouvons vérifier la connexion à la base de données à l’aide de la commande + doctrine: schema: validate + console.

php app/console doctrine:schema:validate
Output[Mapping]  OK - The mapping files are correct.
[Database] FAIL - The database schema is not in sync with the current mapping file.

La ligne OK signifie que la connexion à la base de données fonctionne. La ligne FAIL est attendue car nous n’avons pas encore créé le schéma de base de données. Faisons-le ensuite:

php app/console doctrine:schema:create
OutputATTENTION: This operation should not be executed in a production environment.

Creating database schema...
Database schema created successfully!

Cela créera toutes les tables d’application dans la base de données configurée, en fonction des informations de métadonnées obtenues à partir des entités d’application.

Maintenant, vous devriez vider le cache.

php app/console cache:clear --env=prod --no-debug
OutputClearing the cache for the prod environment with debug false

Et enfin, générer les actifs de l’application.

php app/console assetic:dump --env=prod --no-debug
OutputDumping all prod assets.
Debug mode is off.

14:02:39 [file+] /var/www/todo-symfony/app/../web/css/app.css
14:02:39 [dir+] /var/www/todo-symfony/app/../web/js
14:02:39 [file+] /var/www/todo-symfony/app/../web/js/app.js

Étape 6 - Configuration du serveur Web

Il ne reste plus qu’à configurer le serveur Web. Cela impliquera deux étapes: définir la directive + date.timezone dans` + php.ini` et mettre à jour le fichier de configuration de site Web par défaut (sur Apache ou Nginx) pour servir notre application.

Nous verrons comment accomplir ces étapes sur les environnements LEMP et LAMP.

Étapes de configuration pour Nginx + PHP-FPM

Commençons par éditer le fichier + php.ini par défaut pour définir le fuseau horaire du serveur. Il s’agit d’une condition préalable à l’exécution des applications Symfony, qui est généralement commentée lors de nouvelles installations de serveurs.

Ouvrez le fichier + / etc / php5 / fpm / php.ini.

sudo nano /etc/php5/fpm/php.ini

Recherchez la ligne contenant + date.timezone +. Supprimez la mise en commentaire de la directive en supprimant le signe +; + au début de la ligne et ajoutez le fuseau horaire approprié à votre application. Dans cet exemple, nous utiliserons + Europe / Amsterdam +, mais vous pouvez choisir n’importe quel supported timezone.

modifié /etc/php5/fpm/php.ini

[Date]
; Defines the default timezone used by the date functions
; http://php.net/date.timezone
date.timezone =

Enregistrez le fichier et quittez. Pour appliquer les modifications, redémarrez PHP.

sudo service php5-fpm restart

Ensuite, nous devons remplacer le fichier de configuration de site Web par défaut par un fichier personnalisé conçu pour servir une application Symfony. Créez d’abord une sauvegarde de la configuration de site Web par défaut actuelle.

cd /etc/nginx/sites-available
sudo mv default default-bkp

Créez un nouveau fichier pour remplacer l’ancien.

sudo nano /etc/nginx/sites-available/default

Collez le contenu suivant dans le fichier. N’oubliez pas de remplacer les valeurs + nom_serveur + pour refléter le nom de domaine ou l’adresse IP de votre serveur.

/ etc / nginx / sites-available / default

server {
   server_name ;
   root /var/www//web;

   location / {
       # try to serve file directly, fallback to app.php
       try_files $uri /app.php$is_args$args;
   }

   location ~ ^/app\.php(/|$) {
       fastcgi_pass unix:/var/run/php5-fpm.sock;
       fastcgi_split_path_info ^(.+\.php)(/.*)$;
       include fastcgi_params;
       fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
       # Prevents URIs that include the front controller. This will 404:
       # http://domain.tld/app.php/some-path
       # Remove the internal directive to allow URIs like this
       internal;
   }

   error_log /var/log/nginx/symfony_error.log;
   access_log /var/log/nginx/symfony_access.log;
}

Enregistrez le fichier et quittez. Pour appliquer les modifications, redémarrez Nginx.

sudo service nginx restart

Étapes de configuration pour Apache + PHP5 Web Server

Commençons par éditer le fichier + php.ini par défaut pour définir le fuseau horaire du serveur. Il s’agit d’une condition préalable à l’exécution des applications Symfony, qui est généralement commentée lors de nouvelles installations de serveurs.

Ouvrez le fichier + / etc / php5 / apache2 / php.ini:

sudo nano /etc/php5/apache2/php.ini

Recherchez la ligne contenant + date.timezone +. Supprimez la mise en commentaire de la directive en supprimant le signe +; + au début de la ligne et ajoutez le fuseau horaire approprié à votre application. Dans cet exemple, nous utiliserons + Europe / Amsterdam +, mais vous pouvez choisir n’importe quel supported timezone.

modifié /etc/php5/fpm/php.ini

[Date]
; Defines the default timezone used by the date functions
; http://php.net/date.timezone
date.timezone =

Enregistrez le fichier et quittez. Nous devons maintenant remplacer le fichier de configuration de site Web par défaut par un fichier personnalisé, conçu pour servir une application Symfony. Créez une sauvegarde de la configuration de site Web par défaut actuelle.

cd /etc/apache2/sites-available
sudo mv 000-default.conf default-bkp.conf

Créez un nouveau fichier pour remplacer l’ancien.

sudo nano /etc/apache2/sites-available/000-default.conf

Collez le contenu suivant dans le fichier.

/etc/apache2/sites-available/000-default.conf

<VirtualHost *:80>

   DocumentRoot /var/www//web
   <Directory /var/www//web>
       AllowOverride None
       Order Allow,Deny
       Allow from All

       <IfModule mod_rewrite.c>
           Options -MultiViews
           RewriteEngine On
           RewriteCond %{REQUEST_FILENAME} !-f
           RewriteRule ^(.*)$ app.php [QSA,L]
       </IfModule>
   </Directory>

   # uncomment the following lines if you install assets as symlinks
   # or run into problems when compiling LESS/Sass/CoffeScript assets
   # <Directory /var/www/project>
   #     Options FollowSymlinks
   # </Directory>

   ErrorLog /var/log/apache2/symfony_error.log
   CustomLog /var/log/apache2/symfony_access.log combined
</VirtualHost>

Si vous utilisez un nom de domaine pour accéder à votre serveur au lieu de la seule adresse IP, vous pouvez éventuellement définir les valeurs + NomServeur + et + ServerAlias ​​+, comme indiqué ci-dessous. Sinon, vous pouvez les omettre.

/etc/apache2/sites-available/000-default.conf

<VirtualHost *:80>



   DocumentRoot /var/www/todo-symfony/web
. . .

Enregistrez le fichier et quittez. Nous devons également activer + mod_rewrite + pour Apache.

sudo a2enmod rewrite

Pour appliquer toutes les modifications, redémarrez Apache.

sudo service apache2 restart

Étape 7 - Accéder à l’application

Votre serveur devrait être prêt à servir l’application de démonstration Symfony. Visitez + http: // + dans votre navigateur et vous devriez voir une page comme celle-ci:

image: https: //assets.digitalocean.com/articles/symfony_1404/todo-symfony.png [Aperçu de l’application Symfony To-Do]

Vous pouvez utiliser le formulaire pour créer de nouvelles tâches et tester les fonctionnalités de l’application.

Conclusion

Le déploiement de toute application en production nécessite une attention particulière aux détails, comme la création d’un utilisateur de base de données dédié avec un accès limité et la définition des autorisations de répertoire appropriées sur le dossier de l’application. Ces étapes sont nécessaires pour accroître la sécurité des serveurs et des applications dans les environnements de production. Dans ce tutoriel, nous avons vu les étapes spécifiques à suivre pour déployer manuellement une application Symfony de base en production sur un serveur Ubuntu 14.04.

Related