Introduction
L'intégration continue (CI) et le déploiement continu (CD) font partie des sujets les plus tendance actuellement dans le développement de logiciels. Pour réaliser l'aspect CI/CD de l'architecture logicielle, les développeurs utilisent des conteneurs. Les conteneurs sont des environnements légers, virtualisés, portables et définis par logiciel. Dans les conteneurs, le logiciel peut s'exécuter de manière isolée des autres logiciels s'exécutant sur la machine hôte physique. Ce tutoriel se concentre sur l'utilisation de la plateforme de conteneurs Docker pour déployer et exécuter des applications web. Docker permet de simplifier le processus de configuration d'une pile de serveurs web. Dans ce tutoriel, nous utiliserons la pile LEMP pour servir une application Laravel .
La pile LEMP combine Linux comme système d'exploitation, Nginx comme serveur web, MySQL comme base de données, et le langage PHP pour le script et le traitement dynamique. Vous pouvez suivre notre tutoriel sur la façon d'installer et de configurer une pile LEMP sur Ubuntu. Laravel est l'un des meilleurs frameworks PHP pour le développement d'applications web.
Docker fournit un outil appelé Docker Compose pour définir le processus de configuration d'un conteneur Docker. Docker Compose permet aux développeurs de définir l'infrastructure de leur application, les services, les volumes, les réseaux et toutes les dépendances dans un seul fichier appelé le fichier docker-compose. Il peut gérer plusieurs conteneurs Docker grâce à ses commandes telles que docker container create, docker container run, etc.
Dans ce tutoriel, vous apprendrez comment déployer une application web Laravel avec Nginx et MySQL dans un conteneur Docker. Les configurations de l'ensemble de la pile seront définies dans un fichier docker-compose, ainsi que d'autres fichiers de configuration pour PHP, MySQL et Nginx. Commençons !
Tout d'abord
- Comme il s'agit d'un tutoriel pratique, vous devriez disposer d'une installation de Ubuntu 20.04 comme environnement d'exploitation initial. Vous devriez également avoir un utilisateur non-root avec des privilèges sudo. Voici un tutoriel étape par étape pour vous aider à configurer votre serveur Ubuntu.
- Vous devez installer Docker. Nous avons un tutoriel sur la façon d'installer et d'utiliser Docker sur Ubuntu 18.04.
- Vous devez installer Docker Compose en suivant le tutoriel de la documentation officielle de Docker.
Étape 1 : Télécharger Laravel et installer les dépendances
La première étape consiste à obtenir le code Laravel à partir d'un dépôt. Dans des scénarios réels, vous pouvez avoir votre code Laravel dans un dépôt quelque part, par exemple sur GitHub, Bitbucket, Gitlab, etc. Cependant, pour les besoins de ce tutoriel, nous allons cloner la dernière version depuis le dépôt officiel de Laravel sur GitHub. Le dépôt est fourni avec un fichier composer, un gestionnaire de dépendances au niveau de l'application pour PHP. Comme nous voulons que tout s'exécute à l'intérieur du conteneur Docker, nous installerons les dépendances en utilisant l'image Docker composer . Cela nous évitera également d'avoir à installer composer globalement sur la machine hôte réelle. Ensuite, lancez votre terminal.
Allez dans votre répertoire personnel :
|
1 |
cd ~ |
Saisissez la commande suivante pour cloner le dépôt dans un répertoire nommé laravel-web. Vous êtes libre de le nommer comme vous le souhaitez. Au moment de la rédaction de ce dépôt, lorsque nous exécutons cette commande, elle récupère la version 8 de Laravel. Lorsque vous exécuterez la commande, vous trouverez probablement une nouvelle version :
|
1 |
git clone https://github.com/laravel/laravel.git laravel-web |
Ensuite, déplacez-vous dans le répertoire dans lequel vous venez de cloner le dépôt :
|
1 |
cd ~/laravel-web |
Saisissez la commande suivante pour monter les répertoires requis par votre application Laravel en utilisant l'image composer de Docker:
|
1 |
docker run --rm -v $(pwd):/app composer install |
Les options -v et –rm de la commande docker run créent un conteneur éphémère qui sera monté par liaison (bind-mount) sur le répertoire actuel avant d'être supprimé. La commande copie le contenu de ~/laravel-web dans le conteneur et s'assure que le dossier vendor créé par composer est recopié dans le répertoire actuel.
Maintenant, vous devez changer le propriétaire du répertoire laravel-web pour l'utilisateur non-root. Cela permettra de travailler avec le code de votre application en tant qu'utilisateur non-root et d'exécuter des processus à l'intérieur du conteneur dans les étapes suivantes. Entrez la commande suivante pour changer le propriétaire :
|
1 |
sudo chown -R $USER:$USER ~/laravel-web |
Votre code d'application est maintenant en place. Le répertoire appartient à un utilisateur non-root, vous pouvez donc procéder à la définition des services de l'application dans le fichier docker-composer.
Étape 2 : Créer le fichier Docker Compose
Docker Compose simplifie le processus de construction et de déploiement d'une application. Une fois que vous avez défini les configurations et les services, vous pouvez facilement déployer votre application sur n'importe quelle machine hôte sur laquelle Docker et Docker Compose sont installés, sans vous soucier des dépendances de l'application. Plus important encore, vous pouvez le faire avec une seule commande Docker Compose, comme nous le verrons dans l'Étape 9.
Dans cette étape, vous allez définir un fichier Docker Compose avec les configurations pour le serveur web, la base de données et les services d'application nécessaires au déploiement d'une application Laravel.
Les fichiers Docker Compose sont des YAML enregistrés avec l'extension .yml. Veuillez noter qu'une indentation correcte est nécessaire pour un fichier Docker Compose valide. Entrez la commande suivante pour créer et ouvrir le fichier avec nano pour édition :
|
1 |
nano ~/laravel-web/docker-compose.yml |
Ensuite, vous définirez trois services dans ce fichier : app, webserver et db. La section db définit les identifiants de la base de données pour votre application, veillez donc à choisir un mot de passe mysql_root_password fort et à le remplacer dans cette section. Copiez et collez le code suivant :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
version: '2.0' services: #Service PHP app: build: context: . dockerfile: Dockerfile image: cloudsigma.com/php container_name: app restart: unless-stopped tty: true environment: SERVICE_NAME: app SERVICE_TAGS: dev working_dir: /var/www/html/ networks: - app-network #Service Nginx webserver: image: nginx:alpine container_name: webserver restart: unless-stopped tty: true ports: - "80:80" - "443:443" networks: - app-network #Service MySQL db: image: mysql:5.7.32 container_name: db restart: unless-stopped tty: true ports: - "3306:3306" environment: MYSQL_DATABASE: laravel_web MYSQL_ROOT_PASSWORD: replace_mysql_root_password SERVICE_TAGS: dev SERVICE_NAME: mysql networks: - app-network #Réseaux Docker networks: app-network: driver: bridge |
Ci-dessous, vous trouverez les explications des définitions de services du code ci-dessus :
- app : Définit l'application Laravel et exécute une image Docker personnalisée, cloudsigma.com/php, que nous définirons à l'Étape 4. Il définit également le working_dir dans le conteneur sur /var/www/html.
- webserver : Il récupère l'image nginx:alpine depuis Docker et expose les ports 80 et 443.
- db : Il récupère l'image mysql:5.7.32 depuis Docker et définit quelques variables d'environnement. Celles-ci incluent une base de données appelée laravel_web pour l'application et le mot de passe root pour la base de données. Vous pouvez renommer la base de données avec le nom de votre choix. N'oubliez pas de remplacer la MYSQL_ROOT_PASSWORD par un mot de passe fort. Ce service mappe également le port 3306 de l'hôte au port 3306 du conteneur.
La propriété container_name dans chaque service définit un nom pour le conteneur correspondant au service. Si vous ne définissez pas cette propriété, Docker choisit un nom aléatoire pour chaque conteneur.
La propriété networks définit un réseau bridge appelé app-network qui facilite la communication entre les conteneurs. Un réseau bridge est contrôlé par un pont logiciel qui permet uniquement la communication entre les conteneurs sur le même pont réseau. Le contrôleur logiciel du pont installe des pilotes qui empêchent les conteneurs de différents réseaux bridge de communiquer directement entre eux. Cela garantit un niveau de sécurité élevé puisque seuls les services liés peuvent communiquer directement. Vous pouvez choisir de définir plusieurs services et réseaux se connectant à des fonctions associées.
Étape 3 : Comment persister les données
Votre application web va gérer et servir des données à vos utilisateurs. Dans cette étape, nous vous guiderons dans la définition de volumes et de montages bind pour vos définitions de services afin de persister les données de l'application. Docker propose des fonctionnalités incroyables telles que les montages bind et les volumes pour persister les données et sauvegarder les fichiers de configuration de l'application. Nous les utiliserons pour configurer notre application Laravel avec Docker.
Les volumes sont préférés pour diverses raisons, notamment parce qu'ils offrent des sauvegardes et persistent les données au-delà du cycle de vie d'un conteneur. Les montages bind font généralement référence à un répertoire réel sur la machine hôte. Lorsque vous créez un volume, un nouveau répertoire est créé à l'intérieur du répertoire de stockage de Docker, qui est géré par Docker. Lorsque vous créez un montage bind, un fichier ou un répertoire de la machine hôte est monté dans un conteneur (référencé par son chemin absolu). Ceci est crucial pour notre application web car lorsque vous modifiez le code sur la machine hôte, il sera immédiatement disponible pour le conteneur.
Soyez prudent lorsque vous utilisez des montages bind. Les processus s'exécutant à l'intérieur du conteneur Docker peuvent apporter des modifications au système de fichiers de l'hôte et affecter les processus non-Docker s'exécutant sur le système hôte. Bien que les montages Docker soient une fonctionnalité puissante, soyez conscient de ces implications en matière de sécurité.
Ceci étant dit, voyons comment nous pouvons utiliser ces deux fonctionnalités dans notre configuration. Tout d'abord, nous allons définir un volume pour persister la base de données MySQL. Dans le fichier Docker Compose que nous avons créé, sous le service db, ajoutez une propriété volumes comme mis en évidence ci-dessous :
|
1 2 3 4 5 6 7 8 |
#Service MySQL db: ... volumes: - dbdata:/var/lib/mysql/ networks: - app-network ... |
Comme défini, le volume dbdata persistera le contenu de /var/lib/mysql. Il facilite les sauvegardes et permet de redémarrer le service sans perdre les données. Ensuite, vous devez ajouter la définition des volumes à la fin du fichier Docker Compose pour la rendre disponible pour tous les services. Saisissez l'extrait de code suivant au bas du fichier :
|
1 2 3 4 |
#Volumes volumes: dbdata: driver: local |
Pour vous connecter à une base de données MySQL, vous devez fournir des identifiants. Pour ce faire, définissez un montage bind en ajoutant l'extrait de code mis en évidence suivant au service db sous la propriété volumes :
|
1 2 3 4 5 6 7 |
#Service MySQL db: ... volumes: - dbdata:/var/lib/mysql/ - ./mysql/my.cnf:/etc/mysql/my.cnf ... |
Le code lie ~/laravel-web/mysql/my.cnf à /etc/mysql/my.cnf dans le conteneur. Le fichier lié correspond aux fichiers de configuration MySQL que nous créerons à l'Étape 7.
Le conteneur doit utiliser le serveur Nginx pour servir le code de votre application. Par conséquent, nous allons définir deux montages bind (un pour le fichier de configuration Nginx et un pour le code de l'application) sous le service webserver à cet effet. Ajoutez l'extrait de code suivant pour la définition des volumes sous le service webserver :
|
1 2 3 4 5 6 7 8 |
#Service Nginx webserver: ... volumes: - ./:/var/www/html/ - ./nginx/conf.d/:/etc/nginx/conf.d/ networks: - app-network |
Cette ligne – ./:/var/www/html lie le code de l'application dans le répertoire ~/laravel-web au répertoire /var/www/html à l'intérieur du conteneur. Pour le second montage de type bind, un fichier de configuration pour Nginx sera créé dans ~/laravel-web/nginx/conf.d/. Il sera monté sur /etc/nginx/conf.d/ à l'intérieur du conteneur. Par conséquent, vous pouvez mettre à jour le fichier de configuration sur la machine hôte selon vos besoins. Nous créerons le fichier de conf Nginx à l' Étape 6.
Pour que les modifications du code se reflètent automatiquement dans le conteneur, nous lions le code de l'application au conteneur par un montage de type bind. Cela accélère le processus de déploiement. Ainsi, ajoutez l'extrait de code mis en évidence suivant au service app :
|
1 2 3 4 5 6 7 8 |
#Service PHP app: ... volumes: - ./:/var/www/html/ - ./php/laravel.ini:/usr/local/etc/php/conf.d/laravel.ini networks: - app-network |
La deuxième ligne lie un fichier de configuration PHP, que nous créerons à l' Étape 5 dans le fichier ~/laravel-web/php/laravel.ini vers /usr/local/etc/php/conf.d/laravel.ini à l'intérieur du conteneur.
Votre fichier Docker Compose complet devrait maintenant ressembler à ceci :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 |
version: '2.0' services: #Service PHP app: build: context: . dockerfile: Dockerfile image: cloudsigma.com/php container_name: app restart: unless-stopped tty: true environment: SERVICE_NAME: app SERVICE_TAGS: dev working_dir: /var/www/html/ volumes: - ./:/var/www/html/ - ./php/laravel.ini:/usr/local/etc/php/conf.d/laravel.ini networks: - app-network #Service Nginx webserver: image: nginx:alpine container_name: webserver restart: unless-stopped tty: true ports: - "80:80" - "443:443" volumes: - ./:/var/www/html/ - ./nginx/conf.d/:/etc/nginx/conf.d/ networks: - app-network #Service MySQL db: image: mysql:5.7.32 container_name: db restart: unless-stopped tty: true ports: - "3306:3306" environment: MYSQL_DATABASE: laravel_web MYSQL_ROOT_PASSWORD: remplacer_mot_de_passe_root_mysql SERVICE_TAGS: dev SERVICE_NAME: mysql volumes: - dbdata:/var/lib/mysql/ - ./mysql/my.cnf:/etc/mysql/my.cnf networks: - app-network #Réseaux Docker networks: app-network: driver: bridge #Volumes volumes: dbdata: driver: local |
Si tout semble correct, appuyez sur Ctrl + O pour enregistrer le fichier. Ensuite, appuyez sur Ctrl + X pour quitter l'éditeur. À ce stade, vous devriez être en mesure de créer une image Docker personnalisée pour votre application à l'aide du fichier Docker Compose.
Étape 4 : Créer le Dockerfile
Le Dockerfile contient des instructions que Docker peut utiliser pour créer des images Docker personnalisées. Il peut également installer les logiciels requis et configurer les paramètres nécessaires pour votre application. Ils spécifient l'environnement à l'intérieur d'un conteneur qui hébergera le code de votre application. Vous pouvez pousser les images que vous créez vers docker hub pour les partager ou les placer sur d'autres registres privés.
Nous allons créer un Dockerfile qui spécifiera les instructions pour construire l'image de l'application Laravel. Utilisez nano pour créer le Dockerfile dans le répertoire ~/laravel-web :
|
1 |
nano ~/laravel-web/Dockerfile |
Dans l'éditeur ouvert, ajoutez le code suivant :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
FROM php:7.4-fpm # Copier composer.lock et composer.json dans le répertoire de travail COPY composer.lock composer.json /var/www/html/ # Définir le répertoire de travail WORKDIR /var/www/html/ # Installer les dépendances pour le système d'exploitation RUN apt-get update && apt-get install -y \ build-essential \ libpng-dev \ libjpeg62-turbo-dev \ libfreetype6-dev \ locales \ zip \ jpegoptim optipng pngquant gifsicle \ vim \ libzip-dev \ unzip \ git \ libonig-dev \ curl # Vider le cache RUN apt-get clean && rm -rf /var/lib/apt/lists/* # Installer les extensions pour php RUN docker-php-ext-install pdo_mysql mbstring zip exif pcntl RUN docker-php-ext-configure gd --with-freetype --with-jpeg RUN docker-php-ext-install gd # Installer composer (gestionnaire de paquets php) RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer # Copier le contenu du répertoire de l'application existante dans le répertoire de travail COPY . /var/www/html # Attribuer les permissions du répertoire de travail à l'utilisateur www-data RUN chown -R www-data:www-data \ /var/www/html/storage \ /var/www/html/bootstrap/cache # Exposer le port 9000 et démarrer le serveur php-fpm (pour FastCGI Process Manager) EXPOSE 9000 CMD ["php-fpm"] |
Le Dockerfile crée d'abord une image basée sur l'image Docker php:7.4-fpm. Il s'agit d'une image basée sur Debian avec l'implémentation PHP FastCGI (PHP-FPM) installée. Pour que Laravel fonctionne correctement, il nécessite d'autres extensions PHP comme mcrypt, pdo_mysql, mbstring et imagick, que le script installe. Il installe ensuite le gestionnaire de paquets PHP composer. Le conteneur l'utilisera pour installer les dépendances PHP de Laravel.
Vous pouvez utiliser la directive RUN pour définir des commandes telles que l'installation, la mise à jour et la configuration des paramètres à l'intérieur du conteneur. Elle attribue également des permissions d'utilisateur. La directive WORKDIR spécifie le répertoire de travail, /var/www/html dans ce cas. Le script exécute la commande CHOWN pour attribuer les permissions du répertoire /var/www/html à l'utilisateur www-data.
Avant de construire définitivement l'image, un port doit être exposé pour permettre l'accès à l'application s'exécutant à l'intérieur du conteneur. La commande EXPOSE expose un port, 9000, pour le serveur php-fpm. La commande finale à exécuter est la directive CMD. Elle lance php-fpm pour démarrer le serveur.
Vous pouvez maintenant appuyer sur Ctrl + O pour enregistrer le fichier. Ensuite, appuyez sur Ctrl + X pour quitter l'éditeur.
Étape 5 : Configurer PHP
Dans cette étape, nous allons configurer le service php pour traiter les requêtes entrantes de Nginx. Vous allez créer un fichier laravel.ini dans le répertoire php. Ce fichier contiendra les configurations PHP. C'est le fichier que vous aviez monté par liaison (bind-mounted) sur /usr/local/etc/php/conf.d/laravel.ini dans le conteneur à l'Étape 3. Les configurations de ce fichier remplacent le fichier php.ini par défaut généralement lu par PHP au démarrage. Entrez la commande suivante pour créer le répertoire php :
|
1 |
mkdir ~/laravel-web/php |
Créez et ouvrez le fichier laravel.ini dans le répertoire php en entrant la commande suivante :
|
1 |
nano ~/laravel-web/php/laravel.ini |
Le fichier php.ini par défaut a une limite de téléchargement définie à 2M. À titre d'exemple, nous allons vous montrer comment ajuster et définir les configurations php en modifiant la valeur de la limite de téléchargement autorisée, au cas où vous souhaiteriez télécharger des fichiers plus volumineux. Entrez les lignes de code suivantes dans le fichier :
|
1 2 |
upload_max_filesize=80M post_max_size=80M |
Cela définit la limite de téléchargement et vous pouvez télécharger des fichiers d'une taille totale ne dépassant pas 80 Mo. Vous pouvez ajouter d'autres configurations php dans le fichier laravel.ini pour remplacer les configurations php par défaut. Maintenant, sauvegardez et fermez le fichier.
Étape 6 : Configurer Nginx
Dans cette étape, nous allons configurer Nginx pour utiliser le service php que nous avons défini précédemment. Il utilisera PHP-FPM comme serveur FastCGI pour servir du contenu dynamique. Le serveur FastCGI est un logiciel qui permet à des programmes interactifs de s'interfacer avec un serveur web.
Comme nous l'avions défini dans le fichier docker-compose à l'Étape 3, nous allons créer le fichier de configuration Nginx app.conf dans le répertoire ~/laravel-web/nginx/conf.d/. Tout d'abord, entrez la commande suivante pour créer le répertoire :
|
1 |
mkdir -p ~/laravel-web/nginx/conf.d |
Ensuite, créez et ouvrez le fichier app.conf à l'aide de nano en entrant la commande suivante :
|
1 |
nano ~/laravel-web/nginx/conf.d/app.conf |
Ajoutez le code de configuration Nginx suivant au fichier :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
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/html/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; } } |
Nginx lit des fichiers de configuration appelés blocs de serveur (server blocks) pour savoir quel répertoire doit être servi à un visiteur du site web en fonction de l'URL. Pour en savoir plus, lisez la configuration des blocs de serveur dans notre tutoriel sur l'installation de Nginx sur Ubuntu 18.04. Les directives définies servent aux fins suivantes :
- listen – Définit le port sur lequel le serveur écoutera les requêtes entrantes, qui est généralement le port 80.
- error_log & access_log – Définit les fichiers pour l'écriture des journaux (logs) de l'application.
- root – Définit le chemin de la racine web (webroot), le répertoire qui servira toute requête adressée au serveur depuis Internet.
Dans le bloc location pour php, la directive fastcgi_pass spécifie que le service app écoute sur un socket TCP sur le port 9000 (qui a été défini dans le Dockerfile). Cela indique au serveur PHP-FPM d'écouter sur le réseau et non sur un socket Unix. Bien qu'un socket Unix puisse présenter un léger avantage en termes de vitesse par rapport à un socket TCP, il ne dispose pas de protocole réseau, évitant ainsi la pile réseau.
Un socket Unix serait plus approprié pour les scénarios où les hôtes sont situés sur une seule machine. Cependant, si vous avez des services s'exécutant sur différents hôtes, un socket TCP présente l'avantage de connecter des services distribués. Dans notre cas, le conteneur de l'application s'exécute sur un hôte différent de celui de notre conteneur de serveur web. Ainsi, un socket TCP est le plus approprié pour notre configuration.
Vous pouvez maintenant appuyer sur Ctrl + O pour enregistrer le fichier, puis sur Ctrl + X pour quitter l'éditeur. Les modifications apportées dans le répertoire nginx/conf.d/ se refléteront automatiquement dans le conteneur du serveur web grâce au montage de type bind que vous avez ajouté dans le fichier Docker Compose à l'Étape 3.
Étape 7 : Configurer MySQL
Après avoir configuré Nginx pour fonctionner avec PHP, nous pouvons maintenant configurer MySQL pour stocker et servir des données dynamiques à PHP. Nous avions déjà configuré le fichier Docker Compose pour installer les extensions nécessaires à la communication entre PHP et MySQL. Nous allons créer le fichier de configuration MySQL my.cnf dans le dossier mysql, qui sera monté par liaison (bind-mounted) sur /etc/mysql/my.cnf comme nous l'avions défini dans la section du service db de Docker Compose à l'Étape 3.
Les paramètres de configuration et les modifications de MySQL peuvent être apportés au fichier my.cnf quand vous le souhaitez. Ils devraient se refléter immédiatement à l'intérieur du conteneur. Tout d'abord, créez le répertoire en saisissant la commande suivante :
|
1 |
mkdir ~/laravel-web/mysql |
Ensuite, créez et ouvrez le fichier avec nano en saisissant la commande suivante :
|
1 |
nano ~/laravel-web/mysql/my.cnf |
Saisissez l'extrait de code suivant pour activer le journal des requêtes (query log) et spécifier l'emplacement du fichier de journalisation :
|
1 2 3 |
[mysqld] general_log = 1 general_log_file = /var/lib/mysql/general.log |
En définissant la propriété general_log sur 1, vous autorisez les journaux généraux. La propriété general_log_file spécifie l'emplacement du fichier de journaux. Appuyez sur Ctrl + O pour enregistrer le fichier, puis sur Ctrl + X pour quitter l'éditeur.
Étape 8 : Définir les variables d'environnement de Laravel
À ce stade, tous les services et paramètres de configuration sont terminés. Ainsi, nous devrions être en mesure de déployer nos conteneurs. Cependant, il reste une étape importante à accomplir avant que notre application web ne soit réellement utilisable – les variables d'environnement. Le framework Laravel attend un fichier nommé .env qu'il utilise pour définir son environnement. Par défaut, Laravel est fourni avec le fichier .env.example que vous pouvez copier vers .env, puis modifier les variables avec vos propres informations. Saisissez la commande suivante pour copier le fichier :
|
1 |
cp .env.example .env |
Une fois copié, ouvrez le fichier à l'aide de nano pour le modifier :
|
1 |
nano .env |
Voici une capture d'écran de ce à quoi le fichier peut ressembler :
Dans le fichier, l'étape suivante consiste à modifier les variables sous le bloc DB_CONNECTION comme vous l'aviez défini dans les configurations précédentes effectuées jusqu'à présent. Mettez à jour comme suit :
- DB_HOST est le db conteneur de base de données.
- DB_DATABASE est le laravel_web.
- DB_USERNAME est le nom d'utilisateur pour la base de données. Choisissez le nom de votre choix, mais pour les besoins de ce tutoriel, prenons laraveldocker.
- DB_PASSWORD est un mot de passe fort que votre utilisateur ci-dessus utilisera pour se connecter à la base de données, choisissez donc un mot de passe robuste. À l'Étape 10, nous créerons cet utilisateur avec le mot de passe que vous choisissez ici.
Une fois les valeurs mises à jour, votre DB_CONNECTION devrait maintenant ressembler à ceci :
Enregistrez et fermez le fichier.
Étape 9 : Exécuter les conteneurs Docker
À ce stade, tous vos services et configurations sont définis dans le fichier Docker Compose. Une seule commande est nécessaire pour démarrer tous les conteneurs, créer les volumes, connecter les réseaux, ainsi que configurer et compiler votre application. Saisissez la commande suivante dans votre terminal :
|
1 |
docker-compose up -d |
Lorsque vous lancez la commande docker-compose up pour la première fois, elle télécharge toutes les images Docker nécessaires. Si vous configurez l'infrastructure sur votre ordinateur local, cela peut prendre un certain temps. Une fois les images téléchargées, Compose crée les conteneurs. Le drapeau -d indique à Docker d'exécuter les conteneurs en arrière-plan. Si le processus se termine avec succès, vous devriez voir quelque chose comme ceci dans votre terminal :
Saisissez la commande suivante dans votre terminal pour lister tous les conteneurs en cours d'exécution :
|
1 |
docker ps |
Il devrait afficher quelque chose de similaire à la capture d'écran ci-dessous, avec des détails sur les conteneurs app, webserver et db :
- CONTAINER ID – Un identifiant unique pour chaque conteneur.
- NAMES – Le nom du service associé à chaque conteneur, tel que défini dans le fichier Docker Compose. (Vous pouvez utiliser soit l'ID du conteneur, soit son nom pour y accéder).
- IMAGE – Le nom de l'image pour chaque conteneur.
- STATUS – Il affiche des informations sur l'état du conteneur (il peut être arrêté, en cours d'exécution ou en cours de redémarrage).
- PORTS – Il indique les ports qu'un conteneur expose.
Docker Compose fournit une commande appelée exec que vous pouvez utiliser pour exécuter des commandes de terminal ou accéder à la ligne de commande à l'intérieur d'un conteneur. Nous voulons d'abord exécuter quelques commandes à l'intérieur du conteneur app, qui est le conteneur exécutant l'application Laravel.
Docker fournit une commande pour accéder à la ligne de commande d'un conteneur. Sa syntaxe est la suivante : docker-compose exec container_name bash. Pour accéder à la ligne de commande du conteneur app, saisissez la commande suivante :
|
1 |
docker-compose exec app bash |
Une fois sur la ligne de commande du conteneur, vous pouvez exécuter des commandes de configuration Laravel Artisan. Saisissez la commande suivante pour générer la clé laravel et l'enregistrer dans le fichier .env :
|
1 |
php artisan key:generate |
Une fois la clé d'environnement définie, vous pouvez exécuter la commande suivante pour mettre en cache les paramètres de configuration :
|
1 |
php artisan config:cache |
Les configurations sont stockées dans le fichier /var/www/html/bootstrap/cache/config.php à l'intérieur du conteneur. Vous pouvez appuyer sur Ctrl + D pour quitter le terminal du conteneur.
Pour confirmer que l'application Laravel a été déployée et fonctionne, visitez l'IP publique de votre serveur dans votre navigateur (http://your_server_public_ip). Vous devriez voir la page d'accueil d'une nouvelle installation de Laravel :
Étape 10 : Configurer un utilisateur MySQL
Dans cette étape, nous allons créer un utilisateur de base de données pour la base de données MySQL laravel_web que nous avons spécifiée dans le fichier docker-compose. Lorsque vous avez exécuté la commande de construction du conteneur à l'Step 9, MySQL a été installé, mais a seulement créé un compte d'administration root par défaut, qui se trouve avoir des privilèges illimités sur la base de données. Pour éviter d'utiliser l'utilisateur root, nous allons créer un utilisateur dédié, laraveldocker, à utiliser pour l'application. C'est l'utilisateur que vous avez spécifié dans les variables d'environnement à l'Step 8. Accédez à la ligne de commande à l'intérieur du terminal en saisissant la commande suivante :
|
1 |
docker-compose exec db bash |
Une fois à l'intérieur du conteneur, connectez-vous à MySQL en saisissant la commande suivante :
|
1 |
mysql -u root -p |
À l'invite de mot de passe, saisissez le mot de passe que vous avez défini dans le service db du fichier docker-compose à l'Step 2.
Une fois connecté à l'invite MySQL, vérifiez si vous pouvez voir la base de données que vous avez spécifiée dans le fichier docker-compose en saisissant la commande SQL suivante :
|
1 |
show databases; |
Vous devriez voir la base de données laravel_web, ou le nom que vous avez spécifié pour votre configuration :
Ensuite, nous créons un utilisateur et un mot de passe pour la base de données laravel_web. Ce doivent être les mêmes informations que celles que vous avez spécifiées dans le fichier .env à l'Step 8. Saisissez la commande suivante pour créer l'utilisateur et le mot de passe, et accorder tous les privilèges à cet utilisateur :
|
1 |
GRANT ALL ON laravel_web.* TO 'laraveldocker'@'%' IDENTIFIED BY 'your_strong_laravel_docker_password'; |
Pour que les modifications prennent effet immédiatement, saisissez la commande suivante pour vider les privilèges :
|
1 |
FLUSH PRIVILEGES; |
Ceci termine la configuration de l'utilisateur MySQL. Quittez l'invite MySQL en tapant exit et en appuyant sur Entrée. Enfin, quittez le conteneur db en appuyant sur Ctrl + D.
Étape 11 : Tester la communication entre le code de l'application Laravel et la base de données MySQL
Jusqu'à cette étape, tout a bien fonctionné. Cependant, nous voulons confirmer que le code Laravel dans le conteneur app peut communiquer avec la base de données MySQL dans le conteneur db. Tout d'abord, accédez au terminal du conteneur app en saisissant la commande suivante :
|
1 |
docker-compose exec app bash |
L'étape suivante consiste à exécuter la commande migration Laravel qui crée les tables :
|
1 |
php artisan migrate |
Vous devriez voir le processus de migration dans votre terminal à mesure que Laravel crée les tables par défaut :
Ensuite, nous allons tester si nous pouvons accéder à la base de données depuis Laravel. Laravel est livré par défaut avec Tinker par défaut, ce qui vous permet d'interagir avec l'ensemble de l'application depuis la ligne de commande, y compris l'accès à la base de données, l'exécution de tâches, l'ORM Eloquent, et plus encore. Nous pouvons utiliser Tinker pour afficher les données de la table migrations. Saisissez la commande suivante pour accéder à Tinker :
|
1 |
php artisan tinker |
Une fois sur l'invite Tinker, vous pouvez lister les tables créées par la commande migrate en saisissant ce qui suit :
|
1 |
\DB::select('show tables'); |
La capture d'écran ci-dessous montre la sortie, qui correspond aux tables actuellement présentes dans la base de données laravel_web :
Vous pouvez récupérer les données d'une table en spécifiant le nom de la table. Par exemple, vous pouvez récupérer les données de la table migrations en saisissant la commande suivante :
|
1 |
\DB::table('migrations')->get(); |
La commande affiche la sortie suivante :
D'après la sortie ci-dessus, votre application Laravel est bien configurée et peut communiquer avec la base de données. Vous pouvez expérimenter d'autres commandes comme la création de modèles, l'exécution de tâches, et plus encore. Vous pouvez quitter l'invite Tinker en appuyant sur Ctrl + D.
Conclusion
Dans ce tutoriel, vous avez déployé une application Laravel avec une pile LEMP dans un conteneur Docker. Vous avez testé l'application en accédant à l'interface web ainsi qu'en vous connectant à la base de données via Laravel Tinker. Vous avez pu découvrir la puissance de Docker Compose. Il vous permet de créer un groupe de conteneurs Docker définis dans un seul fichier, qui peuvent ensuite être exécutés avec une seule commande.
Si vous souhaitez vous familiariser davantage avec les conteneurs, jetez un œil à notre tutoriel qui vous montre comment nettoyer les ressources Docker – images, conteneurs et volumes et à notre présentation détaillée de l'outil Kubernetes.
Vous pouvez également visiter notre blog pour en savoir plus sur Docker et l'intégration continue et le déploiement continu.
Bon développement !
Commentaires
Aucun commentaire pour l'instant. Soyez le premier.