Installer Laravel sur Ubuntu 18.04 Avec Nginx, PHP et Docker

Apprenez à installer Laravel sur Ubuntu : Laravel est un framework PHP open source flexible et léger avec un modèle de conception MVC (Model-View Controller). Ce framework est une excellente alternative à Symfony. Laravel a été conçu pour faciliter les développements plus ou moins complexes avec une grande flexibilité et modularité.

Ce framework offre de belles performances mais attention à suivre les best practices lorsque le volume de données traitées par les fonctions devient important. Ce point fera l’object d’un futur article.

Ce tutoriel a pour but de vous initier pas à pas à l’installation d’une application Laravel sur votre serveur de production.

À l’issue de celui-ci, vous serez en mesure de :

  • Installer un serveur de production sécurisé et initialiser les utilisateurs Linux
  • Installer NGINX et PHP-FPM 7.4
  • Mettre en place une architecture Docker répondant aux besoins basiques de Laravel (MySQL ou MariaDB + Redis)
  • Exploiter votre application Laravel sur votre serveur de production opérationnel

À noter que ce tutoriel convient également à l’installation en production d’une application PHP classique ou Symfony.

Ce tutoriel est composé de trois chapitres :

  1. Configuration de base du serveur Ubuntu 18.04
  2. Installation des composants nécessaires au serveur web (NGINX et PHP 7.4)
  3. Installation des composants nécessaires à l’exploitation de Laravel sous Docker (MySQL ou MariaDB + Redis)



Installer Laravel Sur Ubuntu 18.04 Avec Nginx, PHP Et Docker
Qwenty Ubuntu Strasbourg tuto laravel
Qwenty Nginx Strasbourg tuto laravel
Qwenty Docker Strasbourg tuto laravel

Installer Laravel sur Ubuntu Chapitre 1 – Configuration de base Ubuntu 18.04

Pour installer Laravel sur Ubuntu 18.04, il est nécessaire de suivre quelques étapes de configuration de base. Ceci augmentera la sécurité et la maintenabilité de votre serveur et vous donnera une base solide pour les actions ultérieures.

Connectez-vous en tant que root : 

> ssh root@your_server_ip

Ajoutez un nouvel utilisateur : 

> adduser sammy

Donnez à Sammy les privilèges d’administrateur : 

> usermod -aG sudo sammy



Configurez le firewall : 

Le firewall permet de bloquer la plupart des attaques sur votre serveur en ne laissant ouvert que les ports dont vous avez vraiment besoin. Différentes applications peuvent enregistrer leurs profils auprès de UFW lors de l’installation. Ces profils permettent à UFW de gérer ces applications par nom. OpenSSH, le service qui nous permet de nous connecter à notre serveur a un profil enregistré auprès de UFW.

Vous pouvez le vérifier en tapant:
> ufw app list

Qui nous donne :
Available applications:
OpenSSH

Si OpenSSH n’est pas enregistré auprès de UFW, tapez :
> ufw allow OpenSSH

Activez ensuite le firewall (après avoir autorisé OpenSSH) :
> ufw enable

Actuellement, le firewall bloque toutes les connexions sauf OpenSSH. Notre nouvelle application va utiliser le port 80 (http) et 443 (https). Pour accéder au serveur, nous utilisons le port 22. Il va être nécessaire d’ouvrir les ports ; tapez :

> sudo ufw allow 80
> sudo ufw allow 443
> sudo ufw allow 22/tcp

La configuration de base du serveur est maintenant terminée. La prochaine étape vise à restreindre l’accès SSH au serveur à Sammy. Pour une sécurité accrue, l’accès avec mot de passe sera désactivé ; cet utilisateur devra se connecter en utilisant une clé SSH.

Configurer l’authentification par clé SSH sur Ubuntu 18.04

Nous allons maintenant nous concentrer sur la configuration de clés SSH pour une installation Ubuntu 18.04. Les clés SSH constituent un moyen simple et sécurisé de se connecter à votre serveur et sont recommandées pour tous les utilisateurs.

Créez une paire de clés (privée + publique) sur votre ordinateur :

> ssh-keygen

Par défaut, ssh-keygen crée une paire de clés RSA de 2 048 bits, ce qui est suffisamment sécurisé pour la plupart des cas d’utilisation (vous pouvez éventuellement passer l’argument -b 4096 pour créer une clé plus volumineuse de 4 096 bits).

Après avoir entré la commande, vous devriez voir le résultat suivant :

Generating public/private rsa key pair.
Enter file in which to save the key (/your_home/.ssh/id_rsa):



Appuyez sur Entrée pour valider la destination par défaut, ou entrez un nom de fichier manuellement et appuyez sur Entrée. Attention, si un message vous indique que la clé existe déjà, vous pouvez l’écraser mais vous ne serez plus en mesure de vous connecter aux services utilisés par cette clé. Dans ce cas, je vous conseil de changer le nom de la nouvelle clé avant d’appuyer sur Entrée.

Vous devriez voir la ligne suivante :

Enter passphrase (empty for no passphrase):

Vous n’êtes pas obligé de renseigner un mot de passe mais ceci peut être recommandé dans les cas où votre serveur nécessite une sécurité renforcée.

Appuyez sur Entrée, le message suivant indique que votre clé a été crée avec succès :

Your identification has been saved in /your_home/.ssh/id_rsa.
Your public key has been saved in /your_home/.ssh/id_rsa.pub.
The key fingerprint is:
a9:49:2e:2a:5e:33:3e:a9:de:4e:77:11:58:b6:90:26 username@remote_host
The key's randomart image is:
+--[ RSA 2048]----+
| ..o |
| E o= . |
| o. o |
| .. |
| ..S |
| o o. |
| =o.+. |
|. =++.. |
|o=++. |
+-----------------+

La clé est maintenant présente sur votre machine en local. Nous allons la transférer sur notre nouveau serveur Ubuntu 18.04.

Affichez le contenu de votre clé sur votre machine locale :
> cat ~/.ssh/id_rsa.pub

Copiez la clé affichée en sortie (ssh-rsa XXXXX….).

Oublions maintenant votre machine locale ; les instructions suivantes se passent sur le nouveau serveur Ubuntu 18.04.

Retournez sur le serveur que nous venons de configurer (ssh sammy@your_server_ip si vous vous êtes déconnecté depuis) et créez le nouveau dossier suivant :

> mkdir -p ~/.ssh

Nous allons maintenant autoriser la clé :
> echo la_cle_que_vous_avez_copié >> ~/.ssh/authorized_keys

Vérifiez et configurez automatiquement les droits d’accès au dossier qui contient les clés (toujours sur le serveur) :
> chmod -R go= ~/.ssh
> chown -R sammy:sammy ~/.ssh

Pour optimiser la sécurité de votre serveur, je vous conseil de désactiver l’accès par mot de passe :

Ouvrez le fichier suivant :

> sudo nano /etc/ssh/sshd_config

Dans ce fichier, cherchez « PasswordAuthentication » et passez le à « no » :PasswordAuthentication no

Et enfin, désactivez l’accès root au serveur (identifiant par défaut de connexion) en cherchant « PermitRootLogin » et en le passant à « no » :PermitRootLogin no

Enregistrez le fichier et redémarrez le service SSH :
sudo service ssh restart

Vous pouvez maintenant vous connecter au serveur en utilisant la paire de clés générée. Si vous développez sous MacOS, je vous conseille l’excellent Termius pour gérer vos accès et clés SSH.

Vous disposez maintenant d’une machine configurée et prête à l’emploi. Dans le prochain chapitre, nous allons installer les différents composants nécessaire au serveur web (NGINX + PHP-FPM 7.4).

Installer Laravel sur Ubuntu Chapitre 2 – Installation de NGINX sur Ubuntu 18.04

Connectez-vous en SSH avec l’utilisateur créé dans le premier chapitre

> ssh sammy@your_server_ip

Installez NGINX : 

> sudo apt-get update
> sudo apt install nginx

Aussi simple que ça ! Voici la liste des principales commandes pour gérer NGINX depuis Ubuntu 18.04 :

> sudo systemctl stop nginx.service
> sudo systemctl start nginx.service
> sudo systemctl enable nginx.service



Pour vérifier que NGINX s’est bien installé et est actif, rendez-vous sur votre navigateur et tapez l’adresse ip du serveur ou votre nom de domaine et vérifier que le texte suivant s’affiche bien :

tuto-laravel-nginx-strasbourg-qwenty

Installation de PHP 7.4 FPM et des modules associés

Ajoutez le repository suivant à votre machine : 

> sudo apt-get install software-properties-common
> sudo add-apt-repository ppa:ondrej/php

Puis mettez à jour votre système avec le nouveau repository :
> sudo apt update

Installez PHP 7 et les modules nécessaires à Laravel :
> sudo apt install php-fpm php-common php-mbstring php-xmlrpc php-soap php-gd php-xml php-cli php-curl php-zip

Plusieurs versions de PHP sont installées ; par défaut, c’est la dernière qui est utilisée. Pour switcher de version, utilisez la commande interactive (pour ce tutoriel, choisissez PHP 7.4):
> sudo update-alternatives --config php

Éditez le fichiers suivant :
> sudo nano /etc/php/7.4/fpm/php.ini

Et modifiez les valeur suivantes suivant vos besoins :
file_uploads = On
allow_url_fopen = On
memory_limit = 256M
upload_max_filesize = 100M
cgi.fix_pathinfo = 0
max_execution_time = 360
date.timezone = America/Chicago

Une fois les modifications effectuées, enregistrez le fichier et fermez-le.

Redémarrez NGINX :
> sudo systemctl restart nginx.service

NGINX – Configuration de notre site

Créez un nouveau dossier qui va contenir le code source de votre application Laravel : 

> sudo mkdir /var/www/html/mon-application-laravel

Transférez votre code source dans ce dossier (via SFTP ou en utilisant votre repository Git). Appliquez ensuite les droits adéquats :
> sudo chown -R sammy:www-data /var/www/html/mon-application-laravel
> sudo chmod -R 755 /var/www/html/mon-application-laravel
> sudo chmod -R ug+rwx /var/www/html/mon-application-laravel/storage /var/www/html/mon-application-laravel/bootstrap/cache

Pour installer les dépendances, vous allez avoir besoin de Composer.

Mettez à jour votre système :
> sudo apt update

Installez PHP-CLI et les modules nécessaires :
> sudo apt install curl php-cli php-mbstring git unzip

Installez Composer :
> cd ~
> curl -sS https://getcomposer.org/installer -o composer-setup.php
> sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer

Puis placez-vous dans le dossier qui contient le code source de votre application Laravel :
> cd /var/www/html/mon-application-laravel

Et installez les dépendances du projet via :
> composer install

Nous verrons dans le troisième chapitre comment créer nos composants nécessaires au fonctionnement de notre application (MySQL ou MariaDB + Redis).

Maintenant que le code source de notre projet Laravel est en place sur le serveur, revenons à la configuration de notre application sur NGINX.

Éditez le fichier suivant : 

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

Et utilisez le modèle suivant :

server {
listen 80;
listen [::]:80;
root /var/www/html/mon-application-laravel/public;
index index.php index.html index.htm;
server_name example.com;
client_max_body_size 100M;
location / {
try_files $uri $uri/ /index.php?$args;
}
location ~ \.php$ {
include snippets/fastcgi-php.conf;
fastcgi_pass unix:/var/run/php/php7.4-fpm.sock;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
include fastcgi_params;
}
location ~* \.(?:jpg|jpeg|gif|png|ico|cur|gz|svg|svgz|mp4|ogg|ogv|webm|htc)$ {
expires 7d;
access_log off;
add_header Cache-Control "public";
}
# CSS and Javascript
location ~* \.(?:css|js)$ {
expires 7d;
access_log off;
add_header Cache-Control "public";
}
}



Modifiez la ligne « server_name » par votre nom de domaine.

Redémarrez NGINX :

> sudo systemctl restart nginx.service

Notre serveur est maintenant installé, mais votre site risque de ne pas encore fonctionner si il nécessite une connexion à une base SQL ; nous verrons ça plus tard dans le chapitre 3.

En attendant, nous pouvons vérifier que NGINX fonctionne bien ; rendez-vous sur votre navigateur web et tapez l’URL de votre site ; si tout a bien été paramétré, la page d’accueil de votre site s’affiche. Le cas contraire, vérifiez que votre site n’a pas besoin d’une connexion à une base de données SQL (nous reviendrons sur ce point dans le chapitre 3) et que NGINX fonctionne bien.

En cas d’anomalie, vérifiez les logs :

> cat /var/log/nginx/error.log

Installer l’HTTPS sur notre site

Nous allons maintenant installer un certificat HTTPS gratuit (niveau de sécurité égal aux payants de première catégorie) qui se renouvèlera automatiquement. En savoir plus sur Let’s Encrypt.

> sudo apt-get update
> sudo apt-get install software-properties-common
> sudo add-apt-repository universe
> sudo add-apt-repository ppa:certbot/certbot
> sudo apt-get update
> sudo apt-get install certbot python3-certbot-nginx

Vous pouvez maintenant utiliser l’assistant de configuration :

> sudo certbot --nginx

Et voilà !

Vous disposez maintenant d’un serveur sécurisé qui distribue votre application via le protocole HTTPS.

Il ne vous reste qu’une dernière étape : installer les composants nécessaires pour faire tourner votre application Laravel (MySQL ou MariaDB + Redis). Dans le prochain chapitre, nous allons installer Docker et configurer rapidement les composants nécessaires.

Installer Laravel sur Ubuntu Chapitre 3 – Installer Docker sur votre serveur

Premièrement, mettez à jour vos packages :

> sudo apt update

Ensuite, installez quelques paquets pré-requis qui permettent à apt d’utiliser des paquets via HTTPS :

> sudo apt install apt-transport-https ca-certificates curl software-properties-common

Ajoutez la clé GPG et le repository Docker à votre système :

> curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

> sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable"

À noter que « bionic » correspond à la version 18 d’Ubuntu. Modifiez cette valeur avec la version de votre système.

> sudo apt update

> sudo apt install docker-ce

Docker est maintenant installé, son daemon est actif et il est programmé pour se lancer au démarrage de votre machine. Vous pouvez vérifier ceci en tapant :

> sudo systemctl status docker

 

Mettre en place MySQL sous Docker

Nous allons maintenant ajouter l’image Docker MySQL à notre système :

> sudo docker pull mysql:5.7

Si vous souhaitez accéder à MySQL depuis une machine distante (typiquement votre ordinateur), ne téléchargez pas la dernière version de MySQL  (8.0.15) qui présente des problèmes des compatibilité avec SSH. Utilisez le tag mentionné dans la commande précédente.

Une fois l’image téléchargée, nous allons créer une instance Docker de MySQL :

> docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -p:3306:3306 -d mysql:5.7

Explications :

  • -e représente l’initialisation d’une variable d’environnement, en l’occurence MYSQL_ROOT_PASSWORD qui est initialisée ici à my-secret-pw. À noter que pour vous connecter à votre instance MySQL, vous devrez utiliser dans cet exemple le couple d’identifiant / mot de passe « root » / « my-secret-pw ».
  • -p indique qu’on expose le port 3306 de notre container sur le port 3306 de notre machine physique. Le format de cet argument est le suivant : hostPort:containerPort. Ceci va permettre à nos application Laravel de discuter avec ce container via le port SQL par défaut.
  • -d indique que le container s’execute en tâche de fond (detached).

Une fois la commande lancée, vous pouvez voir la liste de vos containers créés en tapant la commande :

> sudo docker ps -a

La première colonne de chaque ligne contient l’identifiant unique du container. Celui-ci va nous servir à stopper, relancer et supprimer un container. Cet identifiant peut être long à retenir ou à taper : retenez simplement ses 3 premiers caractères, Docker reconnaît automatiquement un container dont l’identifiant a été renseigné partiellement. Voici les commandes basiques liées aux containers :

Stopper un container :

> sudo docker stop id_du_container

Lancer un container précédemment stoppé :

> sudo docker start id_du_container

Supprimer un container (irréversible et seulement si celui-ci est stoppé) :

> sudo docker rm id_du_container

On y est ! Si vous souhaitez vous connecter au MySQL de votre serveur sur une machine distante, passez par une connection SSH (si vous êtes sur MacOS, je vous conseille l’excellent Sequel Pro).

Il ne vous reste plus qu’à créer votre nouvelle base de données et de modifier le fichier .env de votre application Laravel :

  • DB_CONNECTION=mysql
  • DB_HOST=127.0.0.1
  • DB_PORT=3306
  • DB_DATABASE=votre_nouvelle_base_de_données
  • DB_USERNAME=root
  • DB_PASSWORD=my-secret-password

Mettre en place Redis sous Docker

Si vous souhaitez gérer le cache de votre application via Redis, ajoutez l’image Redis à votre système :

> docker pull redis

Une fois l’image téléchargée, créez une instance Docker de Redis :

> docker run --name some-redis -p 6379:6379 -d redis

Il ne vous reste plus qu’à installer les packages prérequis par Laravel (la doc ici)  et modifier le fichier .env de votre application Laravel.



Conclusion

Vous disposez maintenant d’une stack Laravel Sur Ubuntu 18.04 Avec Nginx, PHP Et Docker (MySQL et Redis) prête à l’emploi et évolutive. Cette architecture est basique et permet de faire tourner sans problème votre application Laravel.

Observez la facilité d’installation des différents containers Docker ; vous pouvez maintenant imaginer de nouvelles perspectives pour votre application (ElasticSearch, MongoDB, Jenkins, Solr)… Ces composants sont très simples à installer et vont vous ouvrir de nouvelles possibilités !

Gatien Sancho

Gatien Sancho

Passionné de développement et nouvelles technologies, j'ai plaisir à partager mon savoir-faire avec les entreprises qui désirent donner un coup de pouce à la compétitivité de leurs services.

QWENTY

Développement, Cloud, Business Intelligence à Strasbourg.

 

À PROPOS

7 rue de Bucarest

67000 STRASBOURG

+33 06 01 82 24 04

gatien.sancho@qwenty.fr