Docker : découverte et environnement LAMP pour WordPress

Vous avez sûrement déjà entendu parler de Docker, si ce n'est déjà utilisé.

Docker peut considérablement vous simplifier la vie, sécuriser, harmoniser votre environnement de développement ou de production, ainsi que faciliter le travail en équipe... après l'avoir apprivoisé.

Le plan de ce tutoriel :

1. construire un environnement LAMP (Linux-Apache-Mysql-PHP) complet, identique ou proche de celui qui se retrouvera en production chez un hébergeur web
2. comprendre le fonctionnement de Docker grâce à ce prétexte pour le perfectionner ou l'utiliser dans d'autres conditions

À la fin de cette page vous serez comme ça.

Contexte

Docker n'est pas une machine virtuelle ; c'est une technologie qui orchestre des applications en conteneurs (containerisées), embarquant chacune leurs dépendances, en fonctionnant de manière isolée tout en pouvant partager des ressources et communiquer.

Même si on peut le percevoir comme une autre recette accroissant la hauteur du burger full-stack, s'y intéresser vaut le détour.

🥝 Chez Alsacréations nous avons, après de multiples expérimentations, structuré notre propre environnement pour les projets WordPress autour de WordPlate + MySQL/MariaDB dans Docker. Cela nous permet d'avoir un modèle propre, organisé, testé, éprouvé, documenté, pour tout nouveau projet de site. #pub Si vous avez besoin d'une équipe à la pointe pour votre nouveau site ou votre refonte, contactez-nous ;) (PS : on aime aussi Vue et Nuxt).

(Illustration : Docker.com)

Étapes

Lorsqu'on découvre Docker, le plus mystérieux n'est pas son fonctionnement interne. Il faut avant tout cerner la logique des quelques opérations de base :

1. choisir une image (par exemple le serveur web Apache)
2. compiler l'image (bonus : ajouter une petite configuration personnelle)
3. exécuter le conteneur correspondant à cette image
4. s'y connecter

Cette introduction est destinée à en présenter les concepts pour une prise en main rapide pour un cas simple : développer un site web (avec WordPress en option) sans avoir à installer et configurer Apache, PHP, MySQL sur sa machine ou une solution qui les regroupe telle que WAMP, MAMP, XAMPP, etc. et que l'on n'ose plus toucher ultérieurement "tant que ça marche".

Le même principe est applicable à d'autres configurations et langages (Java, Python, Node, Redis, PostgreSQL, Nginx, MongoDB...)

Avantages

Identifions tout de suite les avantages majeurs de Docker :

• la configuration étant définie par un fichier, elle peut être versionnée dans un projet et partagée entre toutes les personnes y participant
• la configuration étant définie très précisément et de manière compacte, elle permet à toutes et tous d'obtenir exactement le même environnement, ce qui évite le fameux "chezmoicamarche.org"
• cela permet de faire cohabiter plusieurs environnements radicalement différents et indépendants, à la demande, pour chaque projet (ex : on utilise LAMP, puis on éteint et on allume MEAN, puis on rallume LAMP)
• on peut facilement changer d'application ou de version d'application (ex: de version de PHP, remplacer Mysql par MariaDB) sans avoir à tout réinstaller
• toutes les personnes participant à un projet n'ont pas besoin de connaître Docker
• c'est propre, c'est multi-plateforme, c'est le 21e siècle et quart

Performance

Sans entrer dans les détails techniques, il ne s'agit pas d'émulation et il n'y a pas de comparaison possible avec VirtualBox ou VmWare. La performance de Docker selon le système utilisé est :

• Optimale sur Linux car quasi-native en utilisant le kernel (noyau) et les ressources directes : performances extrêmement proches voire identiques à du natif (bare metal). C'est son usage principal pour un hébergement en production.
• Moins optimale sur Windows et macOS car il y a invocation nécessaire d'un sous-système Linux, mais c'est amplement suffisant pour développer.

Si le poids des images (des applications) varie selon leur complexité, on reste loin d'une machine virtuelle complète : à partir de quelques Mo car pouvant être construites grâce à Alpine Linux, une distribution très légère (~5 Mo)... jusqu'à quelques centaines de Mo.

Fonctionnement

Docker est articulé autour de plusieurs concepts, qu'il n'est pas nécessaire de maîtriser pleinement pour commencer à s'en servir :

• Docker Daemon : le chef d'orchestre de l'ombre
• L'interface en ligne de commande (CLI) : pour piloter l'ensemble
• L'interface graphique Docker Desktop : pour piloter de manière plus agréable visuellement (optionnel pour les puristes)
• Les conteneurs (containers en VO) : vos applications (dans notre cas : un container Apache, un container PHP, un container MySQL, un container phpmyadmin)
• Les images Docker : les modèles pour construire les conteneurs
• Une API REST

Si vous installez Docker sur votre machine, vous retrouverez la commande docker dans votre Terminal (CLI) quoiqu'il arrive.

Toutes les opérations sont décrites en ligne de commande mais une fois vos containers en place vous pouvez les démarrer/arrêter en un clic avec l'interface graphique ou l'extension Visual Studio Code.

Qu'est-ce qu'une image Docker ?

Une image est un modèle d'application, préconfigurée, embarquée dans un mini-système Linux. Docker Hub liste toutes les images disponibles publiquement au téléchargement https://hub.docker.com/search?q=&type=image ; chacune étant nommée image:tag, avec tag représentant une version, ou une déclinaison particulière.

Exemples :

• alpine:latest (dernière version disponible d'Alpine Linux)
• alpine:3.13 (une version précise)
• php:7.4-apache (PHP 7.4 tournant avec Apache)
• php:8-fpm-alpine (PHP 8 en mode FPM au-dessus d'Alpine Linux)

L'image hello-world est une petite image de démonstration qui ne fait qu'afficher un message de bienvenue, pratique pour les premiers tests :

• Récupérer une image existante se fait avec la commande pull, par exemple : docker pull hello-world:latest

• Exécuter cette image dans un conteneur se fait avec run : docker run hello-world

Si on tente un run directement sans avoir pull ou sans avoir déjà une image en stock, le pull est déclenché automatiquement. On en profite.

Si on possède Docker Desktop (Windows, Mac) ou Dockstation (Linux), l'image apparaît dans le "stock" disponible en local.

L'image est notée comme étant in use (utilisée) par un un conteneur qui a aussi été créé pour l'occasion (avec un nom aléatoire) :

On peut aussi se renseigner en ligne de commande avec docker image ls

$ docker image ls
REPOSITORY    TAG       IMAGE ID       CREATED       SIZE
hello-world   latest    feb5d9fea6a5   2 weeks ago   13.3kB

À noter : lorsqu'une image a été téléchargée pour être exécutée, elle reste disponible en local. On peut nettoyer cette liste par la suite en se débarrassant des conteneurs associés : docker container prune (supprime les conteneurs inactifs) puis docker image rm hello-world.

Il y a toujours cette dualité : un conteneur ne peut exister l'image qui lui a donné naissance.

Qu'est-ce qu'un conteneur ?

Cette première étape est déjà bien motivante : on peut rapidement télécharger-exécuter une application avec les avantages de base de Docker. Lançons notre premier serveur web Apache avec PHP : docker run -p 80:80 php:7.4-apache (les noms disponibles peuvent être trouvés dans la section tags du hub Docker).

L'option -p 80:80 signifie que l'on fait correspondre le port http local à celui exposé par le conteneur (sinon on ne pourra s'y connecter, tout étant bloqué par défaut).

Et maintenant ? En se rendant à l'adresse http://localhost/ il y a une réponse du serveur... avec une erreur du type 403 Forbidden car aucun fichier n'est encore prêt à être servi. Mais nous avons bien un serveur web Apache qui tourne, équipé de PHP (croyons-le sur parole) après une seule ligne de commande. 🎊

Il reste maintenant à peaufiner la configuration, déterminer l'accès aux bons fichiers (du site web) et compléter par MySQL dans le cadre de cette introduction.

Dockerfile ?

Il est possible de créer ses propres images, à partir de briques déjà existantes (telles que celle utilisée précédemment php:7.4-apache), complétées par des instructions de configuration.

Un Dockerfile est un fichier texte qui va dans un premier temps invoquer une image de base, avec l'instruction FROM puis dérouler d'autres commandes propres à Docker dont la liste est présentée ci-dessous. En voici un exemple relativement parlant (surtout si vous êtes familier de la ligne de commande Linux).

# Image de base
FROM php:7.4-apache
# Port ouvert (web = 80)
EXPOSE 80
# Dossier de travail pour les commandes suivantes
WORKDIR /var/www/html

# Installation initiale de modules apache et php
RUN a2enmod headers deflate expires rewrite
RUN docker-php-ext-install mysqli

# Redémarrage d'Apache pour prendre en compte ces modifications
RUN apachectl restart

L'image obtenue nous permettra d'avoir désormais en plus : des modules Apache (headers, deflate, expires, rewrite) et un module mysqli pour PHP.

Une dizaine d'instructions existent : https://docs.docker.com/engine/reference/builder/ entre autres :

• FROM Définit l'image source (FROM php:7.4-cli).
• ENV Définit une variable d'environnement à la compilation et à l'exécution (ENV MY_VAR=kiwi).
• LABEL Ajoute une métadonnée à l'image.
• WORKDIR Définit le dossier de travail pour les commandes suivantes (WORKDIR /var/www/html).
• RUN Exécute une commande à la compilation (RUN echo Hello).
• CMD Exécute une commande dans le conteneur (CMD [ "php", "./your-script.php" ]).
• EXPOSE Informe Docker que le conteneur écoute sur un port (EXPOSE 80 ou EXPOSE 80/tcp).
• COPY Copie des fichiers/répertoires depuis une source vers le filesystem de l'image. --chown modifie les droits à la volée.
• ADD Ajoute des fichiers/répertoires (y compris depuis une URL ou une extraction tar) dans le filesystem de l'image (ADD test.txt dir/). --chown modifie les droits à la volée.
• VOLUME Crée un point de montage (VOLUME /myvol).
• ENTRYPOINT Configure un conteneur comme un exécutable.
• USER Définit l'id utilisateur (UID) et groupe (GID) à utiliser lorsque l'image s'exécute et pour toute instruction suivante (RUN, CMD, ENTRYPOINT).
• ARG Définit une variable que l'on peut passer au moment de la compilation avec --build-arg <varname>=<value>.

Compiler sa propre image Docker (apache/php)

La commande build compile une nouvelle image à partir de paramètres (et dans la plupart des cas d’une autre image racine) décrits par la “recette” Dockerfile : docker build -t monserveurweb . Le point final signifie que le fichier Dockerfile se trouve dans le dossier courant.

L'image apparaît ensuite dans la liste des images disponibles, que ce soit en ligne de commande avec docker image list ou dans le client graphique Docker.

Lancer le conteneur avec docker run

Pour lancer le conteneur correspondant, on utilisera docker run (ou l'interface graphique) à partir d’un nom d'image, par exemple docker run monserveurweb.

(Il ne faut pas faire attention ici aux warnings, c'est logique et propre à Apache car on ne lui a pas indiqué de configuration particulière)

Pour éviter d'avoir un nom généré aléatoirement, on pourra le nommer docker run --name mon-serveur-web monserveurweb. et relancer cette commande autant de fois que nécessaire.

On constate alors que ce nouveau couple image/conteneur :

• sera facile à “installer” et opérationnel quelques secondes après le téléchargement
• sera “isolé” des autres applications
• pourra tout de même accéder au système de fichiers de l’hôte (= volumes), au réseau (exposer un port par exemple 80 pour le web, 3306 pour mysql, ou communiquer avec l’extérieur)
• peut être achevé avec docker container stop mon-serveur-web et supprimé avec docker container rm mon-serveur-web lorsqu'on n'en a plus besoin, puis invoqué à nouveau plus tard, etc.

La commande docker run peut comporter un certain nombre de paramètres pour indiquer dans quelles conditions exécuter l’application (volumes de données, ports, droits, etc).

Ports

Chaque conteneur peut exposer (EXPOSE) des ports du conteneur vers l’extérieur (l’hôte) : -p 8000:80 signifie que le conteneur "publie" son port 80 "natif" vers le port 8000 et que le navigateur peut s'y connecter sur http://localhost:8000 s'il est sur la même machine. Dans notre exemple initial nous avions 80:80, si votre port 80 est déjà occupé par une autre application rien ne vous empêchera d'en choisir librement un autre. Chaque conteneur Apache invoqué pourra donc vivre sur son port 80 naturellement sans avoir besoin d'être configuré autrement.

Link (lien)

Un lien permet de lier, ou plutôt de rendre visibles des conteneurs entre eux, par des noms choisis, sur leurs réseaux respectifs : --link db:mysql (plus de détails à venir dans la partie compose).

Volumes

Un volume est un "partage" d’un dossier local (machine hôte = votre système Linux/Windows/Mac) avec le conteneur. Il peut aussi provenir d’un service distant (ssh, s3…). Ce n’est pas une copie, c’est une synchronisation réelle sur le disque. Conteneur et hôte peuvent lire et écrire dans cet emplacement : pratique pour conserver les données utiles hors du conteneur lorsqu'il est arrêté/détruit.

Exemples : -v C:\www\mysql:/var/lib/mysql (car dans un conteneur mysql ou mariadb, les données des bases sont par défaut dans /var/lib/mysql) ou -v /var/www/wordpress/public:/var/www/html (car dans un conteneur apache, les fichiers sont cherchés par défaut dans /var/www/html)

On place le chemin local à gauche du séparateur : et le chemin dans le conteneur à droite local:conteneur

Pour finir, une commande plus complète pourrait donner ceci :

docker run
-v c:\www\docker\wordpress:/var/www/html
-p 80:80
# -p 8000:80 (si on a besoin de changer le port)
# --link mysqlserver:db (on ne peut pas encore faire ça, voir ci-dessous)
monserveurweb
# ou php:7.4-apache

Cela signifie que les fichiers de votre site web (WordPress ou autre, en HTML statique ou PHP) devront être placés dans le chemin mentionné (ici c:\www\docker\wordpress) pour qu'Apache puisse les trouver et afficher la page d'installation.

Ajouter un container MySQL (ou MariaDB)

Nous avons le serveur web, il nous faut ajouter la base de données MySQL (ou MariaDB).

On peut là aussi démarrer rapidement un serveur à partir de docker run et nous n'aurons pas besoin de Dockerfile car l'image de base fournie mysql/mysql-server par https://hub.docker.com/r/mysql/mysql-server/ ne sera pas modifiée.

Une petite différence avec l'image d'Apache : nous aurons tout de même besoin d'une variable d'environnement car MySQL nécessite d'être initialisé avec un mot de passe ; au choix :

• -e MYSQL_ROOT_PASSWORD=azertybaïdjan (explicite, mot de passe "en dur")
• -e MYSQL_RANDOM_ROOT_PASSWORD=yes (mot de passe aléatoirement généré la première fois : retrouvez-le dans les logs du container, attention il faut le noter car il disparaît ensuite)

Voici la commande complète :

docker run
--name mysqlserver
# --restart always (si on veut le redémarrer automatiquement)
-p 3306:3306
-v $PWD/mysql:/var/lib/mysql
-e MYSQL_ROOT_PASSWORD=azertybaïdjan
mysql/mysql-server

Ici le port 3306 standard est exposé vers l'extérieur, et $PWD signifie "dossier courant" : ce n'est pas forcément disponible sous Windows où il faudra spécifier le chemin complet (c:...)

Si on oublie le volume (option -v) alors les données seront stockées dans le conteneur et effacées avec lui. Attention Dino Danger.

Variables d'environnement

L'option -e passe une variable d’environnement (existe déjà nativement sous Windows, macOS, Linux) au conteneur, souvent pour le pré-configurer.

• Pour le serveur MySQL : -e MYSQL_ROOT_PASSWORD=****** -e MYSQL_DATABASE=db -e MYSQL_USER=user

• Pour phpmyadmin : -e UPLOAD_LIMIT=128M -e PMA_HOST=db

Ces variables sont données par la documentation officielle, exemple pour PhpMyAdmin : https://hub.docker.com/r/phpmyadmin/phpmyadmin/

Nous devons adapter la commande run du conteneur apache pour qu'il puisse utiliser un lien vers le conteneur de la base.

docker run --name mon-serveur-web -v c:\www\docker\wordpress:/var/www/html -p 80:80 --link mysqlserver:db monserveurweb

Le nom du serveur (host, hostname) à indiquer pour un script PHP souhaitant se connecter à MySQL, ou pour l'installation de WordPress, deviendra "db".

Ajouter un container phpmyadmin

Tout cela est bien beau, avec phpmyadmin pour administrer le serveur c'est encore mieux.

Lançons docker run --name pma --link mysqlserver:db -p 8080:80 -e PMA_HOST=db -e UPLOAD_LIMIT=128M phpmyadmin

Toutes les options ont déjà été décrites précédemment, la nouveauté est l'usage de --link qui va indiquer que lorsque phpmyadmin tentera de se connecter au serveur nommé "db" (précisé par PMA_HOST), cela pointera en réalité vers l'IP interne du conteneur nommé "mysqlserver".

Nous pouvons nous y connecter via http://localhost:8080/ comme on peut le deviner avec l'option -p utilisée.

Bilan, aller plus loin avec docker-compose

Après cette mise en place, un constat : tous ces conteneurs sont bien pratiques, il nous a suffi de quelques instructions pour aboutir à un environnement complet, modulaire :

Tous les ports ouverts sont indiqués, ainsi que par la commande docker container ls.

Une fois qu'on maîtrise ce principe, toutes les autres images Docker sont à portée de pull + run.

il nous faudrait ~~un anneau~~ une magie supplémentaire pour tous les gouverner... plutôt que de manipuler la ligne de commande pour chacun d'entre eux : cela fera l'objet d'un prochain tutoriel.

Volumes et principes à respecter

Un conteneur est surtout le code d’application, ne devrait pas détenir les données du projet (ex : la base SQL, les uploads).

Tant qu'on utilise les volumes qui partagent les fichiers du système hôte (votre machine) dans un dossier précis, on conservera les données utiles “en dehors” du conteneur s'il est détruit.

Un conteneur détruit pourra être remplacé par un autre (ex : une nouvelle version de l'application) tout en accédant au volume des données qui a été préservé. C'est une philosophie : séparer proprement, et se préparer au pire, permettent d'aborder les risques plus sereinement.

Vous pourrez par exemple

• passer d'une version de gitlab à l'autre (gitlab-ee édition payante vers gitlab-ce édition gratuite)
• remplacer mysql-server par mariadb, son "équivalent" beaucoup plus libre
• tester vos fichiers web avec différentes versions de PHP et upgrader progressivement un vieux développement de PHP5 vers PHP7 puis PHP8

Alpine Linux

Un mot rapide sur Alpine Linux : c'est une distribution Linux minimaliste qui a été choisie pour la plupart des images Docker en raison de son poids. Si les quelques Mo qui servent de socle sont orientés pour des utilisateurs expérimentés, rien n'empêche de les étoffer par d'autres paquets.

Il n'y a aucune obligation à maîtriser Linux (ou Alpine Linux) pour se servir de Docker. Néanmoins pouvoir exécuter des commandes en accédant au shell du conteneur est pratique pour bien des opérations.

Attach shell

Il y a plusieurs façons d'exécuter un conteneur, la méthode classique est de le laisser tourner en permanence en tâche de fond et de s'y connecter sur un port, par exemple avec un navigateur web pour Apache, mais on peut aussi :

• ouvrir un terminal interactif qui attend les commandes (ici on ouvre accès à un shell dans un container Linux avec -it)

docker run -it alpine /bin/sh

• lui confier une commande précise : le conteneur se lance, exécute la commande et prend fin immédiatement (ici cela liste les fichiers du dossier courant avec la commande ls)

docker run alpine ls -l

• exécuter un cron depuis la machine hôte pour lancer une tâche du conteneur (exemple : export MySQL pour backup)

docker exec -i mysqlserver mysqldump mabase -ulogin -ppassword | gzip >export.sql.gz

Ici mysqlserver est le nom du conteneur et mysqldump mabase -ulogin -ppassword est la commande qui s'exécute dans ce conteneur.

Visual Studio Code

L'extension Docker est fortement recommandée pour se connecter au service Docker (Engine) de la machine et administrer les images et conteneurs, mais aussi, entre autres :

• attacher un shell : ouvre un nouvel onglet de Terminal
• attacher un shell dans Visual Studio Code : ouvre une nouvelle fenêtre permettant de développer “dans” le conteneur, c'est-à-dire accéder à l'arborescence du système de fichiers interne. C'est bien pratique quand on l'utilise régulièrement et cela peut même changer totalement la façon de travailler.
• voir les logs : permet notamment de voir les requêtes HTTP d'un serveur web, ou la procédure de lancement de MySQL

À défaut d'utiliser Docker Desktop, cette extension accomplit les tâches les plus courantes, sans quitter l'éditeur de code.

Astuces

Sous Linux, pour synchroniser l’heure/fuseau horaire de l’hôte à celui du conteneur (sinon il peut y avoir un décalage de 2h en Europe), on peut ajouter un volume -v /etc/localtime:/etc/localtime:ro (ici ro signifie read-only c'est-à-dire lecture seule)

Si le shell par défaut est trop limité, tenter d’exécuter bash s'il est déjà inclus dans l'image, ou on peut l'installer avec un petit apt update && apt install bash etc. Même chose pour l'éditeur vim si vous savez comment en sortir.

Commandes Docker utiles

• Compiler un Dockerfile dans le dossier courant pour créer une image docker build -t <nomimage:tag> .
• Compiler une image en conteneur et l'exécuter docker run --name <nomducontainer> <nomimage:tag> (+ voir autres options)
• Démarrer ou arrêter un container s'il est déjà existant : docker start <nomducontainer> (ou stop)
• Exécuter une commande dans le container : docker container exec -it <nomducontainer> <lacommande> (par exemple bash pour ouvrir un shell)
• Lister tous les containers : docker container ls ou docker ps -a
• Lister toutes les images : docker image ls
• Supprimer un container : docker container rm <nomducontainer>
• Supprimer une image : docker image rm <nomdelimage>
• Utiliser le chemin courant dans une commande docker : $PWD
• Créer un network : docker network create my-custom-net et l'utiliser au run : --network=my-custom-net

Inspection

• Statistiques : docker stats
• Logs : docker logs <nomducontainer>
• Ports ouverts : docker port <nomducontainer>
• Processus : docker top <nomducontainer>
• Différences appliquées : docker diff <nomducontainer>

Options pour Docker run

• -d : permet de détacher l'exécution du container du terminal courant
• -p : permet de lier un port (local:container -p 8080:80)
• -u : permet de spécifier l'utilisateur+groupe d'exécution
• -v : permet de déclarer un volume (local:container -v /var/path/to/mydata/mysql:/var/lib/mysql)
• -e : permet de passer/spécifier une variable d'environnement
• -i : permet d'avoir un terminal interactif (stdin), par exemple pour entrer un mot de passe au prompt (souvent combiné avec t)
• -t : alloue un pseudo-tty
• --link : permet de "lier" un hostname d'un container à un autre (par exemple un serveur mysql dans un 1er container mysqlserver devient --link mysqlserver:db dans le 2e, on utilise alors db)
• --restart always : indique au service Docker de redémarrer le container au boot et de le maintenir actif si Docker est lui-même relancé

Astuces :

• ajouter -m 256m pour limiter la mémoire à 256 Mo
• ajouter--read-only pour que le système de fichiers soit en lecture seule
• suffixer un volume par:ro pour qu'il soit en lecture seule