One place for hosting & domains

      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

      É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 :

      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.

      Attention : le fichier de configuration de l’environnement contient des informations sensibles sur votre serveur, notamment les informations d’identification de la base de données et les clés de sécurité. Par conséquent, ne partagez jamais ce fichier en public.

      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 :

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

      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 :

      .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 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 :

      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 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 :

      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 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 :

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

      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 :

      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 :

      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 :

      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 :

      docker-compose.yml

        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 :

      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 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 :

      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: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 :

      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 :

      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 :

      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 > IlluminateFoundationComposerScripts::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
      

      Note : Si vous exécutez cette démo sur votre machine locale, utilisez http://localhost:8000 pour accéder à l’application à partir de votre navigateur.

      Vous verrez une page comme celle-ci :

      application de démonstration Laravel

      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 :

      Output

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

      Vous pouvez alors reprendre vos services avec :

      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 :

      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.



      Source link