TOC

Comment configurer Laravel, Nginx et MySQL avec Docker Compose

L'auteur a sélectionnéThe FreeBSD Foundation pour recevoir un don dans le cadre du programmeWrite 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 lescontainers éphémères. Lorsque vous utilisez une pile d'applications LEMP, par exemple, avecPHP,Nginx,MySQL et le frameworkLaravel, 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 commandesdocker container create etdocker container run.

Dans ce didacticiel, vous allez créer une application Web utilisant le framework Laravel, avec Nginx comme serveur Web et MySQL comme base de données, le tout dans des conteneurs Docker. Vous définirez toute la configuration de la pile dans un fichierdocker-compose, ainsi que les fichiers de configuration pour PHP, MySQL et Nginx.

Conditions préalables

Avant de commencer, vous aurez besoin de:

[[step-1 -—- download-laravel-and-install-dependencies]] == Étape 1 - Téléchargement de Laravel et installation des dépendances

Dans un premier temps, nous obtiendrons la dernière version de Laravel et installerons les dépendances du projet, y comprisComposer, le gestionnaire de paquets au niveau de l'application pour PHP. Nous allons installer ces dépendances avec Docker pour éviter de devoir 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

Accédez au répertoirelaravel-app: 

cd ~/laravel-app

Ensuite, utilisez lescomposer image de Docker pour monter les répertoires dont vous aurez besoin pour votre projet Laravel et éviter la surcharge de l'installation de Composer globalement: 

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

L'utilisation des indicateurs-v et--rm avecdocker run crée un conteneur éphémère qui sera monté en liaison dans 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 dossiervendor créé par Composer à l'intérieur du conteneur est copié dans votre répertoire actuel.

Pour finir, 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 l'image de votre application à l'étape 4, car cela vous permettra de travailler avec le code de votre application et d'exécuter des processus dans votre conteneur en tant qu'utilisateur non -root.

Avec votre code d'application en place, vous pouvez définir vos services avec Docker Compose.

[[step-2 -—- creation-the-docker-compose-file]] == Étape 2 - Création du fichier Docker Compose

La construction de vos applications avec Docker Compose simplifie le processus de configuration et de version de votre infrastructure. Pour configurer notre application Laravel, nous allons écrire un fichierdocker-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 fichierdocker-compose, vous définirez trois services:app,webserver etdb. Ajoutez le code suivant au fichier, en veillant à remplacer le mot de passeroot pourMYSQL_ROOT_PASSWORD, défini comme unenvironment variable sous le servicedb, par 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 incluent:

  • 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 lesworking_dir du conteneur sur/var/www.

  • webserver: cette définition de service extrait lesnginx:alpine image de Docker et expose les ports80 et443.

  • db: cette définition de service extrait lesmysql:5.7.22 image de Docker et définit quelques variables d'environnement, y compris une base de données appeléelaravel pour votre application et le mot de passeroot pour la base de données. Vous êtes libre de nommer la base de données comme vous le souhaitez et vous devez remplaceryour_mysql_root_password par votre propre mot de passe fort. Cette définition de service mappe également le port3306 sur l'hôte au port3306 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 attribue un nom à chaque conteneur en combinant le nom d’une personne historiquement célèbre et un mot aléatoire, séparés 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 ponté utilise un pont logiciel permettant aux conteneurs connectés au même réseau pont de communiquer entre eux. Le pilote de pont installe automatiquement les règles sur la machine hôte afin que les conteneurs situés sur différents réseaux de pont ne puissent pas communiquer directement les uns avec les autres. 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 associées: les services d'application frontaux peuvent utiliser un réseaufrontend, par exemple, et les services back-end peuvent utiliser un réseaubackend.

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

[[step-3 -—- persisting-data]] == Étape 3 - Données persistantes

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

[.warning] #Warning: En utilisant des montages de liaison, vous permettez de changer 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 répertoires système importants. Il s'agit d'une capacité puissante ayant des implications en matière de sécurité et pouvant avoir un impact sur les processus non Docker sur le système hôte. Utilisez les montures de liaison avec précaution.
#

Dans le fichierdocker-compose, définissez un volume appelédbdata sous la définition de servicedb 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 servicedb sans perdre de données.

Au bas du fichier, ajoutez la définition du volumedbdata:

~/laravel-app/docker-compose.yml

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

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

Ensuite, ajoutez un montage de liaison au servicedb 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 de liaison lie~/laravel-app/mysql/my.cnf à/etc/mysql/my.cnf dans le conteneur.

Ensuite, ajoutez des montages de liaison au servicewebserver. Il y en aura deux: un pour votre code d'application et un autre pour la définition de configuration Nginx que vous allez créer à 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 de liaison lie le code de l'application dans le 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 de liaison suivants au serviceapp 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 serviceapp est en train de monter en liaison le dossier~/laravel-app, qui contient le code de l'application, dans le dossier/var/www du conteneur. Cela accélérera le processus de développement, car toutes les modifications apportées à votre répertoire d'applications locales seront immédiatement répercutées 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 fichierdocker-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é les modifications.

Une fois votre fichierdocker-compose écrit, vous pouvez désormais créer l'image personnalisée pour votre application.

[[step-4 -—- creation-the-dockerfile]] == Étape 4 - Création du Dockerfile

Docker vous permet de spécifier l'environnement à l'intérieur de conteneurs individuels avec unDockerfile. Un fichier 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 versDocker Hub ou n'importe quel registre privé.

NosDockerfile seront situés dans notre répertoire~/laravel-app. Créez le fichier: 

nano ~/laravel-app/Dockerfile

CeDockerfile définira l'image de base et spécifiera les commandes et instructions nécessaires pour construire 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 \
    mysql-client \
    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 desphp:7.2-fpm Docker image. Il s'agit d'une image basée sur Debian sur laquelle l'implémentation PHP FastCGIPHP-FPM est installée. Le fichier installe également les packages prérequis pour Laravel:mcrypt,pdo_mysql,mbstring etimagick aveccomposer.

La directiveRUN 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éswww. L'instructionWORKDIR spécifie le répertoire/var/www comme répertoire de travail de 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 à l'exécution de conteneurs Docker, qui s'exécutent par défaut en tant queroot. Au lieu d'exécuter ce conteneur en tant queroot, nous avons créé l'utilisateurwww, qui a un accès en lecture / écriture au dossier/var/www grâce à l'instructionCOPY que nous sommes à l'aide de l'indicateur--chown pour copier les autorisations du dossier d'application.

Enfin, la commandeEXPOSE expose un port dans le conteneur,9000, pour le serveurphp-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é les modifications.

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

[[step-5 -—- configuring-php]] == Étape 5 - Configuration de PHP

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

Pour configurer PHP, vous allez créer le fichierlocal.ini dans le dossierphp. Il s'agit du fichier que vous avez monté en liaison avec/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 fichierphp.ini par défaut que PHP lit au démarrage.

Créez le répertoirephp: 

mkdir ~/laravel-app/php

Ensuite, ouvrez le fichierlocal.ini: 

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

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

~/laravel-app/php/local.ini

upload_max_filesize=40M
post_max_size=40M

Les directivesupload_max_filesize etpost_max_size définissent la taille maximale autorisée pour les fichiers téléchargés et montrent comment vous pouvez définir les configurationsphp.ini à partir de votre fichierlocal.ini. Vous pouvez mettre toute configuration spécifique à PHP que vous souhaitez remplacer dans le fichierlocal.ini.

Enregistrez le fichier et quittez votre éditeur.

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

[[step-6 -—- configuring-nginx]] == Étape 6 - Configuration de Nginx

Avec le service PHP configuré, vous pouvez modifier le service Nginx pour utiliser PHP-FPM en tant que serveur FastCGI afin de servir du contenu dynamique. Le serveur FastCGI est basé sur un protocole binaire pour l’interfaçage de programmes interactifs avec un serveur Web. Pour plus d'informations, reportez-vous à cet article surUnderstanding and Implementing FastCGI Proxying in Nginx.

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

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

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

Ensuite, créez le fichier de configuration deapp.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;
    }
}

Leserver 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 etaccess_log: ces directives définissent les fichiers pour l'écriture des journaux.

  • root: cette directive définit le chemin du dossier racine, formant le chemin complet de tout fichier demandé sur le système de fichiers local.

Dans le bloc d'emplacementphp, la directivefastcgi_pass spécifie que le serviceapp écoute sur un socket TCP sur le port9000. Cela fait que le serveur PHP-FPM écoute sur le réseau plutôt que sur un socket Unix. Bien qu'un socket Unix ait un léger avantage en vitesse par rapport à un socket TCP, il n'a pas de protocole réseau et ignore donc la pile réseau. Dans les cas où les hôtes sont situés sur une seule machine, un socket Unix peut avoir un sens, mais dans les cas où des services s'exécutent sur des hôtes différents, un socket TCP offre l'avantage de vous permettre de vous connecter à des services distribués. Comme notre conteneurapp s'exécute sur un hôte différent de celui de notre conteneurwebserver, un socket TCP est le plus logique pour notre configuration.

Enregistrez le fichier et quittez votre éditeur lorsque vous avez terminé les modifications.

Grâce au montage de liaison que vous avez créé à l'étape 2, toutes les modifications que vous apportez dans le dossiernginx/conf.d/ seront directement reflétées dans le conteneurwebserver.

Ensuite, regardons nos paramètres MySQL.

[[step-7 -—- configuring-mysql]] == Étape 7 - Configurer MySQL

Avec PHP et Nginx configurés, vous pouvez permettre à MySQL d’agir comme base de données pour votre application.

Pour configurer MySQL, vous allez créer le fichiermy.cnf dans le dossiermysql. Il s'agit du fichier que vous avez monté en liaison avec/etc/mysql/my.cnf à l'intérieur du conteneur à l'étape 2. Ce montage de liaison vous permet de remplacer les paramètresmy.cnf en cas de besoin.

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

Commencez par créer le répertoiremysql: 

mkdir ~/laravel-app/mysql

Ensuite, créez le fichiermy.cnf: 

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

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

~/laravel-app/mysql/my.cnf

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

Ce fichiermy.cnf active les journaux, définissant le paramètregeneral_log comme1 pour autoriser les journaux généraux. Le paramètregeneral_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.

[[step-8 -—- running-the-containers-and-modifying-environment-settings]] == Étape 8 - Exécution des conteneurs et modification des paramètres d'environnement

Maintenant que vous avez défini tous vos services dans votre fichierdocker-compose et créé les fichiers de configuration pour ces services, vous pouvez démarrer les conteneurs. Cependant, comme étape finale, 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 s'attend à définir son environnement: 

cp .env.example .env

Nous allons configurer les détails spécifiques de notre configuration dans ce fichier une fois que nous aurons démarré les conteneurs.

Avec tous vos services définis dans votre fichierdocker-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écutezdocker-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 ordinateur local, Compose créera vos conteneurs. L'indicateur-d démonise le processus, 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 conteneursapp,webserver etdb: 

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

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

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

Ouvrez le fichier à l'aide dedocker-compose exec, qui vous permet d'exécuter des commandes spécifiques dans des conteneurs. Dans ce cas, vous ouvrez le fichier pour le modifier: 

docker-compose exec app nano .env

Trouvez le bloc qui spécifieDB_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éesdb.

  • DB_DATABASE sera la base de donnéeslaravel.

  • DB_USERNAME sera le nom d'utilisateur que vous utiliserez pour votre base de données. Dans ce cas, nous utiliseronslaraveluser.

  • DB_PASSWORD sera le mot de passe sécurisé que vous souhaitez utiliser pour ce compte 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.

Ensuite, définissez la clé d'application pour l'application Laravel avec la commandephp artisan key:generate. Cette commande générera une clé et la copiera dans votre fichier.env, garantissant 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 en cache ces paramètres 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.

Pour finir, visitezhttp://your_server_ip dans le navigateur. Vous verrez la page d'accueil suivante pour votre application Laravel:

Laravel Home Page

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éeslaravel sur le conteneurdb.

[[step-9 -—- creation-a-user-for-mysql]] == Étape 9 - Création d'un utilisateur pour MySQL

L'installation MySQL par défaut crée uniquement le compte administratif deroot, qui dispose de privilèges illimités sur le serveur de base de données. En général, il vaut mieux éviter d’utiliser le compte administratif deroot lors de l’interaction avec la base de données. Créons plutôt 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 conteneurdb avecdocker-compose exec: 

docker-compose exec db bash

À l'intérieur du conteneur, connectez-vous au compte administratif de MySQLroot: 

mysql -u root -p

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

Commencez par rechercher la base de données appeléelaravel, que vous avez définie dans votre fichierdocker-compose. Exécutez la commandeshow databases pour rechercher les bases de données existantes: 

show databases;

Vous verrez la base de donnéeslaravel 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 seralaraveluser, mais vous pouvez 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';

Videz les privilèges pour informer 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 à utiliser la console Tinker.

[[step-10 -—- migrating-data-and-working-with-the-tinker-console]] == Étape 10 - Migration des données et utilisation de la Tinker Console

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

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

docker-compose exec app php artisan migrate

Cette commande va migrer 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 commandetinker: 

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 utilisertinker 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 un développement et des expériences plus poussés.

Conclusion

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

La simplicité de cette installation repose sur Docker Compose, qui vous permet de créer un groupe de conteneurs Docker, définis dans un fichier unique, à l’aide d’une seule commande. Si vous souhaitez en savoir plus sur la façon de faire de la CI avec Docker Compose, jetez un œil àHow To Configure a Continuous Integration Testing Environment with Docker and Docker Compose on Ubuntu 16.04. Si vous souhaitez rationaliser le processus de déploiement de votre application Laravel,How to Automatically Deploy Laravel Applications with Deployer on Ubuntu 16.04 sera une ressource pertinente.

Related