Déployer Laravel, Nginx & MySQL avec Docker

Prérequis

Avant de commencer, vous aurez besoin d’un serveur avec Ubuntu 18.04 d’installé

sudo apt-get update
apt full-upgrade

Télécharger Laravel et installer les dépendances

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

déplacer le poineur dans le dossier récemment creer

cd ~/laravel-app

Ensuite, utilisez Composer de Docker pour créer les répertoires dont vous aurez besoin pour votre projet Laravel et éviter la surcharge liée à l’installation globale de Composer:

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

docker run –rm -v signifie que Docker crée un conteneur éphémère qui sera monté en association dans votre répertoire actuel avant d’être supprimé, il copie le contenu de votre répertoire dans le conteneur et s’assure que le dossier créé par Composer est bien copié dans votre répertoire laravel-app vendor

En cas d’erreur, vous pouvez faire la commande suivante :

sudo apt install docker.io

Définir les autorisations sur le répertoire du projet :

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

Cela sera important lorsque vous écrivez le fichier Dockerfile ou exécuter des processus dans votre conteneur en tant qu’utilisateur non root .

Création du fichier de composition Docker

Pour configurer notre application Laravel, nous allons écrire un docker-composefichier qui définit nos services de serveur Web, de base de données et d’application.

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

Dans le fichier docker-compose.yml, ajoutez le code suivant au fichier, en veillant à remplacer le mot de passe root pour MYSQL_ROOT_PASSWORD, défini en tant que variable d’environnement sous le dbservice, par un mot de passe fort de votre choix:

version: '3'
services:

  #PHP Service
  app:
    build:
      context: .
      dockerfile: Dockerfile
    image: e-real.fr/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

Dans le fichier docker-compose.yml, définir un volume dbdata dans la db, cela vous permet d’arrêter et de redémarrer le dbservice sans perdre de données.

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

Au bas du fichier, ajoutez ceci afin de pouvoir utiliser tous les services.

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

Ajoutez au fichier précédent les montages de liaisons (pour lier ~/laravel-app/mysql/my.cnf au /etc/mysql/my.cnfconteneur) pour les fichiers de configuration MySQL que nous créerons plus tard :

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

Ensuite, ajoutez des montages de liaison au webserver : 1 pour votre code d’application et 1 autre pour la configuration Nginx que nous créerons plus tard :


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

Ajoutons les montages de liaison suivants pour PHP Service toujours dans le fichier

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

Votre docker-compose doit maintenant ressembler à ceci:

version: '3'
services:

  #PHP Service
  app:
    build:
      context: .
      dockerfile: Dockerfile
    image: e-real.fr/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

Création du fichier Docker

Un fichier Dockerfile 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 et transmettre les images personnalisées à Docker Hub ou à tout registre privé.

nano ~/laravel-app/Dockerfile

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


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"]

Configuration de PHP

Pour configurer PHP, vous allez créer le fichier local.ini dans le dossier php. La création de ce fichier vous permettra de remplacer le php.inifichier par défaut que PHP lit au démarrage.

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

Ajouter le code suivant dans le fichier local.ini pour définir les limites de taille des fichiers téléchargés:

upload_max_filesize=40M
post_max_size=40M

Configuration de PHP

Pour configurer Nginx, vous allez créer un fichier app.conf dans le dossier conf.d que nous allons créer également

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

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

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

Configuration de 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 fichier my.cnf dans un dossier mysql.


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

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


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

Exécution des conteneurs et modification des paramètres de l’environnement

Nous allons faire une copie du fichier .env.example et le nommer .env pour définir son environnement:

cp .env.example .env

il suffit de faire une seule commande pour démarrer tous les conteneurs, créer les volumes et configurer et connecter les réseaux:

docker-compose up -d

Note : Si vous avez le message d’erreur suivant command ‘docker-compose’ not found : exécutez sudo apt install docker-compose puis relancer la commande précédente

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

docker ps

Vous devriez avoir un fichier celui-ci

Output
CONTAINER ID        NAMES               IMAGE                             STATUS              PORTS
c31b7b3251e0        db                  mysql:5.7.22                      Up 2 seconds        0.0.0.0:3306->3306/tcp
ed5a69704580        app                 e-real.fr/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

Ouvrez le fichier avec vim en utilisant docker-compose exec, ce 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 vim .env

Vous pouvez désormais depuis votre navigateur voir la page d’accueil Laravel en tapant l’adresse de votre serveur : http://your_server_ip

Créer un nouvel utilisateur pou MySQL

L’installation par défaut de MySQL crée uniquement un utilisateur 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 celui-ci lors de l’interaction avec la base de données. À la place, nous allons simplement créer 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 la commande suivante depuis le db container(base de donnée conteneur).

docker-compose exec db bash

Dans le conteneur, connectez-vous à MySQL avec ROOT :

mysql -u root -p

Commencez par rechercher la base de données que vous avez définie dans votre docker-composefichier. Exécutez la commande suivante pour vérifier les bases de données existantes:

mysql> show databases;

Vous devriez voir votre base de données :

Output

Créez le compte utilisateur qui sera autorisé à accéder à cette base de données. Assurez-vous simplement que votre nom d’utilisateur et votre mot de passe correspondent aux informations que vous avez définies dans votre fichier .env à l’étape précédente:

mysql> GRANT ALL ON bdd_name.* TO 'user'@'%' IDENTIFIED BY 'votre_db_password';

mysql> FLUSH PRIVILEGES;

Quittez MySQL :

mysql> EXIT;

Quittez le container :

exit

Bravo, Vous venez de configurer le compte d’utilisateur pour votre base de données et êtes désormais prêt à migrer vos données et à utiliser la console Tinker.

Migration des données avec Tinker

Commencez par tester la connexion à MySQL en exécutant la commande suivante depuis le container :

docker-compose exec app php artisan migrate

Vous devriez avoir quelque chose comme ci-dessous :

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, éxécuter une requête pour vérifier si vous êtes correctement connecté à votre base de données à l’aide de 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 devriez avoir quelque chose 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,
       },
     ],
   }

Bravo, vous avez maintenant une LEMP stack sur votre serveur. La simplicité de cette installation repose sur Docker Compose, qui vous permet de créer un groupe de conteneurs Docker, définis dans un seul fichier, avec une seule commande.

Vous êtes arrivé au bout de cet article, j’en conclus qu’il vous a plu, alors envoyez moi un max d’étoiles ⭐⭐⭐⭐⭐, et partagez le avec vos amis et vos connaissances sur les réseaux sociaux, avec les boutons ci-dessous :

5 (100%) 5 vote[s]