Comment configurer Laravel, Nginx et MySQL avec Docker Compose

De Get Docs
Aller à :navigation, rechercher

L'auteur a sélectionné The FreeBSD Foundation pour recevoir un don dans le cadre du programme Write for DOnations.

Introduction

Au cours des dernières années, Docker est devenu une solution fréquemment utilisée pour déployer des applications grâce à la façon dont il simplifie l'exécution et le déploiement d'applications dans des conteneurs éphémères. Lors de l'utilisation d'une pile d'applications LEMP, par exemple, avec PHP, Nginx, MySQL et le framework Laravel, Docker peut considérablement rationaliser le processus de configuration.

Docker Compose a encore simplifié le processus de développement en permettant aux développeurs de définir leur infrastructure, y compris les services d'application, les réseaux et les volumes, dans un seul fichier. Docker Compose offre une alternative efficace à l'exécution de plusieurs commandes docker container create et docker container run.

Dans ce didacticiel, vous allez créer une application Web à l'aide du framework Laravel, avec Nginx comme serveur Web et MySQL comme base de données, le tout dans des conteneurs Docker. Vous définirez l'intégralité de la configuration de la pile dans un fichier docker-compose, ainsi que des fichiers de configuration pour PHP, MySQL et Nginx.

Conditions préalables

Avant de commencer, vous aurez besoin de :

Étape 1 - Téléchargement de Laravel et installation des dépendances

Dans un premier temps, nous allons obtenir la dernière version de Laravel et installer les dépendances du projet, y compris Composer, le gestionnaire de packages au niveau de l'application pour PHP. Nous allons installer ces dépendances avec Docker pour éviter d'avoir à installer Composer globalement.

Tout d'abord, vérifiez que vous êtes dans votre répertoire personnel et clonez la dernière version de Laravel dans un répertoire appelé laravel-app :

cd ~
git clone https://github.com/laravel/laravel.git laravel-app

Déplacez-vous dans le répertoire laravel-app :

cd ~/laravel-app

Ensuite, utilisez l'composer image de Docker pour monter les répertoires dont vous aurez besoin pour votre projet Laravel et éviter les frais généraux liés à l'installation globale de Composer :

docker run --rm -v $(pwd):/app composer install

L'utilisation des drapeaux -v et --rm avec docker run crée un conteneur éphémère qui sera monté en liaison sur votre répertoire actuel avant d'être supprimé. Cela copiera le contenu de votre répertoire ~/laravel-app dans le conteneur et garantira également que le dossier vendor créé par Composer dans le conteneur est copié dans votre répertoire actuel.

Enfin, définissez les autorisations sur le répertoire du projet afin qu'il appartienne à votre utilisateur non root :

sudo chown -R $USER:$USER ~/laravel-app

Cela sera important lorsque vous écrivez le Dockerfile pour votre image d'application à l'étape 4, car cela vous permettra de travailler avec votre code d'application et d'exécuter des processus dans votre conteneur en tant qu'utilisateur non root.

Une fois votre code d'application en place, vous pouvez passer à la définition de vos services avec Docker Compose.

Étape 2 - Création du fichier Docker Compose

La création de vos applications avec Docker Compose simplifie le processus de configuration et de gestion des versions de votre infrastructure. Pour configurer notre application Laravel, nous allons écrire un fichier docker-compose qui définit notre serveur Web, notre base de données et nos services d'application.

Ouvrez le fichier :

nano ~/laravel-app/docker-compose.yml

Dans le fichier docker-compose, vous définirez trois services : app, webserver et db. Ajoutez le code suivant au fichier, en veillant à remplacer le mot de passe root pour MYSQL_ROOT_PASSWORD, défini comme une variable d'environnement sous le service db, avec un mot de passe fort de votre choix :

~/laravel-app/docker-compose.yml

version: '3'
services:
  
  #PHP Service
  app:
    build:
      context: .
      dockerfile: Dockerfile
    image: digitalocean.com/php
    container_name: app
    restart: unless-stopped
    tty: true
    environment:
      SERVICE_NAME: app
      SERVICE_TAGS: dev
    working_dir: /var/www
    networks:
      - app-network

  #Nginx Service
  webserver:
    image: nginx:alpine
    container_name: webserver
    restart: unless-stopped
    tty: true
    ports:
      - "80:80"
      - "443:443"
    networks:
      - app-network

  #MySQL Service
  db:
    image: mysql:5.7.22
    container_name: db
    restart: unless-stopped
    tty: true
    ports:
      - "3306:3306"
    environment:
      MYSQL_DATABASE: laravel
      MYSQL_ROOT_PASSWORD: your_mysql_root_password
      SERVICE_TAGS: dev
      SERVICE_NAME: mysql
    networks:
      - app-network

#Docker Networks
networks:
  app-network:
    driver: bridge

Les services définis ici comprennent :

  • app : cette définition de service contient l'application Laravel et exécute une image Docker personnalisée, digitalocean.com/php, que vous définirez à l'étape 4. Il définit également le working_dir dans le conteneur sur /var/www.
  • webserver : cette définition de service extrait l'image nginx:alpine de Docker et expose les ports 80 et 443.
  • db : cette définition de service extrait l'image mysql:5.7.22 de Docker et définit quelques variables d'environnement, y compris une base de données appelée laravel pour votre application et le [X196X ]mot de passe root pour la base de données. Vous êtes libre de nommer la base de données comme vous le souhaitez et vous devez remplacer your_mysql_root_password par votre propre mot de passe fort. Cette définition de service mappe également le port 3306 sur l'hôte au port 3306 sur le conteneur.

Chaque propriété container_name définit un nom pour le conteneur, qui correspond au nom du service. Si vous ne définissez pas cette propriété, Docker attribuera un nom à chaque conteneur en combinant le nom d'une personne historiquement célèbre et un mot aléatoire séparé par un trait de soulignement.

Pour faciliter la communication entre les conteneurs, les services sont connectés à un réseau pont appelé app-network. Un réseau de pont utilise un pont logiciel qui permet aux conteneurs connectés au même réseau de pont de communiquer entre eux. Le pilote de pont installe automatiquement des règles sur la machine hôte afin que les conteneurs sur différents réseaux de pont ne puissent pas communiquer directement entre eux. Cela crée un niveau de sécurité plus élevé pour les applications, garantissant que seuls les services associés peuvent communiquer entre eux. Cela signifie également que vous pouvez définir plusieurs réseaux et services se connectant à des fonctions connexes : les services d'application frontaux peuvent utiliser un réseau frontend, par exemple, et les services principaux peuvent utiliser un réseau backend. .

Voyons comment ajouter des volumes et lier des montages à vos définitions de service pour conserver vos données d'application.

Étape 3 - Données persistantes

Docker dispose de fonctionnalités puissantes et pratiques pour la persistance des données. Dans notre application, nous utiliserons les volumes et bind mounts pour conserver la base de données, ainsi que les fichiers d'application et de configuration. Les volumes offrent une flexibilité pour les sauvegardes et une persistance au-delà du cycle de vie d'un conteneur, tandis que les montages liés facilitent les modifications de code pendant le développement, rendant les modifications apportées à vos fichiers ou répertoires hôtes immédiatement disponibles dans vos conteneurs. Notre configuration utilisera les deux.

Avertissement : En utilisant des montages liés, vous permettez de modifier le système de fichiers hôte via des processus s'exécutant dans un conteneur, y compris la création, la modification ou la suppression de fichiers ou de répertoires système importants. Il s'agit d'une capacité puissante avec des implications en matière de sécurité et qui pourrait avoir un impact sur les processus non Docker sur le système hôte. Utilisez les supports de liaison avec précaution.


Dans le fichier docker-compose, définissez un volume appelé dbdata sous la définition de service db pour conserver la base de données MySQL :

~/laravel-app/docker-compose.yml

...
#MySQL Service
db:
  ...
    volumes:
      - dbdata:/var/lib/mysql
    networks:
      - app-network
  ...

Le volume nommé dbdata conserve le contenu du dossier /var/lib/mysql présent à l'intérieur du conteneur. Cela vous permet d'arrêter et de redémarrer le service db sans perdre de données.

Au bas du fichier, ajoutez la définition du volume dbdata :

~/laravel-app/docker-compose.yml

...
#Volumes
volumes:
  dbdata:
    driver: local

Avec cette définition en place, vous pourrez utiliser ce volume sur tous les services.

Ensuite, ajoutez un montage lié au service db pour les fichiers de configuration MySQL que vous allez créer à l'étape 7 :

~/laravel-app/docker-compose.yml

...
#MySQL Service
db:
  ...
    volumes:
      - dbdata:/var/lib/mysql
      - ./mysql/my.cnf:/etc/mysql/my.cnf
  ...

Ce montage lié lie ~/laravel-app/mysql/my.cnf à /etc/mysql/my.cnf dans le conteneur.

Ensuite, ajoutez des montages de liaison au service webserver. Il y en aura deux : un pour votre code d'application et un autre pour la définition de configuration Nginx que vous créerez à l'étape 6 :

~/laravel-app/docker-compose.yml

#Nginx Service
webserver:
  ...
  volumes:
      - ./:/var/www
      - ./nginx/conf.d/:/etc/nginx/conf.d/
  networks:
      - app-network

Le premier montage lié lie le code d'application du répertoire ~/laravel-app au répertoire /var/www à l'intérieur du conteneur. Le fichier de configuration que vous ajouterez à ~/laravel-app/nginx/conf.d/ sera également monté sur /etc/nginx/conf.d/ dans le conteneur, vous permettant d'ajouter ou de modifier le contenu du répertoire de configuration selon vos besoins.

Enfin, ajoutez les montages liés suivants au service app pour le code d'application et les fichiers de configuration :

~/laravel-app/docker-compose.yml

#PHP Service
app:
  ...
  volumes:
       - ./:/var/www
       - ./php/local.ini:/usr/local/etc/php/conf.d/local.ini
  networks:
      - app-network

Le service app monte par liaison le dossier ~/laravel-app, qui contient le code d'application, dans le dossier /var/www dans le conteneur. Cela accélérera le processus de développement, car toute modification apportée à votre répertoire d'application local sera instantanément répercutée dans le conteneur. Vous liez également votre fichier de configuration PHP, ~/laravel-app/php/local.ini, à /usr/local/etc/php/conf.d/local.ini à l'intérieur du conteneur. Vous allez créer le fichier de configuration PHP local à l'étape 5.

Votre fichier docker-compose ressemblera maintenant à ceci :

~/laravel-app/docker-compose.yml

version: '3'
services:
  
  #PHP Service
  app:
    build:
      context: .
      dockerfile: Dockerfile
    image: digitalocean.com/php
    container_name: app
    restart: unless-stopped
    tty: true
    environment:
      SERVICE_NAME: app
      SERVICE_TAGS: dev
    working_dir: /var/www
    volumes:
      - ./:/var/www
      - ./php/local.ini:/usr/local/etc/php/conf.d/local.ini
    networks:
      - app-network

  #Nginx Service
  webserver:
    image: nginx:alpine
    container_name: webserver
    restart: unless-stopped
    tty: true
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./:/var/www
      - ./nginx/conf.d/:/etc/nginx/conf.d/
    networks:
      - app-network

  #MySQL Service
  db:
    image: mysql:5.7.22
    container_name: db
    restart: unless-stopped
    tty: true
    ports:
      - "3306:3306"
    environment:
      MYSQL_DATABASE: laravel
      MYSQL_ROOT_PASSWORD: your_mysql_root_password
      SERVICE_TAGS: dev
      SERVICE_NAME: mysql
    volumes:
      - dbdata:/var/lib/mysql/
      - ./mysql/my.cnf:/etc/mysql/my.cnf
    networks:
      - app-network

#Docker Networks
networks:
  app-network:
    driver: bridge
#Volumes
volumes:
  dbdata:
    driver: local

Enregistrez le fichier et quittez votre éditeur lorsque vous avez terminé d'apporter des modifications.

Avec votre fichier docker-compose écrit, vous pouvez maintenant créer l'image personnalisée pour votre application.

Étape 4 - Création du Dockerfile

Docker vous permet de spécifier l'environnement à l'intérieur de conteneurs individuels avec un Dockerfile. Un Dockerfile vous permet de créer des images personnalisées que vous pouvez utiliser pour installer le logiciel requis par votre application et configurer les paramètres en fonction de vos besoins. Vous pouvez pousser les images personnalisées que vous créez vers Docker Hub ou n'importe quel registre privé.

Notre Dockerfile sera situé dans notre répertoire ~/laravel-app. Créez le fichier :

nano ~/laravel-app/Dockerfile

Ce Dockerfile définira l'image de base et spécifiera les commandes et instructions nécessaires pour créer l'image de l'application Laravel. Ajoutez le code suivant au fichier :

~/laravel-app/php/Dockerfile

FROM php:7.2-fpm

# Copy composer.lock and composer.json
COPY composer.lock composer.json /var/www/

# Set working directory
WORKDIR /var/www

# Install dependencies
RUN apt-get update && apt-get install -y \
    build-essential \
    libpng-dev \
    libjpeg62-turbo-dev \
    libfreetype6-dev \
    locales \
    zip \
    jpegoptim optipng pngquant gifsicle \
    vim \
    unzip \
    git \
    curl

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

# Install extensions
RUN docker-php-ext-install pdo_mysql mbstring zip exif pcntl
RUN docker-php-ext-configure gd --with-gd --with-freetype-dir=/usr/include/ --with-jpeg-dir=/usr/include/ --with-png-dir=/usr/include/
RUN docker-php-ext-install gd

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

# Add user for laravel application
RUN groupadd -g 1000 www
RUN useradd -u 1000 -ms /bin/bash -g www www

# Copy existing application directory contents
COPY . /var/www

# Copy existing application directory permissions
COPY --chown=www:www . /var/www

# Change current user to www
USER www

# Expose port 9000 and start php-fpm server
EXPOSE 9000
CMD ["php-fpm"]

Tout d'abord, le Dockerfile crée une image au-dessus de l'php:7.2-fpm Docker image. Il s'agit d'une image basée sur Debian sur laquelle l'implémentation PHP FastCGI PHP-FPM est installée. Le fichier installe également les packages prérequis pour Laravel : mcrypt, pdo_mysql, mbstring et imagick avec composer.

La directive RUN spécifie les commandes pour mettre à jour, installer et configurer les paramètres à l'intérieur du conteneur, y compris la création d'un utilisateur et d'un groupe dédiés appelés www. L'instruction WORKDIR spécifie le répertoire /var/www comme répertoire de travail pour l'application.

La création d'un utilisateur et d'un groupe dédiés avec des autorisations restreintes atténue la vulnérabilité inhérente lors de l'exécution de conteneurs Docker, qui s'exécutent par défaut en tant que root. Au lieu d'exécuter ce conteneur en tant que root, nous avons créé l'utilisateur www, qui a un accès en lecture/écriture au dossier /var/www grâce au [ X157X] que nous utilisons avec l'indicateur --chown pour copier les autorisations du dossier de l'application.

Enfin, la commande EXPOSE expose un port dans le conteneur, 9000, pour le serveur php-fpm. CMD spécifie la commande qui doit s'exécuter une fois le conteneur créé. Ici, CMD spécifie "php-fpm", qui démarrera le serveur.

Enregistrez le fichier et quittez votre éditeur lorsque vous avez terminé d'apporter des modifications.

Vous pouvez maintenant passer à la définition de votre configuration PHP.

Étape 5 - Configuration de PHP

Maintenant que vous avez défini votre infrastructure dans le fichier docker-compose, vous pouvez configurer le service PHP pour qu'il agisse en tant que processeur PHP pour les requêtes entrantes de Nginx.

Pour configurer PHP, vous allez créer le fichier local.ini dans le dossier php. Il s'agit du fichier que vous avez monté en liaison sur /usr/local/etc/php/conf.d/local.ini à l'intérieur du conteneur à l'étape 2. La création de ce fichier vous permettra de remplacer le fichier php.ini par défaut que PHP lit au démarrage.

Créez le répertoire php :

mkdir ~/laravel-app/php

Ensuite, ouvrez le fichier local.ini :

nano ~/laravel-app/php/local.ini

Pour montrer comment configurer PHP, nous allons ajouter le code suivant pour définir des limites de taille pour les fichiers téléchargés :

~/laravel-app/php/local.ini

upload_max_filesize=40M
post_max_size=40M

Les directives upload_max_filesize et post_max_size définissent la taille maximale autorisée pour les fichiers téléchargés et montrent comment vous pouvez définir des configurations php.ini à partir de votre fichier local.ini. Vous pouvez mettre n'importe quelle configuration spécifique à PHP que vous souhaitez remplacer dans le fichier local.ini.

Enregistrez le fichier et quittez votre éditeur.

Avec votre fichier PHP local.ini en place, vous pouvez passer à la configuration de Nginx.

Étape 6 - Configuration de Nginx

Avec le service PHP configuré, vous pouvez modifier le service Nginx pour utiliser PHP-FPM comme serveur FastCGI pour servir le contenu dynamique. Le serveur FastCGI est basé sur un protocole binaire pour interfacer des programmes interactifs avec un serveur web. Pour plus d'informations, veuillez consulter cet article sur Comprendre et mettre en œuvre le proxy FastCGI dans Nginx.

Pour configurer Nginx, vous allez créer un fichier app.conf avec la configuration du service dans le dossier ~/laravel-app/nginx/conf.d/.

Commencez par créer le répertoire nginx/conf.d/ :

mkdir -p ~/laravel-app/nginx/conf.d

Créez ensuite le fichier de configuration app.conf :

nano ~/laravel-app/nginx/conf.d/app.conf

Ajoutez le code suivant au fichier pour spécifier votre configuration Nginx :

~/laravel-app/nginx/conf.d/app.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;
    }
}

Le server block définit la configuration du serveur web Nginx avec les directives suivantes :

  • listen : Cette directive définit le port sur lequel le serveur écoutera les requêtes entrantes.
  • error_log et access_log : Ces directives définissent les fichiers d'écriture des journaux.
  • root : cette directive définit le chemin du dossier racine, formant le chemin complet vers tout fichier demandé sur le système de fichiers local.

Dans le bloc de localisation php, la directive fastcgi_pass spécifie que le service app écoute sur un socket TCP sur le port 9000. Cela permet au serveur PHP-FPM d'écouter sur le réseau plutôt que sur un socket Unix. Bien qu'un socket Unix ait un léger avantage en termes de vitesse par rapport à un socket TCP, il n'a pas de protocole réseau et saute donc la pile réseau. Pour les cas où les hôtes sont situés sur une machine, un socket Unix peut avoir du sens, mais dans les cas où vous avez des services exécutés sur différents hôtes, un socket TCP offre l'avantage de vous permettre de vous connecter à des services distribués. Étant donné que notre conteneur app s'exécute sur un hôte différent de notre conteneur webserver, un socket TCP est le plus logique pour notre configuration.

Enregistrez le fichier et quittez votre éditeur lorsque vous avez terminé d'apporter des modifications.

Grâce au montage lié que vous avez créé à l'étape 2, toutes les modifications que vous apportez dans le dossier nginx/conf.d/ seront directement répercutées dans le conteneur webserver.

Ensuite, regardons nos paramètres MySQL.

Étape 7 - Configuration de MySQL

Avec PHP et Nginx configurés, vous pouvez activer MySQL pour agir en tant que base de données pour votre application.

Pour configurer MySQL, vous allez créer le fichier my.cnf dans le dossier mysql. Il s'agit du fichier que vous avez monté en liaison sur /etc/mysql/my.cnf à l'intérieur du conteneur à l'étape 2. Ce support de liaison vous permet de remplacer les paramètres my.cnf selon les besoins.

Pour montrer comment cela fonctionne, nous allons ajouter des paramètres au fichier my.cnf qui activent le journal des requêtes générales et spécifient le fichier journal.

Commencez par créer le répertoire mysql :

mkdir ~/laravel-app/mysql

Ensuite, créez le fichier my.cnf :

nano ~/laravel-app/mysql/my.cnf

Dans le fichier, ajoutez le code suivant pour activer le journal des requêtes et définir l'emplacement du fichier journal :

~/laravel-app/mysql/mon.cnf

[mysqld]
general_log = 1
general_log_file = /var/lib/mysql/general.log

Ce fichier my.cnf active les journaux, définissant le paramètre general_log comme 1 pour autoriser les journaux généraux. Le paramètre general_log_file spécifie où les journaux seront stockés.

Enregistrez le fichier et quittez votre éditeur.

Notre prochaine étape sera de démarrer les conteneurs.

Étape 8 - Modification des paramètres d'environnement et exécution des conteneurs

Maintenant que vous avez défini tous vos services dans votre fichier docker-compose et créé les fichiers de configuration pour ces services, vous pouvez démarrer les conteneurs. Comme dernière étape, cependant, nous allons faire une copie du fichier .env.example que Laravel inclut par défaut et nommer la copie .env, qui est le fichier que Laravel attend pour définir son environnement :

cp .env.example .env

Vous pouvez maintenant modifier le fichier .env sur le conteneur app pour inclure des détails spécifiques sur votre configuration.

Ouvrez le fichier à l'aide de nano ou de l'éditeur de texte de votre choix :

nano .env

Trouvez le bloc qui spécifie DB_CONNECTION et mettez-le à jour pour refléter les spécificités de votre configuration. Vous allez modifier les champs suivants :

  • DB_HOST sera votre conteneur de base de données db.
  • DB_DATABASE sera la base de données laravel.
  • DB_USERNAME sera le nom d'utilisateur que vous utiliserez pour votre base de données. Dans ce cas, nous utiliserons laraveluser.
  • DB_PASSWORD sera le mot de passe sécurisé que vous souhaitez utiliser pour ce compte d'utilisateur.

/var/www/.env

DB_CONNECTION=mysql
DB_HOST=db
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=laraveluser
DB_PASSWORD=your_laravel_db_password

Enregistrez vos modifications et quittez votre éditeur.

Avec tous vos services définis dans votre fichier docker-compose, il vous suffit d'émettre une seule commande pour démarrer tous les conteneurs, créer les volumes, configurer et connecter les réseaux :

docker-compose up -d

Lorsque vous exécutez docker-compose up pour la première fois, il télécharge toutes les images Docker nécessaires, ce qui peut prendre un certain temps. Une fois les images téléchargées et stockées sur votre machine locale, Compose créera vos conteneurs. L'indicateur -d diabolise le processus en exécutant vos conteneurs en arrière-plan.

Une fois le processus terminé, utilisez la commande suivante pour répertorier tous les conteneurs en cours d'exécution :

docker ps

Vous verrez la sortie suivante avec des détails sur vos conteneurs app, webserver et db :

OutputCONTAINER ID        NAMES               IMAGE                             STATUS              PORTS
c31b7b3251e0        db                  mysql:5.7.22                      Up 2 seconds        0.0.0.0:3306->3306/tcp
ed5a69704580        app                 digitalocean.com/php              Up 2 seconds        9000/tcp
5ce4ee31d7c0        webserver           nginx:alpine                      Up 2 seconds        0.0.0.0:80->80/tcp, 0.0.0.0:443->443/tcp

Le CONTAINER ID dans cette sortie est un identifiant unique pour chaque conteneur, tandis que NAMES répertorie le nom du service associé à chacun. Vous pouvez utiliser ces deux identifiants pour accéder aux conteneurs. IMAGE définit le nom de l'image pour chaque conteneur, tandis que STATUS fournit des informations sur l'état du conteneur : s'il est en cours d'exécution, en cours de redémarrage ou arrêté.

Nous allons maintenant utiliser docker-compose exec pour définir la clé d'application pour l'application Laravel. La commande docker-compose exec vous permet d'exécuter des commandes spécifiques dans des conteneurs.

La commande suivante générera une clé et la copiera dans votre fichier .env, en veillant à ce que vos sessions utilisateur et vos données chiffrées restent sécurisées :

docker-compose exec app php artisan key:generate

Vous disposez maintenant des paramètres d'environnement requis pour exécuter votre application. Pour mettre ces paramètres en cache dans un fichier, ce qui augmentera la vitesse de chargement de votre application, exécutez :

docker-compose exec app php artisan config:cache

Vos paramètres de configuration seront chargés dans /var/www/bootstrap/cache/config.php sur le conteneur.

Enfin, visitez http://your_server_ip dans le navigateur. Vous verrez la page d'accueil suivante pour votre application Laravel :

Avec vos conteneurs en cours d'exécution et vos informations de configuration en place, vous pouvez passer à la configuration de vos informations utilisateur pour la base de données laravel sur le conteneur db.

Étape 9 - Création d'un utilisateur pour MySQL

L'installation par défaut de MySQL crée uniquement le compte administratif root, qui dispose de privilèges illimités sur le serveur de base de données. En général, il est préférable d'éviter d'utiliser le compte administratif root lors de l'interaction avec la base de données. Au lieu de cela, créons un utilisateur de base de données dédié pour la base de données Laravel de notre application.

Pour créer un nouvel utilisateur, exécutez un shell bash interactif sur le conteneur db avec docker-compose exec :

docker-compose exec db bash

Dans le conteneur, connectez-vous au compte administratif MySQL root :

mysql -u root -p

Vous serez invité à entrer le mot de passe que vous avez défini pour le compte MySQL root lors de l'installation dans votre fichier docker-compose.

Commencez par rechercher la base de données appelée laravel, que vous avez définie dans votre fichier docker-compose. Exécutez la commande show databases pour vérifier les bases de données existantes :

show databases;

Vous verrez la base de données laravel répertoriée dans la sortie :

Output+--------------------+
| Database           |
+--------------------+
| information_schema |
| laravel            |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
5 rows in set (0.00 sec)

Ensuite, créez le compte utilisateur qui sera autorisé à accéder à cette base de données. Notre nom d'utilisateur sera laraveluser, bien que vous puissiez le remplacer par un autre nom si vous préférez. Assurez-vous simplement que votre nom d'utilisateur et votre mot de passe correspondent aux détails que vous avez définis dans votre fichier .env à l'étape précédente :

GRANT ALL ON laravel.* TO 'laraveluser'@'%' IDENTIFIED BY 'your_laravel_db_password';

Supprimez les privilèges pour notifier le serveur MySQL des modifications :

FLUSH PRIVILEGES;

Quittez MySQL :

EXIT;

Enfin, quittez le conteneur :

exit

Vous avez configuré le compte d'utilisateur pour votre base de données d'application Laravel et êtes prêt à migrer vos données et à travailler avec la console Tinker.

Étape 10 - Migration des données et utilisation de la console Tinker

Avec votre application en cours d'exécution, vous pouvez migrer vos données et expérimenter avec la commande tinker, qui lancera une console PsySH avec Laravel préchargé. PsySH est une console de développement d'exécution et un débogueur interactif pour PHP, et Tinker est un REPL spécifiquement pour Laravel. L'utilisation de la commande tinker vous permettra d'interagir avec votre application Laravel à partir de la ligne de commande dans un shell interactif.

Tout d'abord, testez la connexion à MySQL en exécutant la commande Laravel artisan migrate, qui crée une table migrations dans la base de données depuis l'intérieur du conteneur :

docker-compose exec app php artisan migrate

Cette commande migrera les tables Laravel par défaut. La sortie confirmant la migration ressemblera à ceci :

Output
Migration table created successfully.
Migrating: 2014_10_12_000000_create_users_table
Migrated:  2014_10_12_000000_create_users_table
Migrating: 2014_10_12_100000_create_password_resets_table
Migrated:  2014_10_12_100000_create_password_resets_table

Une fois la migration terminée, vous pouvez exécuter une requête pour vérifier si vous êtes correctement connecté à la base de données à l'aide de la commande tinker :

docker-compose exec app php artisan tinker

Testez la connexion MySQL en récupérant les données que vous venez de migrer :

\DB::table('migrations')->get();

Vous verrez une sortie qui ressemble à ceci :

Output=> Illuminate\Support\Collection {#2856
     all: [
       {#2862
         +"id": 1,
         +"migration": "2014_10_12_000000_create_users_table",
         +"batch": 1,
       },
       {#2865
         +"id": 2,
         +"migration": "2014_10_12_100000_create_password_resets_table",
         +"batch": 1,
       },
     ],
   }

Vous pouvez utiliser tinker pour interagir avec vos bases de données et expérimenter des services et des modèles.

Avec votre application Laravel en place, vous êtes prêt pour d'autres développements et expérimentations.

Conclusion

Vous avez maintenant une application de pile LEMP en cours d'exécution sur votre serveur, que vous avez testée en accédant à la page d'accueil de Laravel et en créant des migrations de base de données MySQL.

La clé de la simplicité de cette installation est Docker Compose, qui vous permet de créer un groupe de conteneurs Docker, défini dans un seul fichier, avec une seule commande. Si vous souhaitez en savoir plus sur la façon de faire CI avec Docker Compose, jetez un œil à Comment configurer un environnement de test d'intégration continue avec Docker et Docker Compose sur Ubuntu 16.04. Si vous souhaitez rationaliser votre processus de déploiement d'applications Laravel, alors Comment déployer automatiquement des applications Laravel avec Deployer sur Ubuntu 16.04 sera une ressource pertinente.