Comment installer et configurer Laravel avec Docker Compose sur Ubuntu 22.04

Introduction

Pour 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 jetables, et peuvent être exploités pour développer, tester et déployer des applications en production.

Dans ce guide, nous utiliserons Docker Compose pour conteneuriser une application Laravel pour le développement. Lorsque vous aurez terminé, vous disposerez d'une application Laravel de démonstration exécutée sur trois conteneurs de services distincts :

• Une app service exécutant PHP7.4-FPM ;
• Une db service exécutant MySQL 5.7 ;
• Un nginx service qui utilise l'app service pour analyser le code PHP avant de servir l'application Laravel à l'utilisateur final.

Pour permettre un processus de développement rationalisé et faciliter le débogage des applications, nous synchroniserons les fichiers d'application en utilisant des volumes partagés. Nous verrons également comment utiliser docker-compose exec commandes pour exécuter Composer et Artisan sur l'app conteneur.

Prérequis

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

Étape 1 - Obtention de l'application de démonstration

Pour commencer, nous allons récupérer l'application de démonstration Laravel à partir de son référentiel Github. Nous sommes intéressés par le tutorial-01 branche, 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 à votre répertoire personnel avec :

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

Nous aurons besoin du unzip commande pour décompresser le code de l'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

Accédez à la travellist-demo répertoire :

cd travellist-demo

Dans l'étape suivante, nous allons créer un .env fichier de configuration pour configurer l'application.

Étape 2 - Configuration du .env de l'application Fichier

Les fichiers de configuration Laravel sont situés dans un répertoire appelé config , dans le répertoire racine de l'application. De plus, un .env Le fichier est utilisé pour définir une configuration dépendante de l'environnement, telle que les informations d'identification et toute information susceptible de varier entre les déploiements. Ce fichier n'est pas inclus dans le contrôle de révision.

Avertissement :Le fichier de configuration de l'environnement contient des informations sensibles sur votre serveur, y compris les informations d'identification de la base de données et les clés de sécurité. Pour cette raison, vous ne devez jamais partager ce fichier publiquement.

Les valeurs contenues dans le .env aura priorité sur les valeurs définies dans les fichiers de configuration réguliers situés dans config annuaire. 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 éléments qui peuvent varier en fonction de l'environnement dans lequel l'application s'exécute.

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

cp .env.example .env

Ouvrez ce fichier en utilisant nano ou l'éditeur de texte de votre choix :

nano .env

Le .env actuel fichier de la travellist l'application de démonstration contient des paramètres pour utiliser une base de données MySQL locale, avec 127.0.0.1 en tant qu'hébergeur de la base de données. Nous devons mettre à jour le DB_HOST variable afin qu'elle 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 . Allez-y et remplacez la valeur indiquée de DB_HOST avec le nom du service de base de données :

.env

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 dans une étape ultérieure où nous configurerons le docker-compose.yml fichier pour configurer nos services.

Enregistrez le fichier lorsque vous avez terminé l'édition. Si vous avez utilisé nano , vous pouvez le faire en appuyant sur Ctrl+x , puis Y et Enter pour confirmer.

Étape 3 - Configuration du Dockerfile de l'application

Bien que nos services MySQL et Nginx soient basés sur des images par défaut obtenues à partir du Docker Hub, nous devons toujours créer une image personnalisée pour le conteneur d'application. Nous allons créer un nouveau Dockerfile pour cela.

Notre liste de voyage l'image sera basée sur le php:7.4-fpm image PHP officielle 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 ; ceci est nécessaire pour exécuter artisan et composer commandes lors du développement de l'application. Le uid garantit que l'utilisateur à l'intérieur du conteneur a le même uid que votre utilisateur système sur votre machine hôte, sur laquelle vous exécutez Docker. De cette façon, tous les fichiers créés par ces commandes sont répliqués sur l'hôte avec les autorisations appropriées. Cela signifie également que vous pourrez utiliser l'éditeur de code de votre choix sur 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 :

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 composer exécutable de sa dernière image officielle à notre propre image d'application.

Un nouvel utilisateur système est alors créé et configuré à l'aide du user et uid arguments 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 définissons le répertoire de travail par défaut comme /var/www et passez à l'utilisateur nouvellement créé. Cela garantira que vous vous connectez en tant qu'utilisateur régulier et que vous êtes dans le bon répertoire lors de l'exécution de composer et artisan commandes sur le conteneur d'application.

Étape 4 - Configuration de la configuration Nginx et des fichiers de vidage de 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 configurer ou d'amorcer 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 configurer un dossier avec des fichiers qui seront utilisés pour configurer et initialiser nos conteneurs de services.

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

mkdir -p docker-compose/nginx

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

nano docker-compose/nginx/travellist.conf

Copiez la configuration Nginx suivante dans ce fichier :

docker-compose/nginx/travellist.conf

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 utilisez index.php comme page d'index par défaut. Il définira la racine du document sur /var/www/public , puis configurez Nginx pour utiliser l'app service sur le port 9000 pour traiter *.php fichiers.

Enregistrez et fermez le fichier lorsque vous avez terminé l'édition.

Pour configurer la base de données MySQL, nous partagerons un vidage de base de données qui sera importé lors de l'initialisation du conteneur. Il s'agit d'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 docker-compose dossier :

mkdir docker-compose/mysql

Ouvrir un nouveau .sql fichier :

nano docker-compose/mysql/init_db.sql

Le vidage MySQL suivant est basé sur la base de données que nous avons configurée dans notre guide Laravel sur LEMP. Cela créera une nouvelle table nommée places . Ensuite, il remplira le tableau avec un ensemble d'exemples de lieux.

Ajoutez le code suivant au fichier :

docker-compose/mysql/db_init.sql

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);

Les places table contient trois champs :id , name , et visited . Le visited le champ est un drapeau utilisé pour identifier les endroits qui sont encore à visiter . N'hésitez pas à modifier les exemples de lieux ou à en inclure de nouveaux. Enregistrez et fermez le fichier lorsque vous avez terminé.

Nous avons terminé la configuration du Dockerfile de l'application et des fichiers de configuration du service. Ensuite, nous allons configurer Docker Compose pour utiliser ces fichiers lors de la création de nos services.

Étape 5 - Création d'un environnement multi-conteneurs avec Docker Compose

Docker Compose vous permet de créer des environnements multi-conteneurs pour les applications exécutées sur Docker. Il utilise des définitions de service pour créer des environnements entièrement personnalisables avec plusieurs conteneurs pouvant partager des réseaux et des volumes de données. Cela permet une intégration transparente entre les composants de l'application.

Pour configurer nos définitions de service, nous allons créer un nouveau fichier appelé docker-compose.yml . En règle générale, ce fichier se trouve à la racine du dossier de l'application et définit votre environnement conteneurisé, y compris les images de base que vous utiliserez pour créer vos conteneurs et la manière dont vos services interagiront.

Nous allons définir trois services différents dans notre docker-compose.yml fichier :app , db , et nginx .

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

Les fichiers de l'application seront synchronisés à la fois sur l'app et le nginx services via montages liés . Les montages liés 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 docker-compose.yml fichier à la racine du dossier de l'application :

nano docker-compose.yml

Un docker-compose.yml typique le fichier commence par une définition de version, suivie d'un services nœud, sous lequel tous les services sont définis. Les réseaux partagés sont généralement définis au bas de ce fichier.

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

docker-compose.yml

version: "3.7"
services:


networks:
  travellist:
    driver: bridge

Nous allons maintenant modifier les services node pour inclure l'app , db et nginx services.

L'app Services

L'app le service configurera un conteneur nommé travellist-app . Il construit une nouvelle image Docker basée sur un Dockerfile situé dans le même chemin que le docker-compose.yml dossier. La nouvelle image sera enregistrée localement sous le nom travellist .

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

Copiez la définition de service suivante sous vos services nœud, à l'intérieur du docker-compose.yml fichier :

application 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 effectuent les opérations suivantes :

• build  :Cette configuration indique à Docker Compose de créer une image locale pour l'app service, 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 d'utilisateurs au moment 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  :Toujours redémarrer, sauf si le service est arrêté.
• working_dir  :Définit le répertoire par défaut pour ce service en tant que /var/www .
• volumes :Crée un volume partagé qui synchronisera le contenu du répertoire courant vers /var/www à l'intérieur du conteneur. Notez qu'il ne s'agit pas de la racine de votre document, car cela vivra dans le nginx conteneur.
• networks  :Configure ce service pour utiliser un réseau nommé travellist .

La db Services

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

Incluez la définition de service suivante dans vos services node, juste après le app service :

docker-compose.yml

  db:
    image: mysql:8.0
    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 effectuent les opérations suivantes :

• image :définit l'image Docker qui doit être utilisée pour ce conteneur. Dans ce cas, nous utilisons une image MySQL 5.7 de Docker Hub.
• container_name  :définit le nom du conteneur pour ce service :travellist-db .
• restart  :Redémarrez toujours ce service, à moins qu'il ne soit explicitement arrêté.
• environment :Définit les variables d'environnement dans le nouveau conteneur. Nous utilisons les valeurs obtenues à partir de Laravel .env fichier 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 .sql dump de la base de données qui sera utilisé pour initialiser la base de données de l'application. L'image MySQL importera automatiquement .sql fichiers placés dans le /docker-entrypoint-initdb.d répertoire à l'intérieur du conteneur.
• networks  :Configure ce service pour utiliser un réseau nommé travellist .

Le nginx Services

Le nginx Le service utilise une image Nginx pré-construite au-dessus d'Alpine, une distribution Linux légère. Il crée un conteneur nommé travellist-nginx , et il utilise les ports définition pour créer une redirection depuis le port 8000 sur le système hôte au port 80 à l'intérieur du conteneur.

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

docker-compose.yml

  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 effectuent les opérations suivantes :

• 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  :configure le nom du conteneur pour ce service :travellist-nginx .
• restart  :Redémarrez toujours ce service, à moins qu'il ne soit explicitement arrêté.
• ports :Met en place une redirection de port qui permettra un accès externe via le port 8000 au serveur Web exécuté sur le port 80 à l'intérieur du conteneur.
• volumes  :Crée deux volumes partagés. Le premier synchronisera le contenu du répertoire courant vers /var/www à l'intérieur du conteneur. De cette façon, lorsque vous apportez des modifications locales aux fichiers d'application, elles seront rapidement reflétées dans l'application servie par Nginx à l'intérieur du conteneur. Le deuxième volume s'assurera que notre fichier de configuration Nginx, situé à 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 Fichier

C'est ainsi que notre docker-compose.yml fini le fichier ressemble à :

docker-compose.yml

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:8.0
    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écution de l'application avec Docker Compose

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

Créez l'app image avec la commande suivante :

docker-compose build app

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

OutputBuilding app
Sending build context to Docker daemon  377.3kB
Step 1/11 : FROM php:7.4-fpm
 ---> 8c08d993542f
Step 2/11 : ARG user
 ---> e3ce3af04d87
Step 3/11 : ARG uid
 ---> 30cb921ef7df
Step 4/11 : RUN apt-get update && apt-get install -y     git     curl     libpng-dev     libonig-dev     libxml2-dev     zip     unzip
. . .
 ---> b6dbc7a02e95
Step 5/11 : RUN apt-get clean && rm -rf /var/lib/apt/lists/*
 ---> 10ef9dde45ad
. . .
Step 6/11 : RUN docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd
. . .
 ---> 920e4f09ec75
Step 7/11 : COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
 ---> dbbcd44e44af
Step 8/11 : RUN useradd -G www-data,root -u $uid -d /home/$user $user
 ---> db98e899a69a
Step 9/11 : RUN mkdir -p /home/$user/.composer &&     chown -R $user:$user /home/$user
 ---> 5119e26ebfea
Step 10/11 : WORKDIR /var/www
 ---> 699c491611c0
Step 11/11 : USER $user
 ---> cf250fe8f1af
Successfully built cf250fe8f1af
Successfully tagged travellist:latest

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

docker-compose up -d

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

Cela exécutera 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 comme celle-ci :

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   nginx -g daemon off;            Up      0.0.0.0:8000->80/tcp,:::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 le docker-compose exec commande pour exécuter des commandes dans les conteneurs de services, comme un ls -l pour afficher des informations détaillées sur les fichiers dans le répertoire de l'application :

docker-compose exec app ls -l

Outputtotal 256
-rw-r--r-- 1 sammy sammy    737 Apr 18 14:21 Dockerfile
-rw-r--r-- 1 sammy sammy    101 Jan  7  2020 README.md
drwxr-xr-x 6 sammy sammy   4096 Jan  7  2020 app
-rwxr-xr-x 1 sammy sammy   1686 Jan  7  2020 artisan
drwxr-xr-x 3 sammy sammy   4096 Jan  7  2020 bootstrap
-rw-r--r-- 1 sammy sammy   1501 Jan  7  2020 composer.json
-rw-r--r-- 1 sammy sammy 179071 Jan  7  2020 composer.lock
drwxr-xr-x 2 sammy sammy   4096 Jan  7  2020 config
drwxr-xr-x 5 sammy sammy   4096 Jan  7  2020 database
drwxr-xr-x 4 sammy sammy   4096 Apr 18 14:22 docker-compose
-rw-r--r-- 1 sammy sammy   1017 Apr 18 14:29 docker-compose.yml
-rw-r--r-- 1 sammy sammy   1013 Jan  7  2020 package.json
-rw-r--r-- 1 sammy sammy   1405 Jan  7  2020 phpunit.xml
drwxr-xr-x 2 sammy sammy   4096 Jan  7  2020 public
-rw-r--r-- 1 sammy sammy    273 Jan  7  2020 readme.md
drwxr-xr-x 6 sammy sammy   4096 Jan  7  2020 resources
drwxr-xr-x 2 sammy sammy   4096 Jan  7  2020 routes
-rw-r--r-- 1 sammy sammy    563 Jan  7  2020 server.php
drwxr-xr-x 5 sammy sammy   4096 Jan  7  2020 storage
drwxr-xr-x 4 sammy sammy   4096 Jan  7  2020 tests
-rw-r--r-- 1 sammy sammy    538 Jan  7  2020 webpack.mix.js

Nous allons maintenant lancer l'composer install pour installer les dépendances de l'application :

docker-compose exec app rm -rf vendor composer.lock
docker-compose exec app composer install

Vous verrez une sortie comme celle-ci :

OutputNo composer.lock file present. Updating dependencies to latest instead of installing from lock file. See https://getcomposer.org/install for more information.
. . .
Lock file operations: 89 installs, 0 updates, 0 removals
  - Locking doctrine/inflector (2.0.4)
  - Locking doctrine/instantiator (1.4.1)
  - Locking doctrine/lexer (1.2.3)
  - Locking dragonmantank/cron-expression (v2.3.1)
  - Locking egulias/email-validator (2.1.25)
  - Locking facade/flare-client-php (1.9.1)
  - Locking facade/ignition (1.18.1)
  - Locking facade/ignition-contracts (1.0.2)
  - Locking fideloper/proxy (4.4.1)
  - Locking filp/whoops (2.14.5)
. . .
Writing lock file
Installing dependencies from lock file (including require-dev)
Package operations: 89 installs, 0 updates, 0 removals
  - Downloading doctrine/inflector (2.0.4)
  - Downloading doctrine/lexer (1.2.3)
  - Downloading dragonmantank/cron-expression (v2.3.1)
  - Downloading symfony/polyfill-php80 (v1.25.0)
  - Downloading symfony/polyfill-php72 (v1.25.0)
  - Downloading symfony/polyfill-mbstring (v1.25.0)
  - Downloading symfony/var-dumper (v4.4.39)
  - Downloading symfony/deprecation-contracts (v2.5.1)
. . .
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 le artisan Outil de ligne de commande Laravel. Cette clé est utilisée pour chiffrer les sessions utilisateur et d'autres données sensibles :

docker-compose exec app php artisan key:generate

OutputApplication key set successfully.

Allez maintenant dans 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

Remarque  :Si vous exécutez cette démo sur votre machine locale, utilisez http://localhost:8000 pour accéder à l'application depuis votre navigateur.

Vous verrez une page comme celle-ci :

Vous pouvez utiliser les logs commande pour vérifier les logs générés par vos services :

docker-compose logs nginx

Attaching to travellist-nginx
. . .
travellist-nginx | 172.24.9.1 - - [18/Apr/2022:14:49:16 +0000] "GET / HTTP/1.1" 200 627 "-" "curl/7.82.0"
travellist-nginx | 172.24.9.1 - - [18/Apr/2022:14:51:27 +0000] "GET / HTTP/1.1" 200 627 "-" "Mozilla/5.0 (X11; Linux x86_64; rv:89.0) Gecko/20100101 Firefox/89.0"
travellist-nginx | 172.24.9.1 - - [18/Apr/2022:14:51:27 +0000] "GET /favicon.ico HTTP/1.1" 200 0 "http://localhost:8000/" "Mozilla/5.0 (X11; Linux x86_64; rv:89.0) Gecko/20100101 Firefox/89.0"

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

docker-compose pause

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

Vous pourrez alors reprendre vos services avec :

docker-compose unpause

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

Pour arrêter votre environnement Docker Compose et supprimer tous ses conteneurs, réseaux et volumes, exécutez :

docker-compose down

OutputStopping 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

For an overview of all Docker Compose commands, please check the Docker Compose command-line reference.

Conclusion

In this guide, we’ve set up a Docker environment with three containers using Docker Compose to define our infrastructure in a YAML file.

From this point on, you can work on your Laravel application without needing to install and set up a local web server for development and testing. Moreover, you’ll be working with a disposable environment that can be easily replicated and distributed, which can be helpful while developing your application and also when moving towards a production environment.