Comment installer et configurer Laravel avec Docker Compose sur Ubuntu 20.04

Introduction

Conteneuriser une application fait référence au processus d’adaptation d’une application et de ses composants afin de pouvoir l’exécuter dans des environnements légers appelés conteneurs. Ces environnements sont isolés et remplaçables et peuvent être exploités pour développer, tester et déployer des apps en production.

Dans ce guide, nous utiliserons Docker Compose pour conteneuriser une application Laravel pour le développement. Lorsque vous aurez terminé, vous aurez une application Laravel de démonstration fonctionnant sur trois conteneurs de service distincts :

• Un service app fonctionnant sous PHP7.4-FPM ;
• Un service db fonctionnant sous MySQL 5.7 ;
• Un service nginx qui utilise le service app pour analyser le code PHP avant de servir l’application Laravel à l’utilisateur final.

Pour permettre un processus de développement simplifié et faciliter le débogage des apps, nous maintiendrons la synchronisation des fichiers d’application en utilisant des volumes partagés. Nous verrons également comment utiliser les commandes docker-compose exec pour exécuter Composer et Artisan sur le conteneur de l’application.

Conditions préalables

• Accès à une machine locale Ubuntu 20.04 ou à un serveur de développement en tant que non-root user avec des privilèges sudo. Si vous utilisez un serveur distant, il est conseillé d’avoir un pare-feu actif installé. Pour les configurer, veuillez vous référer à notre Guide de configuration initiale du serveur pour Ubuntu 20.04.
• Docker a été installé sur votre serveur, en suivant les Étapes 1 et 2 de Comment installer et utiliser Docker sur Ubuntu 20.04.
• Docker Compose installé sur votre serveur, en suivant l’Étape 1 de Comment installer Docker Compose sur Ubuntu 20.04.

Étape 1 - Obtenez l’application de démonstration

Pour commencer, nous irons chercher l’application de démonstration Laravel dans son répertoire Github. Nous sommes intéressés par la branche tutorial-01, qui contient l’application Laravel de base que nous avons créée dans le premier guide de cette série.

Pour obtenir le code d’application compatible avec ce tutoriel, téléchargez la version tutorial-1.0.1 dans votre répertoire de base avec :

cd ~
curl -L https://github.com/do-community/travellist-laravel-demo/archive/tutorial-1.0.1.zip -o travellist.zip

Nous aurons besoin de la commande unzip pour décompresser le code d’application. Si vous n’avez pas encore installé ce package, faites-le maintenant avec :

sudo apt update
sudo apt install unzip

Maintenant, décompressez le contenu de l’application et renommez le répertoire décompressé pour un accès plus facile :

unzip travellist.zip
mv travellist-laravel-demo-tutorial-1.0.1 travellist-demo

Naviguez vers le répertoire travellist-demo :

cd travellist-demo

Au cours de la prochaine étape, nous allons créer un fichier de configuration .env pour configurer l’application.

Étape 2 - Configurez le fichier .env de l’application

Les fichiers de configuration Laravel sont situés dans un répertoire appelé config, dans le répertoire root de l’application. En outre, un fichier .env est utilisé pour configurer environment-dependent configuration, telles que les références et toute information pouvant varier d’un déploiement à l’autre. Ce fichier n’est pas inclus dans la gestion de versions.

Les valeurs contenues dans le fichier .env auront la priorité sur les valeurs fixées dans les fichiers de configuration habituels situés dans le répertoire config. Chaque installation sur un nouvel environnement nécessite un fichier d’environnement personnalisé pour définir des éléments tels que les paramètres de connexion à la base de données, les options de débogage, l’URL de l’application, entre autres, qui peuvent varier en fonction de l’environnement dans lequel l’application est exécutée.

Nous allons maintenant créer un nouveau fichier .env afin de personnaliser les options de configuration pour l’environnement de développement que nous configurons. Laravel contient un exemple de fichier .env que nous pouvons copier pour créer le nôtre :

cp .env.example .env

Ouvrez ce fichier en utilisant nano ou votre éditeur de texte préféré :

nano .env

Le fichier .env provenant de l’application de démonstration travellist contient des paramètres pour utiliser une base de données MySQL locale, avec 127.0.0.1 comme hôte de base de données. Nous devons mettre à jour la variable DB_HOST afin qu’il pointe vers le service de base de données que nous allons créer dans notre environnement Docker. Dans ce guide, nous appellerons notre service de base de données db. Commencez et remplacez la valeur listée de DB_HOST par le nom du service de base de données :

APP_NAME=Travellist
APP_ENV=dev
APP_KEY=
APP_DEBUG=true
APP_URL=http://localhost:8000

LOG_CHANNEL=stack

DB_CONNECTION=mysql
DB_HOST=db
DB_PORT=3306
DB_DATABASE=travellist
DB_USERNAME=travellist_user
DB_PASSWORD=password
...

N’hésitez pas à modifier également le nom de la base de données, le nom d’utilisateur et le mot de passe, si vous le souhaitez. Ces variables seront exploitées lors d’une étape ultérieure où nous mettrons en place le fichier docker-compose.yml pour configurer nos services.

Enregistrez le fichier lorsque vous avez fini de le modifier. Si vous avez utilisé nano, vous pouvez le faire en appuyant sur CTRL+X, puis Y et ENTER pour confirmer.

Étape 3 - Configurez le Dockerfile de l’application

Bien que nos services MySQL et Nginx seront basés sur des images par défaut obtenues à partir de Docker Hub, nous devons encore construire une image personnalisée pour le conteneur de l’application. Bien que nos services MySQL et Nginx soient basés sur des images par défaut obtenues à partir de Docker Hub, nous devons malgré tout construire une image personnalisée pour le conteneur de l’application.

Notre image travellist sera basée sur l’image PHP officielle php:7.4-fpm de Docker Hub. En plus de cet environnement PHP-FPM de base, nous allons installer quelques modules PHP supplémentaires et l’outil de gestion des dépendances Composer.

Nous allons également créer un nouvel utilisateur système ; c’est nécessaire pour exécuter les commandes artisan et composer lors du développement de l’application. Le paramètre uid garantit que l’utilisateur à l’intérieur du conteneur a le même uid que l’utilisateur de votre système sur votre machine hôte, où vous exécutez Docker. Ainsi, tous les fichiers créés par ces commandes sont répliqués dans l’hôte avec les bonnes permissions. Cela signifie également que vous pourrez utiliser l’éditeur de code de votre choix dans la machine hôte pour développer l’application qui s’exécute dans les conteneurs.

Créez un nouveau Dockerfile avec :

nano Dockerfile

Copiez le contenu suivant dans votre Dockerfile :

FROM php:7.4-fpm

# Arguments defined in docker-compose.yml
ARG user
ARG uid

# Install system dependencies
RUN apt-get update && apt-get install -y \
    git \
    curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    zip \
    unzip

# Clear cache
RUN apt-get clean && rm -rf /var/lib/apt/lists/*

# Install PHP extensions
RUN docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd

# Get latest Composer
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

# Create system user to run Composer and Artisan Commands
RUN useradd -G www-data,root -u $uid -d /home/$user $user
RUN mkdir -p /home/$user/.composer && \
    chown -R $user:$user /home/$user

# Set working directory
WORKDIR /var/www

USER $user

N’oubliez pas d’enregistrer le fichier lorsque vous avez terminé.

Notre Dockerfile commence par définir l’image de base que nous utilisons : php:7.4-fpm.

Après avoir installé les packages système et les extensions PHP, nous installons Composer en copiant le fichier exécutable composer depuis sa dernière image officielle vers notre propre image d’application.

Un nouvel utilisateur système est alors créé et configuré en utilisant les arguments user et uid qui ont été déclarés au début du Dockerfile. Ces valeurs seront injectées par Docker Compose au moment de la construction.

Enfin, nous avons défini le répertoire de travail par défaut comme /var/www et changé pour l’utilisateur nouvellement créé. Cela vous permettra de vous connecter comme un utilisateur régulier et de vous assurer que vous êtes dans le bon répertoire lorsque vous exécutez les commandes composer et artisan sur le conteneur de l’application.

Étape 4 - Implémentez la configuration Nginx et les fichiers Dump de la base de données

Lors de la création d’environnements de développement avec Docker Compose, il est souvent nécessaire de partager des fichiers de configuration ou d’initialisation avec des conteneurs de services, afin de mettre en place ou de démarrer ces services. Cette pratique facilite la modification des fichiers de configuration pour affiner votre environnement pendant que vous développez l’application.

Nous allons maintenant créer un dossier avec des fichiers qui serviront à configurer et à initialiser nos conteneurs de services.

Pour configurer Nginx, nous allons partager un fichier travellist.conf qui configurera la façon dont l’application est servie. Créez le dossier docker-compose/nginx avec :

mkdir -p docker-compose/nginx

Ouvrez un nouveau fichier appelé travellist.conf dans ce répertoire :

nano docker-compose/nginx/travellist.conf

Copiez la configuration Nginx suivante dans ce fichier :

server {
    listen 80;
    index index.php index.html;
    error_log  /var/log/nginx/error.log;
    access_log /var/log/nginx/access.log;
    root /var/www/public;
    location ~ \.php$ {
        try_files $uri =404;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass app:9000;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $fastcgi_path_info;
    }
    location / {
        try_files $uri $uri/ /index.php?$query_string;
        gzip_static on;
    }
}

Ce fichier configurera Nginx pour écouter sur le port 80 et utilisera index.php comme page d’index par défaut. Il définira le document root comme /var/www/public, et configurera ensuite Nginx pour utiliser le service de l’application sur le port 9000 pour traiter les fichiers *.php.

Enregistrez et fermez le fichier lorsque vous avez fini de le modifier.

Pour mettre en place la base de données MySQL, nous allons partager un dump de base de données qui sera importé lors de l’initialisation du conteneur. C’est une fonctionnalité fournie par l’image MySQL 5.7 que nous utiliserons sur ce conteneur.

Créez un nouveau dossier pour vos fichiers d’initialisation MySQL dans le dossier docker-compose :

mkdir docker-compose/mysql

Ouvrez un nouveau fichier .sql :

nano docker-compose/mysql/init_db.sql

La sauvegarde Dump MySQL suivante est basée sur la base de données que nous avons mise en place dans notre guide Laravel sur LEMP. Elle créera un nouveau tableau appelé places. Ensuite, elle remplira le tableau avec un ensemble de lieux d’échantillonnage.

Ajoutez le code suivant au fichier :

DROP TABLE IF EXISTS `places`;

CREATE TABLE `places` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(255) COLLATE utf8mb4_unicode_ci NOT NULL,
  `visited` tinyint(1) NOT NULL DEFAULT '0',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=12 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

INSERT INTO `places` (name, visited) VALUES ('Berlin',0),('Budapest',0),('Cincinnati',1),('Denver',0),('Helsinki',0),('Lisbon',0),('Moscow',1),('Nairobi',0),('Oslo',1),('Rio',0),('Tokyo',0);

La table places contient trois champs : id, name, et visited. Le champ visited est un drapeau utilisé pour identifier les lieux qui doivent encore être visités. N’hésitez pas à modifier les échantillons de lieux ou à en inclure de nouveaux. Enregistrez et fermez le fichier lorsque vous avez fini de le modifier.

Nous avons fini de mettre en place le Dockerfile de l’application et les fichiers de configuration du service. Ensuite, nous allons mettre en place Docker Compose pour utiliser ces fichiers lors de la création de nos services.

Étape 5 - Créez un environnement multi-conteneurs avec Docker Compose

Docker Compose permet de créer des environnements multi-conteneurs pour les apps s’exécutant sur Docker. Il utilise les définitions de services pour construire des environnements entièrement personnalisables avec plusieurs conteneurs qui peuvent échanger des réseaux et des volumes de données. Cela permet une intégration harmonieuse entre les composants de l’application.

Pour configurer nos définitions de service, nous créerons un nouveau fichier appelé docker-compose.yml. Généralement, ce fichier est situé à la racine du dossier d’application et définit votre environnement conteneurisé, y compris les images de base que vous utiliserez pour construire vos conteneurs et la manière dont vos services interagiront.

Nous définirons trois services différents dans notre fichiers docker-compose.yml : application, db et nginx.

Le service application construira une image appelée travellist basée sur le Dockerfile que nous avons précédemment créé. Le conteneur défini par ce service exécutera un serveur php-fpm pour analyser le code PHP et renvoyer les résultats au service nginx, qui fonctionnera sur un conteneur séparé. Le service mysql définit un conteneur exécutant un serveur MySQL 5.7. Nos services partageront un pont de réseau appelé travellist.

Les fichiers de l'application seront synchronisés à la fois sur l’application et sur le service nginx via bind mounts. Les bind mounts sont utiles dans les environnements de développement car ils permettent une synchronisation bidirectionnelle performante entre la machine hôte et les conteneurs.

Créez un nouveau fichier docker-compose.yml à la racine du dossier de l’application :

nano docker-compose.yml

Un fichier docker-compose.yml classique débute par une définition de la version, suivie par un noeud de services qui définit l’ensemble des services. Les réseaux partagés sont généralement définis au bas de ce fichier.

Pour commencer, copiez ce code standard dans votre fichier docker-compose.yml :

version: "3.7"
services:


networks:
  travellist:
    driver: bridge

Nous allons maintenant modifier le nœud de services pour inclure les services application, db et nginx.

Le service application

Le service application configurera un conteneur nommé travellist-application. Il construira une nouvelle image Docker basée sur un Dockerfile situé sur le même itinéraire que le fichier docker-compose.yml. La nouvelles image sera enregistrée localement sous le nom de travellist.

Même si la racine du document qui sert d’application est située dans le conteneur nginx, nous avons également besoin des fichiers de l’application quelque part dans le conteneur application afin d’exécuter des tâches en ligne de commande avec l’outil Laravel Artisan.

Copiez la définition de service suivante sous votre noeud de services, à l’intérieur du fichier docker-compose.yml :

  app:
    build:
      args:
        user: sammy
        uid: 1000
      context: ./
      dockerfile: Dockerfile
    image: travellist
    container_name: travellist-app
    restart: unless-stopped
    working_dir: /var/www/
    volumes:
      - ./:/var/www
    networks:
      - travellist

Ces paramètres sont les suivants :

• build : cette configuration indique à Docker Compose de construire une image locale pour le service application, en utilisant le chemin spécifié (contexte) et Dockerfile pour les instructions. Les arguments user et uid sont injectés dans le Dockerfile pour personnaliser les commandes de création utilisateurs lors de la construction.
• image : le nom qui sera utilisé pour l’image en cours de construction.
• container_name : définit le nom du conteneur pour ce service.
• restart :indique qu’il faut toujours redémarrer, sauf si le service est arrêté.
• working_dir : définit le répertoire par défaut pour ce service comme /var/www.
• volumes : crée un volume partagé qui synchronisera le contenu du répertoire actuel avec /var/www dans le conteneur. Notez qu’il ne s’agit pas de la racine de votre document, puisqu’elle se trouve dans le conteneur nginx.
• networks : configure ce service pour utiliser un réseau nommé travellist.

Le service db

Le service db utilise une image MySQL 5.7 préalablement construite depuis Docker Hub. Étant donné que Docker Compose charge automatiquement les fichiers variables .env situés dans le même répertoire que le fichier docker-compose.yml, nous pouvons obtenir nos paramètres de base de données depuis le fichier Laravel .env que nous avons créé dans une étape précédente.

Incluez la définition de service suivante dans votre noeud de services, juste après le service application :

  db:
    image: mysql:5.7
    container_name: travellist-db
    restart: unless-stopped
    environment:
      MYSQL_DATABASE: ${DB_DATABASE}
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
      MYSQL_PASSWORD: ${DB_PASSWORD}
      MYSQL_USER: ${DB_USERNAME}
      SERVICE_TAGS: dev
      SERVICE_NAME: mysql
    volumes:
      - ./docker-compose/mysql:/docker-entrypoint-initdb.d
    networks:
      - travellist

Ces paramètres sont les suivants :

• image : définit l’image Docker qui doit être utilisée pour ce conteneur. Dans ce cas, nous utilisons l’image MySQL 5.7 de Docker Hub.
• container_name : définit le nom du conteneur pour ce service : travellist-db.
• restart : indique qu’il faut toujours redémarrer ce service, sauf s’il est explicitement arrêté.
• environment : définit les variables d’environnement dans le nouveau conteneur. Nous utilisons des valeurs obtenues par le fichier Laravel .env pour configurer notre service MySQL, qui créera automatiquement une nouvelle base de données et un nouvel utilisateur en fonction des variables d’environnement fournies.
• volumes : crée un volume pour partager un dump de base de données .sql qui sera utilisé pour initialiser la base de données de l’application. L’image MySQL importera automatiquement les fichiers .sql placés dans le répertoire /docker-entrypoint-initdb.d dans le conteneur.
• networks : configure ce service pour utiliser un réseau nommé travellist.

Le service nginx

Le service nginx utilise une image Nginx pré-construite sur Alpine, une distribution Linux légère. Il crée un conteneur nommé travellist-nginx et utilise la définition des ports pour créer une redirection depuis le port 8000 sur le système hôte jusqu’au port 80 dans le conteneur.

Incluez la définition de service suivante dans votre noeud de services, juste après le service db :

  nginx:
    image: nginx:1.17-alpine
    container_name: travellist-nginx
    restart: unless-stopped
    ports:
      - 8000:80
    volumes:
      - ./:/var/www
      - ./docker-compose/nginx:/etc/nginx/conf.d
    networks:
      - travellist

Ces paramètres sont les suivants :

• image : définit l’image Docker qui doit être utilisée pour ce conteneur. Dans ce cas, nous utilisons l’image Alpine Nginx 1.17.
• container_name : définit le nom du conteneur pour ce service : travellist-nginx.
• restart : indique qu’il faut toujours redémarrer ce service, sauf s’il est explicitement arrêté.
• ports : configure une redirection des ports qui permettra un accès externe via le port 8000 au serveur web fonctionnant sur le port 80 dans le conteneur.
• volumes : crée deux volumes partagés. Le premier synchronisera le contenu du répertoire actuel avec /var/www à l’intérieur du conteneur. Ainsi, lorsque vous apportez des modifications locales aux fichiers d’application, elles seront rapidement répercutées dans la demande servie par Nginx à l’intérieur du conteneur. Le deuxième volume s’assurera que notre fichier de configuration Nginx, situé à l'adresse docker-compose/nginx/travellist.conf, est copié dans le dossier de configuration Nginx du conteneur.
• networks : configure ce service pour utiliser un réseau nommé travellist.

Fichier docker-compose.yml terminé

Notre fichier docker-compose.yml terminé ressemble à ça :

version: "3.7"
services:
  app:
    build:
      args:
        user: sammy
        uid: 1000
      context: ./
      dockerfile: Dockerfile
    image: travellist
    container_name: travellist-app
    restart: unless-stopped
    working_dir: /var/www/
    volumes:
      - ./:/var/www
    networks:
      - travellist

  db:
    image: mysql:5.7
    container_name: travellist-db
    restart: unless-stopped
    environment:
      MYSQL_DATABASE: ${DB_DATABASE}
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
      MYSQL_PASSWORD: ${DB_PASSWORD}
      MYSQL_USER: ${DB_USERNAME}
      SERVICE_TAGS: dev
      SERVICE_NAME: mysql
    volumes:
      - ./docker-compose/mysql:/docker-entrypoint-initdb.d
    networks:
      - travellist

  nginx:
    image: nginx:alpine
    container_name: travellist-nginx
    restart: unless-stopped
    ports:
      - 8000:80
    volumes:
      - ./:/var/www
      - ./docker-compose/nginx:/etc/nginx/conf.d/
    networks:
      - travellist

networks:
  travellist:
    driver: bridge

Assurez-vous d’enregistrer le fichier lorsque vous avez terminé.

Étape 6 - Exécutez l’application avec Docker Compose

Nous allons maintenant utiliser les commandes docker-compose pour construire l’image de l’application et exécuter les services que nous avons spécifiés dans notre configuration.

Construisez l’image de l'application avec la commande suivante :

docker-compose build app

Cette commande peut prendre quelques minutes. Vous verrez une sortie similaire à celle-ci :

Output
Building app
Step 1/11 : FROM php:7.4-fpm
 ---> fa37bd6db22a
Step 2/11 : ARG user
 ---> Running in f71eb33b7459
Removing intermediate container f71eb33b7459
 ---> 533c30216f34
Step 3/11 : ARG uid
 ---> Running in 60d2d2a84cda
Removing intermediate container 60d2d2a84cda
 ---> 497fbf904605
Step 4/11 : RUN apt-get update && apt-get install -y     git     curl     libpng-dev     libonig-dev     ...
Step 7/11 : COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
 ---> e499f74896e3
Step 8/11 : RUN useradd -G www-data,root -u $uid -d /home/$user $user
 ---> Running in 232ef9c7dbd1
Removing intermediate container 232ef9c7dbd1
 ---> 870fa3220ffa
Step 9/11 : RUN mkdir -p /home/$user/.composer &&     chown -R $user:$user /home/$user
 ---> Running in 7ca8c0cb7f09
Removing intermediate container 7ca8c0cb7f09
 ---> 3d2ef9519a8e
Step 10/11 : WORKDIR /var/www
 ---> Running in 4a964f91edfa
Removing intermediate container 4a964f91edfa
 ---> 00ada639da21
Step 11/11 : USER $user
 ---> Running in 9f8e874fede9
Removing intermediate container 9f8e874fede9
 ---> fe176ff4702b

Successfully built fe176ff4702b
Successfully tagged travellist:latest

Lorsque la construction est terminée, vous pouvez exécuter l’environnement en mode arrière-plan avec :

docker-compose up -d

Output
Creating travellist-db    ... done
Creating travellist-app   ... done
Creating travellist-nginx ... done

Cela fera tourner vos conteneurs en arrière-plan. Pour afficher des informations sur l’état de vos services actifs, exécutez :

docker-compose ps

Vous verrez une sortie de ce type :

Output
      Name                    Command               State          Ports
--------------------------------------------------------------------------------
travellist-app     docker-php-entrypoint php-fpm    Up      9000/tcp
travellist-db      docker-entrypoint.sh mysqld      Up      3306/tcp, 33060/tcp
travellist-nginx   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:8000->80/tcp

Votre environnement est maintenant opérationnel, mais nous devons encore exécuter quelques commandes pour terminer la configuration de l’application. Vous pouvez utiliser la commande docker-compose exec pour exécuter les commandes dans les conteneurs de services, tels qu’un ls -l pour afficher les informations détaillées sur les fichiers dans le répertoire de l’application :

docker-compose exec app ls -l

Output
total 260
-rw-rw-r--  1 sammy sammy    737 Jun  9 11:19 Dockerfile
-rw-rw-r--  1 sammy sammy    101 Jan  7 08:05 README.md
drwxrwxr-x  6 sammy sammy   4096 Jan  7 08:05 app
-rwxr-xr-x  1 sammy sammy   1686 Jan  7 08:05 artisan
drwxrwxr-x  3 sammy sammy   4096 Jan  7 08:05 bootstrap
-rw-rw-r--  1 sammy sammy   1501 Jan  7 08:05 composer.json
-rw-rw-r--  1 sammy sammy 179071 Jan  7 08:05 composer.lock
drwxrwxr-x  2 sammy sammy   4096 Jan  7 08:05 config
drwxrwxr-x  5 sammy sammy   4096 Jan  7 08:05 database
drwxrwxr-x  4 sammy sammy   4096 Jun  9 11:19 docker-compose
-rw-rw-r--  1 sammy sammy    965 Jun  9 11:27 docker-compose.yml
-rw-rw-r--  1 sammy sammy   1013 Jan  7 08:05 package.json
-rw-rw-r--  1 sammy sammy   1405 Jan  7 08:05 phpunit.xml
drwxrwxr-x  2 sammy sammy   4096 Jan  7 08:05 public
-rw-rw-r--  1 sammy sammy    273 Jan  7 08:05 readme.md
drwxrwxr-x  6 sammy sammy   4096 Jan  7 08:05 resources
drwxrwxr-x  2 sammy sammy   4096 Jan  7 08:05 routes
-rw-rw-r--  1 sammy sammy    563 Jan  7 08:05 server.php
drwxrwxr-x  5 sammy sammy   4096 Jan  7 08:05 storage
drwxrwxr-x  4 sammy sammy   4096 Jan  7 08:05 tests
drwxrwxr-x 41 sammy sammy   4096 Jun  9 11:32 vendor
-rw-rw-r--  1 sammy sammy    538 Jan  7 08:05 webpack.mix.js

Nous allons maintenant exécuter composer install pour installer les dépendances de l’application :

docker-compose exec app composer install

Vous verrez une sortie de ce type :

Output
Loading composer repositories with package information
Installing dependencies (including require-dev) from lock file
Package operations: 85 installs, 0 updates, 0 removals
  - Installing doctrine/inflector (1.3.1): Downloading (100%)
  - Installing doctrine/lexer (1.2.0): Downloading (100%)
  - Installing dragonmantank/cron-expression (v2.3.0): Downloading (100%)
  - Installing erusev/parsedown (1.7.4): Downloading (100%)
  - Installing symfony/polyfill-ctype (v1.13.1): Downloading (100%)
  - Installing phpoption/phpoption (1.7.2): Downloading (100%)
  - Installing vlucas/phpdotenv (v3.6.0): Downloading (100%)
  - Installing symfony/css-selector (v5.0.2): Downloading (100%)
…
Generating optimized autoload files
> Illuminate\Foundation\ComposerScripts::postAutoloadDump
> @php artisan package:discover --ansi
Discovered Package: facade/ignition
Discovered Package: fideloper/proxy
Discovered Package: laravel/tinker
Discovered Package: nesbot/carbon
Discovered Package: nunomaduro/collision
Package manifest generated successfully.

La dernière chose que nous devons faire avant de tester l’application est de générer une clé d’application unique avec l’outil de ligne de commande Laravel, artisan. Cette clé est utilisée pour chiffrer les sessions des utilisateurs et d’autres données sensibles :

docker-compose exec app php artisan key:generate

Output
Application key set successfully.

Ouvrez maintenant votre navigateur et accédez au nom de domaine ou à l’adresse IP de votre serveur sur le port 8000 :

http://server_domain_or_IP:8000

Vous verrez une page comme celle-ci :

Vous pouvez utiliser la commande logs pour consultez les journaux générés par vos services :

docker-compose logs nginx

Attaching to travellist-nginx
…
travellist-nginx | /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
travellist-nginx | /docker-entrypoint.sh: Configuration complete; ready for start up
travellist-nginx | 192.168.0.1 - - [09/Jun/2020:11:46:34 +0000] "GET / HTTP/1.1" 200 627 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36"
travellist-nginx | 192.168.0.1 - - [09/Jun/2020:11:46:35 +0000] "GET / HTTP/1.1" 200 627 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36"

Si vous voulez mettre en pause votre environnement Docker Compose tout en conservant l’état de tous ses services, exécutez :

docker-compose pause

Output
Pausing travellist-db    ... done
Pausing travellist-nginx ... done
Pausing travellist-app   ... done

Vous pouvez alors reprendre vos services avec :

docker-compose unpause

Output
Unpausing travellist-app   ... done
Unpausing travellist-nginx ... done
Unpausing travellist-db    ... done

Pour fermer votre environnement Docker Compose et retirer tous ses conteneurs, réseaux et volumes, exécutez :

docker-compose down

Output
Stopping travellist-nginx ... done
Stopping travellist-db    ... done
Stopping travellist-app   ... done
Removing travellist-nginx ... done
Removing travellist-db    ... done
Removing travellist-app   ... done
Removing network travellist-laravel-demo_travellist

Pour un aperçu de toutes les commandes Docker Compose, veuillez consulter la référence de la ligne de commande Docker Compose.

Conclusion

Dans ce guide, nous avons mis en place un environnement Docker avec trois conteneurs en utilisant Docker Compose pour définir notre infrastructure dans un fichier YAML.

À partir de ce moment, vous pouvez travailler sur votre application Laravel sans avoir besoin d’installer et de configurer un serveur web local pour le développement et les tests. De plus, vous travaillerez avec un environnement jetable qui peut être facilement reproduit et distribué, ce qui peut être utile lors du développement de votre application et aussi lors de la transition vers un environnement de production.