Comment installer WordPress avec Docker Compose

introduction

WordPress est un site gratuit et open-source Système de gestion de contenu (CMS) construit sur une base de données MySQL avec un traitement PHP. Grâce à son architecture de plug-in extensible et à son système de templates, et au fait que la plupart de ses tâches d’administration peuvent être effectuées via l’interface Web, WordPress est un choix populaire pour créer différents types de sites Web, des blogs aux pages produits en passant par les sites de commerce électronique.

L’exécution de WordPress implique généralement l’installation d’un LAMP (Linux, Apache, MySQL et PHP) ou https://www.digitalocean.com / community / tutorials / digitalocean-community-glossary # lemp [LEMP] (Linux, Nginx, MySQL et PHP), ce qui peut prendre beaucoup de temps. Cependant, en utilisant des outils tels que Docker et Docker Compose, vous pouvez simplifier le processus de configuration de votre pile préférée et d’installation. WordPress. Au lieu d’installer manuellement des composants individuels, vous pouvez utiliser images, qui normalise des éléments tels que les bibliothèques, les fichiers de configuration et les variables d’environnement, et exécute ces images dans containers, des processus isolés s’exécutant sur un système d’exploitation partagé. De plus, en utilisant Compose, vous pouvez coordonner plusieurs conteneurs (par exemple, une application et une base de données) pour communiquer entre eux.

Dans ce tutoriel, vous allez créer une installation WordPress contenant plusieurs conteneurs. Vos conteneurs incluront une base de données MySQL, un serveur Web Nginx et WordPress. Vous sécuriserez également votre installation en obtenant des certificats TLS / SSL avec Let’s Encrypt pour le domaine que vous souhaitez associer à votre site. Enfin, vous allez configurer un https://www.digitalocean.com/community/tutorials/how-to-schedule-routine-tasks-with-cron-and-anacron-on-a-vps [+ cron +] tâche de renouveler vos certificats afin que votre domaine reste sécurisé.

Conditions préalables

Pour suivre ce tutoriel, vous aurez besoin de:

Étape 1 - Définition de la configuration du serveur Web

Avant d’exécuter des conteneurs, nous commencerons par définir la configuration de notre serveur Web Nginx. Notre fichier de configuration inclura des blocs d’emplacement spécifiques à WordPress, ainsi qu’un bloc d’emplacement pour diriger les demandes de vérification Let Encrypt vers le client Certbot pour des renouvellements de certificat automatisés.

Commencez par créer un répertoire de projet pour votre configuration WordPress appelé ++ et accédez à celui-ci:

mkdir  && cd

Ensuite, créez un répertoire pour le fichier de configuration:

mkdir nginx-conf

Ouvrez le fichier avec + nano + ou votre éditeur préféré:

nano nginx-conf/nginx.conf

Dans ce fichier, nous allons ajouter un bloc de serveur avec des directives pour le nom de notre serveur et la racine du document, ainsi que des blocs d’emplacement pour diriger la demande de certificats, le traitement PHP et les demandes d’actifs statiques du client Certbot.

Collez le code suivant dans le fichier. Assurez-vous de remplacer ++ par votre propre nom de domaine:

~ / wordpress / nginx-conf / nginx.conf

server {
       listen 80;
       listen [::]:80;

       server_name  www.;

       index  index.html index.htm;

       root /var/www/html;

       location ~ /.well-known/acme-challenge {
               allow all;
               root /var/www/html;
       }

       location / {
               try_files $uri $uri/ /index.php$is_args$args;
       }

       location ~ \.php$ {
               try_files $uri =404;
               fastcgi_split_path_info ^(.+\.php)(/.+)$;
               fastcgi_pass :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 ~ /\.ht {
               deny all;
       }

       location = /favicon.ico {
               log_not_found off; access_log off;
       }
       location = /robots.txt {
               log_not_found off; access_log off; allow all;
       }
       location ~* \.(css|gif|ico|jpeg|jpg|js|png)$ {
               expires max;
               log_not_found off;
       }
}

Notre bloc de serveur comprend les informations suivantes:

  • Directives: *

  • + listen +: Ceci dit à Nginx d’écouter sur le port + 80 +, ce qui nous permettra d’utiliser le plugin webroot de Certbot pour nos demandes de certificat . Notez que nous n’avons pas encore inclus le port + 443 + - nous mettrons à jour notre configuration pour inclure SSL une fois que nous aurons obtenu nos certificats.

  • + nom_serveur +: Ceci définit le nom de votre serveur et le bloc serveur à utiliser pour les demandes adressées à votre serveur. Assurez-vous de remplacer «++» dans cette ligne par votre propre nom de domaine.

  • + index +: La directive + index + définit les fichiers qui seront utilisés comme index lors du traitement des requêtes adressées à votre serveur. Nous avons modifié l’ordre de priorité par défaut ici, en déplaçant + index.php + devant le signe + index.html + afin que Nginx donne la priorité aux fichiers nommés + index.php + lorsque cela est possible.

  • + root +: notre directive + root + nomme le répertoire racine des requêtes adressées à notre serveur. Ce répertoire, + / var / www / html +, est https://github.com/docker-library/wordpress/blob/07958d19ed465fb7fe50626be740d88a2c2260a7/php7.2/fpm-alpine/Dockerfile#L53 à titre de point de montage] au moment de la construction, consultez les instructions figurant dans notre WordPress Dockerfile. Ces instructions Dockerfile garantissent également que les fichiers de la version WordPress sont montés sur ce volume.

  • Blocs de localisation: *

  • + location ~ / .well-known / acme-challenge +: Ce bloc d’emplacement gérera les requêtes adressées au répertoire + .well-known +, où Certbot placera un fichier temporaire pour valider que le DNS de notre domaine est résolu en notre serveur. Avec cette configuration en place, nous pourrons utiliser le plug-in webroot de Certbot pour obtenir des certificats pour notre domaine.

  • + location / +: dans ce bloc d’emplacement, nous utiliserons une directive + try_files + pour rechercher les fichiers correspondant aux requêtes URI individuelles. Au lieu de renvoyer par défaut un statut + Not Found + 404, nous laisserons le contrôle au fichier + index.php + de WordPress avec les arguments de la requête.

  • + location ~ \ .php $ +: Ce bloc location gérera le traitement PHP et transmettra ces requêtes à notre conteneur + wordpress +. Parce que notre image WordPress Docker sera basée sur la https://github.com/docker-library/php/blob/e63194a0006848edb13b7eff5a7f9d790d679428/7alpine3.9/fpm/Dockerfile [+ php: fpm + image], nous allons également inclure les options de configuration spécifiques au protocole FastCGI dans ce bloc. Nginx nécessite un processeur PHP indépendant pour les requêtes PHP: dans notre cas, ces requêtes seront gérées par le processeur + php-fpm + inclus dans l’image + php: fpm +. De plus, ce bloc d’emplacement inclut des directives, des variables et des options spécifiques à FastCGI qui soumettront les requêtes à l’application WordPress s’exécutant dans notre conteneur + wordpress +, définiront l’index préféré pour l’URI de la requête analysée et l’analyse des requêtes d’URI.

  • + emplacement ~ / \. ht +: Ce bloc gérera les fichiers + .htaccess + car Nginx ne les servira pas. La directive + deny_all + garantit que les fichiers + .htaccess + ne seront jamais servis aux utilisateurs.

  • + location = / favicon.ico,` + location = / robots.txt + : Ces blocs garantissent que les requêtes envoyées à + / favicon.ico` et + / robots.txt + ne seront pas consignées.

  • + emplacement ~ * \. (css | gif | ico | jpeg | jpg | js | png) $ +: ce bloc désactive la journalisation des demandes de ressources statiques et garantit que ces ressources peuvent être mises en mémoire cache, car elles sont généralement coûteuses. servir.

Pour plus d’informations sur le proxy FastCGI, voir Comprendre et mettre en œuvre la proxy FastCGI dans Nginx. Pour plus d’informations sur les blocs de serveur et d’emplacement, voir Comprendre les algorithmes de sélection de bloc de serveur et d’emplacement Nginx.

Enregistrez et fermez le fichier une fois l’édition terminée. Si vous avez utilisé + nano +, faites-le en pressant + CTRL + X +, + Y +, puis + ENTER +.

Avec votre configuration Nginx en place, vous pouvez passer à la création de variables d’environnement à transmettre à vos conteneurs d’application et de base de données au moment de l’exécution.

Étape 2 - Définition des variables d’environnement

Votre base de données et vos conteneurs d’applications WordPress devront avoir accès à certaines variables d’environnement au moment de l’exécution pour que les données de vos applications persistent et soient accessibles à votre application. Ces variables incluent à la fois des informations sensibles et non sensibles: valeurs sensibles pour votre mot de passe MySQL * root * et l’utilisateur et le mot de passe de la base de données de l’application, ainsi que des informations non sensibles pour le nom et l’hôte de la base de données de votre application.

Plutôt que de définir toutes ces valeurs dans notre fichier Docker Compose - le fichier principal contenant des informations sur le fonctionnement de nos conteneurs -, nous pouvons définir les valeurs sensibles dans un fichier + .env + et limiter sa circulation. Cela évitera que ces valeurs ne soient copiées dans nos référentiels de projets et exposées publiquement.

Dans votre répertoire de projet principal, + ~ / +, ouvrez un fichier nommé + .env +:

nano .env

Les valeurs confidentielles que nous définirons dans ce fichier incluent un mot de passe pour notre utilisateur MySQL * root *, ainsi qu’un nom d’utilisateur et un mot de passe que WordPress utilisera pour accéder à la base de données.

Ajoutez les noms et les valeurs de variable suivants au fichier. N’oubliez pas de fournir * vos propres valeurs * ici pour chaque variable:

~ / wordpress / .env

MYSQL_ROOT_PASSWORD=
MYSQL_USER=
MYSQL_PASSWORD=

Nous avons inclus un mot de passe pour le compte administratif * root *, ainsi que notre nom d’utilisateur et mot de passe préférés pour notre base de données d’applications.

Enregistrez et fermez le fichier une fois l’édition terminée.

Étant donné que votre fichier + .env + contient des informations sensibles, vous devez vous assurer que ces informations figurent dans les fichiers + .gitignore + et + .dockerignore + `de votre projet, qui indiquent https://www.digitalocean.com/community. / tutorials / guide d’utilisation de git-a-reference-guide [Git] et Docker quels fichiers * ne doivent pas être copiés dans vos référentiels Git et vos images Docker, respectivement.

Si vous envisagez de travailler avec Git pour le contrôle de version, initialize your current répertoire de travail en tant que référentiel avec + git init +:

git init

Puis ouvrez un fichier + .gitignore +:

nano .gitignore

Ajoutez + .env + au fichier:

~ / wordpress / .gitignore

.env

Enregistrez et fermez le fichier une fois l’édition terminée.

De même, c’est une bonne précaution d’ajouter + .env + à un fichier + .dockerignore +, afin qu’il ne se retrouve pas dans vos conteneurs lorsque vous utilisez ce répertoire comme contexte de construction.

Ouvrez le fichier:

nano .dockerignore

Ajoutez + .env + au fichier:

~ / wordpress / .dockerignore

.env

En dessous, vous pouvez éventuellement ajouter des fichiers et des répertoires associés au développement de votre application:

~ / wordpress / .dockerignore

.env
.git
docker-compose.yml
.dockerignore

Enregistrez et fermez le fichier lorsque vous avez terminé.

Avec vos informations sensibles en place, vous pouvez maintenant définir vos services dans un fichier + docker-compose.yml.

Étape 3 - Définition des services avec Docker Compose

Votre fichier + docker-compose.yml + contiendra les définitions de service de votre configuration. Un service dans Compose est un conteneur en cours d’exécution, et les définitions de service spécifient des informations sur le fonctionnement de chaque conteneur.

À l’aide de Compose, vous pouvez définir différents services pour exécuter des applications contenant plusieurs conteneurs, car Compose vous permet de lier ces services à des réseaux et des volumes partagés. Cela sera utile pour notre configuration actuelle car nous allons créer différents conteneurs pour notre base de données, notre application WordPress et notre serveur Web. Nous allons également créer un conteneur pour exécuter le client Certbot afin d’obtenir des certificats pour notre serveur Web.

Pour commencer, ouvrez le fichier + docker-compose.yml +:

nano docker-compose.yml

Ajoutez le code suivant pour définir votre version du fichier Compose et le service de base de données + db +:

~ / wordpress / docker-compose.yml

version: '3'

services:
 db:
   image: mysql:
   container_name: db
   restart: unless-stopped
   env_file: .env
   environment:
     - MYSQL_DATABASE=
   volumes:
     - dbdata:/var/lib/mysql
   command: '--default-authentication-plugin=mysql_native_password'
   networks:
     - app-network

La définition du service + db + contient les options suivantes:

  • + image +: Ceci indique à Compose quelle image extraire pour créer le conteneur. Nous épinglons les https://github.com/docker-library/mysql/blob/130abae46a3da1adfc1732a08c3a08c70673e20aa5977/8.0/Dockerfile [+ mysql: + image] ici pour éviter les conflits futurs comme le `+ mysql: le dernier + image ' être mis à jour. Pour plus d’informations sur l’identification des versions et sur la prévention des conflits de dépendance, voir la documentation de Docker à l’adresse Dockerfile.

  • + container_name +: Ceci spécifie un nom pour le conteneur.

  • + restart +: Ceci définit la politique de redémarrage du conteneur. La valeur par défaut est + no +, mais nous avons configuré le conteneur pour qu’il redémarre sauf s’il est arrêté manuellement.

  • + env_file +: Cette option indique à Compose que nous souhaitons ajouter des variables d’environnement à partir d’un fichier appelé + .env +, situé dans notre contexte de construction. Dans ce cas, le contexte de construction est notre répertoire actuel.

  • + environment +: cette option vous permet d’ajouter des variables d’environnement, autres que celles définies dans votre fichier + .env +. Nous allons définir la variable + MYSQL_DATABASE + égale à ++ pour donner un nom à notre base de données d’application. Comme il s’agit d’informations non sensibles, nous pouvons les inclure directement dans le fichier + docker-compose.yml +.

  • + volumes +: Ici, nous montons un nom nommé volume appelé + dbdata + dans le répertoire + / var / lib / mysql + du conteneur . C’est le répertoire de données standard de MySQL sur la plupart des distributions.

  • + command +: Cette option spécifie une commande pour remplacer l’instruction CMD par défaut] pour l’image. Dans notre cas, nous allons ajouter une option à la https://dev.mysql.com/doc/refman/8.0/fr/mysqld.html [+ mysqld +]] de l’image Docker, qui démarre le serveur MySQL sur le serveur récipient. Cette option, + - default-authentication-plugin = mysql_native_password +, définit la variable système + - default-authentication-plugin + sur + mysql_native_password +, spécifiant le mécanisme d’authentification devant régir les nouvelles demandes d’authentification adressées au serveur. Depuis PHP et donc notre image WordPress won’t support https://mysqlserverteam.com/upgrading-to-mysql-8-0-default- authentication-plugin-considérations / [Le nouveau défaut d’authentification de MySQL], nous devons faire cet ajustement pour authentifier l’utilisateur de notre base de données d’application.

  • + network +: Ceci spécifie que votre service d’application rejoindra le réseau + app-network +, que nous définirons en bas du fichier.

Ensuite, sous la définition de votre service + db +, ajoutez la définition de votre service d’application + wordpress +:

~ / wordpress / docker-compose.yml

...
 wordpress:
   depends_on:
     - db
   image: wordpress:-fpm-alpine
   container_name: wordpress
   restart: unless-stopped
   env_file: .env
   environment:
     - WORDPRESS_DB_HOST=db:3306
     - WORDPRESS_DB_USER=$MYSQL_USER
     - WORDPRESS_DB_PASSWORD=$MYSQL_PASSWORD
     - WORDPRESS_DB_NAME=
   volumes:
     - wordpress:/var/www/html
   networks:
     - app-network

Dans cette définition de service, nous nommons notre conteneur et définissons une stratégie de redémarrage, comme nous l’avons fait avec le service + db +. Nous ajoutons également des options spécifiques à ce conteneur:

  • + depend_on +: cette option garantit que nos conteneurs commenceront par ordre de dépendance, le conteneur + wordpress + commençant après le conteneur + db +. Notre application WordPress repose sur l’existence de notre base de données d’application et de notre utilisateur. L’expression de cet ordre de dépendance permettra donc à notre application de démarrer correctement.

  • + image +: Pour cette configuration, nous utilisons https://github.com/docker-library/wordpress/blob/07958d19ed465fb7fef6b6fb7fe50626be740d88a2c2260a7/php7.2/fpm-alpine/Dockerfile [+ -fpm-alpine + 'WordPress image ]. Comme discuté dans https://www.digitalocean.com/community/tutorials/how-to-install-wordpress-with-docker-compose#step-1-%E2%80%94-defining-the-web-server- configuration [Étape 1], l’utilisation de cette image garantit que notre application disposera du processeur `+ php-fpm + requis par Nginx pour gérer le traitement PHP. Il s’agit également d’une image + alpine +, dérivée du projet Alpine Linux, qui nous aidera à réduire la taille globale de notre image. Pour plus d’informations sur les avantages et les inconvénients de l’utilisation des images + alpine + et si cela a du sens pour votre application, voir la discussion complète dans la section * Variantes de l’image * du https://hub.docker.com/_ / wordpress [page d’image WordPress de Docker Hub].

  • + env_file +: Encore une fois, nous spécifions que nous voulons extraire des valeurs de notre fichier + .env +, car c’est ici que nous avons défini notre utilisateur et notre mot de passe de base de données d’application.

  • + environment +: Ici, nous utilisons les valeurs que nous avons définies dans notre fichier + .env +, mais nous les affectons aux noms de variable attendus par l’image WordPress: + WORDPRESS_DB_USER + et + WORDPRESS_DB_PASSWORD +. Nous définissons également un + WORDPRESS_DB_HOST +, qui sera le serveur MySQL exécuté sur le conteneur + db + accessible sur le port par défaut de MySQL, + 3306 +. Notre + WORDPRESS_DB_NAME + sera la même valeur que celle spécifiée dans la définition du service MySQL pour notre + MYSQL_DATABASE +: '++ `.

  • + volumes +: nous montons un volume nommé + wordpress + sur le point de montage + / var / www / html + https://github.com/docker-library/wordpress/blob/07958d19ed465fb7fe50626be740d88a2c2260a7/php7.2/ fpm-alpine / Dockerfile # L53 [créé par l’image WordPress]. L’utilisation d’un volume nommé de cette manière nous permettra de partager notre code d’application avec d’autres conteneurs.

  • + network +: ajoutions également le conteneur + wordpress au réseau` + app-network + `.

Ensuite, sous la définition du service d’application + wordpress +, ajoutez la définition suivante pour votre service Nginx + webserver +:

~ / wordpress / docker-compose.yml

...
 webserver:
   depends_on:
     - wordpress
   image: nginx:-alpine
   container_name: webserver
   restart: unless-stopped
   ports:
     - "80:80"
   volumes:
     - wordpress:/var/www/html
     - ./nginx-conf:/etc/nginx/conf.d
     - certbot-etc:/etc/letsencrypt
   networks:
     - app-network

De nouveau, nous nommons notre conteneur et le rendons dépendant du conteneur + wordpress + dans l’ordre de démarrage. Nous utilisons également une image + alpine + - https://github.com/nginxinc/docker-nginx/blob/e5123eea0d29c8d13df17d782f15679458ff899e/mainline/stretch/Dockerfile [+ -alpine + Nginx image].

Cette définition de service comprend également les options suivantes:

  • + ports +: Cela expose le port + 80 + pour activer les options de configuration définies dans notre fichier + nginx.conf + dans le lien: [Étape 1].

  • + volumes +: nous définissons ici une combinaison de volumes nommés et de bind mounts:

  • + wordpress: / var / www / html +: Ceci montera notre code d’application WordPress dans le répertoire + / var / www / html +, le répertoire que nous avons défini en tant que + root + dans notre bloc de serveur Nginx.

  • +. / nginx-conf: / etc / nginx / conf.d +: Ceci liera le répertoire de configuration Nginx de l’hôte au répertoire approprié du conteneur, en veillant à ce que toutes les modifications apportées aux fichiers de l’hôte soient effectuées. reflété dans le conteneur.

  • + certbot-etc: / etc / letsencrypt +: Ceci montera les certificats et clés Let Encrypt pertinents pour notre domaine dans le répertoire approprié du conteneur.

Et encore une fois, nous avons ajouté ce conteneur au réseau + app-network +.

Enfin, sous votre définition + webserver +, ajoutez votre dernière définition de service pour le service + certbot +. Assurez-vous de remplacer l’adresse e-mail et les noms de domaine énumérés ici par vos propres informations:

~ / wordpress / docker-compose.yml

 certbot:
   depends_on:
     - webserver
   image: certbot/certbot
   container_name: certbot
   volumes:
     - certbot-etc:/etc/letsencrypt
     - wordpress:/var/www/html
   command: certonly --webroot --webroot-path=/var/www/html --email  --agree-tos --no-eff-email --staging -d  -d www.

Cette définition indique à Compose d’extraire le https://hub.docker.com/r/certbot/certbot/ [+ certbot / certbot + image] de Docker Hub. Il utilise également des volumes nommés pour partager des ressources avec le conteneur Nginx, y compris les certificats de domaine et la clé dans + certbot-etc + et le code de l’application dans + wordpress +.

Encore une fois, nous avons utilisé + depend_on + pour spécifier que le conteneur + certbot + doit être démarré une fois que le service + webserver + est en cours d’exécution.

Nous avons également inclus une option + command + qui spécifie une sous-commande à exécuter avec la commande + certbot + par défaut du conteneur. La https://certbot.eff.org/docs/using.html#certbot-command-line-options [+ certonly + sous-commande] obtiendra un certificat avec les options suivantes:

  • + - webroot +: Ceci indique à Certbot d’utiliser le plugin webroot pour placer les fichiers dans le dossier webroot aux fins d’authentification. Ce plugin dépend de la méthode de validation HTTP-01, qui utilise une requête HTTP pour prouver que Certbot peut accéder aux ressources. depuis un serveur qui répond à un nom de domaine donné.

  • + - webroot-path +: Ceci spécifie le chemin du répertoire webroot.

  • + - email +: Votre email préféré pour l’enregistrement et la récupération.

  • + - agree-tos +: Ceci indique que vous acceptez les conditions d’utilisation ACME.

  • + - no-eff-email +: Cela indique à Certbot que vous ne souhaitez pas partager votre courrier électronique avec la Electronic Frontier Foundation (EFF). N’hésitez pas à l’omettre si vous préférez.

  • + - staging +: Ceci indique à Certbot que vous souhaitez utiliser l’environnement de transfert de Let Encrypt pour obtenir des certificats de test. L’utilisation de cette option vous permet de tester vos options de configuration et d’éviter les limites possibles des demandes de domaine. Pour plus d’informations sur ces limites, veuillez consulter la documentation rate de Let’Encrypt.

  • + -d +: Cela vous permet de spécifier les noms de domaine que vous souhaitez appliquer à votre requête. Dans ce cas, nous avons inclus ++ et + www. +. Assurez-vous de les remplacer par votre propre domaine.

Sous la définition de service + certbot +, ajoutez vos définitions de réseau et de volume:

~ / wordpress / docker-compose.yml

...
volumes:
 certbot-etc:
 wordpress:
 dbdata:

networks:
 app-network:
   driver: bridge

Notre clé + volumes + de niveau supérieur définit les volumes + certbot-etc +, + wordpress + et + dbdata +. Lorsque Docker crée des volumes, le contenu du volume est stocké dans un répertoire du système de fichiers hôte, + / var / lib / docker / volumes / +, géré par Docker. Le contenu de chaque volume est ensuite monté à partir de ce répertoire dans tout conteneur utilisant le volume. De cette manière, il est possible de partager le code et les données entre les conteneurs.

Le pont réseau défini par l’utilisateur + app-network + permet la communication entre nos conteneurs car ils se trouvent sur le même hôte démon Docker. Cela simplifie le trafic et la communication au sein de l’application, car il ouvre tous les ports entre les conteneurs sur le même réseau de pont sans exposer aucun port au monde extérieur. Ainsi, nos conteneurs + db, '+ wordpress` et` + web server` peuvent communiquer les uns avec les autres et il suffit d’exposer le port + 80 + pour l’accès frontal à l’application.

Le fichier final + docker-compose.yml + ressemblera à ceci:

~ / wordpress / docker-compose.yml

version: '3'

services:
 db:
   image: mysql:
   container_name: db
   restart: unless-stopped
   env_file: .env
   environment:
     - MYSQL_DATABASE=
   volumes:
     - dbdata:/var/lib/mysql
   command: '--default-authentication-plugin=mysql_native_password'
   networks:
     - app-network

 wordpress:
   depends_on:
     - db
   image: wordpress:-fpm-alpine
   container_name: wordpress
   restart: unless-stopped
   env_file: .env
   environment:
     - WORDPRESS_DB_HOST=db:3306
     - WORDPRESS_DB_USER=$MYSQL_USER
     - WORDPRESS_DB_PASSWORD=$MYSQL_PASSWORD
     - WORDPRESS_DB_NAME=
   volumes:
     - wordpress:/var/www/html
   networks:
     - app-network

 webserver:
   depends_on:
     - wordpress
   image: nginx:-alpine
   container_name: webserver
   restart: unless-stopped
   ports:
     - "80:80"
   volumes:
     - wordpress:/var/www/html
     - ./nginx-conf:/etc/nginx/conf.d
     - certbot-etc:/etc/letsencrypt
   networks:
     - app-network

 certbot:
   depends_on:
     - webserver
   image: certbot/certbot
   container_name: certbot
   volumes:
     - certbot-etc:/etc/letsencrypt
     - wordpress:/var/www/html
   command: certonly --webroot --webroot-path=/var/www/html --email  --agree-tos --no-eff-email --staging -d  -d www.

volumes:
 certbot-etc:
 wordpress:
 dbdata:

networks:
 app-network:
   driver: bridge

Enregistrez et fermez le fichier une fois l’édition terminée.

Avec vos définitions de service en place, vous êtes prêt à démarrer les conteneurs et à tester vos demandes de certificat.

Étape 4 - Obtention des certificats SSL et des informations d’identification

Nous pouvons démarrer nos conteneurs avec la commande +docker-compose up + `, qui créera et exécutera nos conteneurs dans l’ordre que nous avons spécifié. Si nos demandes de domaine aboutissent, nous verrons le statut de sortie correct dans notre sortie et les bons certificats montés dans le dossier `+ / etc / letsencrypt / live +

Related