Créez votre site Joomla avec Docker - Partie 2

Fin 2023, j'ai écrit un très long article sur l'utilisation de Joomla avec Docker : Créer votre site Joomla avec Docker - Partie 1.

C'était une introduction pas à pas à Docker et à la création d'un site local basé sur Joomla.

J'y expliquais, longuement, les différentes étapes de la création d'un site, le choix d'un moteur de base de données (MySQL, MariaDB ou PostgreSQL), le choix d'une version précise de Joomla / du moteur de base de données, le type de volumes (le site et la base doivent-ils être conservés en RAM ou sur le disque dur (c'est-à-dire la notion de volumes)) et beaucoup d'autres choses comme le choix du port du site, la création d'un alias (quelque chose comme http://my_project.local au lieu de http://127.0.0.1). Je vous encourage vivement à lire ou relire cet article avant de commencer celui-ci.

Comme Docker et Joomla évoluent rapidement, je vous propose ici de repartir de là où nous en étions et de voir ce qui a changé depuis.

Nous allons aussi pousser l'automatisation un cran plus loin, en exploitant beaucoup plus le concept de makefile et un fichier de configuration appelé .env.

Résultat​

$ make up

UID=$(id -u) GID=$(id -g) docker compose up --detach
[+] Running 33/12
✔ joomla Pulled 16.1s
✔ joomladb Pulled 10.7s

[+] Running 3/3
✔ Network runningjoomlaindocker_default Created 0.0s
✔ Container joomla-db Healthy 31.7s
✔ Container joomla-app Started 31.1s
▋

Voilà tout le déploiement : Docker récupère Joomla, PHP, Apache et MySQL, les relie entre eux, et une minute plus tard le site est accessible dans le navigateur — sans configuration manuelle de la base de données, sans édition de fichiers PHP à la main.

Pourquoi ça fonctionne​

• compose.yaml, .env et makefile forment ensemble un point de configuration unique : un fichier à modifier pour la version de Joomla ou de PHP, un autre pour le numéro de port et le nom du projet, et des cibles make pour que personne n'ait à retenir les incantations docker compose brutes.
• depends_on + healthcheck dans compose.yaml font attendre Joomla jusqu'à ce que la base de données soit réellement prête avant de lancer sa propre installation — plus de crash au démarrage.
• Comme toute la configuration tient dans trois petits fichiers, la même recette passe à l'échelle avec plusieurs projets isolés (versions différentes de Joomla/PHP/MySQL) sur la même machine, comme le montrent les sections Configuration avancée et Démarrer trois projets différents ci-dessous.

Créer les trois fichiers de configuration​

Contrairement à l'article Créer votre site Joomla avec Docker - Partie 1, où j'avais commencé par expliquer quelques concepts avant d'entrer dans le sujet, faisons l'inverse ici : partons des trois fichiers que nous allons utiliser, puis voyons comment ils fonctionnent. N'essayez pas trop de comprendre le contenu des fichiers ; nous y reviendrons plus tard.

Créez les trois fichiers dans un dossier sur votre disque dur pour le moment (par exemple dans /tmp/joomla), afin d'aller vite à l'essentiel : créer un site Joomla avec une seule ligne de commande à exécuter sur votre ordinateur.

Notre fichier d'orchestration : compose.yaml​

Il nous faut un fichier qui explique à Docker comment nous voulons configurer Joomla et, aussi, le type de base de données souhaité.

Notre fichier d'orchestration va également indiquer à Docker que nous voulons que le site Joomla soit persistant, c'est-à-dire que les fichiers soient enregistrés sur notre disque dur. Idem pour la base de données.

Nous devons faire ça pour que, si nous supprimons volontairement le container Docker afin de libérer de la mémoire par exemple, le site Joomla reste sauvegardé sur le disque. Ainsi, la prochaine fois que nous réveillerons notre site, les fichiers et les tables de la base seront restaurés.

Nous allons aussi définir une dépendance (basée sur depends_on et healthcheck) : Joomla doit attendre que le serveur de base de données soit prêt avant de démarrer son installation (en effet, si l'installateur Joomla essaie d'accéder à MySQL avant même que le système soit chargé, notre projet plantera pendant le chargement des containers).

Comme vous le voyez, notre fichier compose.yaml est d'une importance capitale pour bien définir notre projet.

Créez un nouveau dossier (par exemple mkdir /tmp/joomla && cd $_) sur votre disque dur et créez le fichier compose.yaml avec ce contenu :

$ mkdir /tmp/joomla && cd $_▋

name: ${PROJECT_NAME:-your-project-name}?

services:
  joomla:
    image: joomla:${JOOMLA_VERSION:-latest}?
    container_name: ${CONTAINER_PREFIX:-joomla}-app
    restart: always
    ports:
      - ${WEB_PORT:-8080}:80?
    environment:
      - JOOMLA_DB_HOST=joomladb
      - JOOMLA_DB_NAME=${DB_NAME:-joomla}
      - JOOMLA_DB_PASSWORD=${DB_PASSWORD:-examplepass}
      - JOOMLA_DB_USER=${DB_USER:-joomla}
    depends_on:
      joomladb:?
        condition: service_healthy?
    user: ${UID:-1000}:${GID:-1000}?
    volumes:
      - ./joomla_data:/var/www/html?
    networks:
      - joomla_network

  joomladb:
    image: mysql:${MYSQL_VERSION:-latest}
    container_name: ${CONTAINER_PREFIX:-joomla}-db
    restart: always
    ports:
      - ${MYSQL_PORT-:3306}:3306?
    environment:
      - MYSQL_DATABASE=${DB_NAME:-joomla}
      - MYSQL_PASSWORD=${DB_PASSWORD:-examplepass}
      - MYSQL_RANDOM_ROOT_PASSWORD='1'?
      - MYSQL_USER=${DB_USER:-joomla}
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]?
      timeout: 20s
      retries: 10
    user: ${UID:-1000}:${GID:-1000}
    volumes:
      - ./db_data:/var/lib/mysql
    networks:
      - joomla_network

networks:
  joomla_network:

Nous utiliserons un fichier de configuration appelé .env​

Nous allons aussi utiliser un fichier de configuration nommé .env (qui n'est jamais rien de plus qu'un bête dictionnaire de clés - valeurs) pour différencier nos projets.

Créez un deuxième fichier appelé .env avec ce contenu :

CONTAINER_PREFIX=joomla?
DB_NAME=joomla
DB_PASSWORD=examplepass?
DB_USER=joomla
JOOMLA_VERSION=5.2.0-php8.3-apache?
MYSQL_PORT=3306
MYSQL_VERSION=8.4.2?
PROJECT_NAME=running-joomla-in-docker
WEB_PORT=8080?

Utiliser un fichier .env est vraiment pratique : vous n'avez plus besoin de modifier le fichier compose.yaml, qui peut rester standard pour tous vos projets.

Si vous avez besoin de deux sites Joomla ou plus (vous êtes une agence web qui commence à utiliser Docker pour son développement), vous n'aurez à modifier que le fichier .env en changeant le WEB_PORT (chaque projet doit avoir son port unique) et vous mettrez probablement aussi à jour PROJECT_NAME, par exemple avec le nom de votre client.

Simplifions-nous la vie et soyons paresseux ; utilisons un makefile​

Le troisième et dernier fichier que nous allons utiliser s'appelle makefile et il contiendra quelques scripts : nous allons par exemple créer un script appelé up pour construire notre site.

Pour pouvoir utiliser un makefile, le binaire GNU Make doit être installé sur votre machine.

$ which make▋

$ sudo apt-get update && sudo apt-get install make▋

Créez donc un fichier appelé makefile dans votre répertoire courant avec ce contenu :

include .env?

config:
	@UID=$$(id -u) GID=$$(id -g) docker compose config?

down: stop?
	-@UID=$$(id -u) GID=$$(id -g) docker compose down?

log:
	-@UID=$$(id -u) GID=$$(id -g) docker compose logs

reset: down
	-@rm -rf db_data joomla_data?

start:
	@clear?
	@printf "\033[1;33m%s\033[0m\n\n" "To start your site, please jump to http://127.0.0.1:${WEB_PORT}"?
	@printf "\033[1;33m%s\033[0m\n\n" "Go to http://127.0.0.1:${WEB_PORT}/administrator to open your backend."

	@printf "\033[1;104m%s\033[0m\n\n" "Below a summary of your current installation:"

	@printf "\033[1;34m%s\033[0m\n\n" "JOOMLA"
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n" "  * Project name" "${PROJECT_NAME}"
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n" "  * Version" "${JOOMLA_VERSION}"
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n\n" "  * Port" "${WEB_PORT}"

	@printf "\033[1;34m%s\033[0m\n\n" "DATABASE"
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n" "  * Host" "joomla-db"
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n" "  * User name" "${DB_USER}"
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n" "  * Password" "${DB_PASSWORD}"
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n" "  * Database name" "${DB_NAME}"
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n" "  * Version" "${MYSQL_VERSION}"
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n\n" "  * Port" "${MYSQL_PORT}"

stop:
	-@UID=$$(id -u) GID=$$(id -g) docker compose stop

up:
	-@mkdir -p db_data joomla_data?
	@UID=$$(id -u) GID=$$(id -g) docker compose up --detach --build?

Avant de commencer​

Nous sommes prêts. Juste avant de démarrer, vérifiez que vous avez bien les trois fichiers ci-dessous (lancez ls -alh) :

$ ls -alh

total 20K
drwxr-xr-x 2 christophe christophe 4.0K Jan 4 16:10 .
drwxrwxrwt 13 root root 4.0K Jan 4 16:10 ..
-rw-r--r-- 1 christophe christophe 201 Jan 4 16:10 .env
-rw-r--r-- 1 christophe christophe 1.2K Jan 4 16:10 compose.yaml
-rw-r--r-- 1 christophe christophe 1.6K Jan 4 16:10 makefile
▋

Vérifier notre configuration​

En lançant make config (config est une action que nous avons définie dans notre makefile), nous pouvons afficher la configuration de notre projet à l'écran (juste l'afficher, rien n'est exécuté).

$ make config▋

Nous devrions voir beaucoup d'informations techniques commençant par quelque chose comme :

name: running-joomla-in-docker
services:
  joomla:
    container_name: joomla-app
    depends_on:?
      joomladb:
        condition: service_healthy?
        required: true?
    environment:
      JOOMLA_DB_HOST: joomladb
      JOOMLA_DB_NAME: joomla
      JOOMLA_DB_PASSWORD: examplepass
      JOOMLA_DB_USER: joomla
    image: joomla:5.2.0-php8.3-apache
    networks:
      joomla_network: null
    ports:
      - mode: ingress
        target: 80
        published: "8080"
        protocol: tcp
    restart: always
    user: 1002:1002?
    volumes:
      - type: bind
        source: /tmp/joomla/joomla_data?
        target: /var/www/html?
        bind:
          create_host_path: true?
  joomladb:
    container_name: joomla-db
    environment:
      MYSQL_DATABASE: joomla
      MYSQL_PASSWORD: examplepass
      MYSQL_RANDOM_ROOT_PASSWORD: "'1'"?
      MYSQL_USER: joomla
    healthcheck:?
      test:
        - CMD
        - mysqladmin?
        - ping
        - -h
        - localhost
      timeout: 20s?
      retries: 10?
    image: mysql:8.4.2
    networks:
      joomla_network: null
    ports:
      - mode: ingress
        target: 3306
        published: "3306"
        protocol: tcp
    restart: always
    user: 1002:1002
    volumes:
      - type: bind
        source: /tmp/joomla/db_data
        target: /var/lib/mysql
        bind:
          create_host_path: true
networks:
  joomla_network:
    name: running-joomla-in-docker_joomla_network?

L'objectif de make config est de s'assurer que tous les fichiers sont corrects (sinon nous aurons des messages d'erreur) et que les variables sont bien remplacées par leurs valeurs. Vous pouvez voir par exemple que la version de Joomla est bien celle spécifiée dans le fichier .env et que la ligne user (la dernière ligne ci-dessus) est correctement initialisée avec le user_id:group_id de votre utilisateur courant.

Réveillons Joomla...​

Nous voici au cœur du sujet : nous aimerions voir un beau site Joomla tout neuf. Est-ce possible en une seule commande, et même sans rien installer à la main ?

La réponse est « oui » et make up fera la magie.

Dans votre console, lancez simplement make up, et patientez une minute. La toute première fois, vous obtiendrez la sortie console montrée en haut de cet article.

Qu'est-ce que ça veut dire ? Docker a récupéré (pulled) depuis Internet nos services joomla et joomladb (autrement dit, il a téléchargé le CMS Joomla (avec PHP et Apache) et MySQL).

En lançant ensuite la commande ci-dessous (ou juste docker container list pour obtenir toutes les colonnes), vous obtiendrez la liste des containers en cours d'exécution :

$ {`docker container list --all --format "table {{.Image}}\\t{{.Names}}\\t{{.Status}}\\t{{.Ports}}"`}

IMAGE NAMES STATUS PORTS
joomla:5.2.0-php8.3-apache joomla-app Up 6 minutes 0.0.0.0:8080->80/tcp
mysql:8.4.2 joomla-db Up 7 minutes (healthy) 3306/tcp, 33060/tcp
▋

Comme on le voit, youpi !, nous avons nos deux services (des containers nommés) qui sont Joomla et MySQL, et tous les deux sont Up (voyez la colonne Status). On voit que Joomla utilise le port 8080 et MySQL le port 3306.

... ou demandons-lui de s'endormir (on garde les containers)​

La commande inverse de make up est make stop. L'action stop arrêtera nos containers Joomla et MySQL (comprenez les faire dormir) mais sans supprimer les fichiers (votre site et votre base) de votre disque dur. En relançant make up, vous les retrouverez. up et stop sont comme un interrupteur.

$ make stop▋

... ou demandons-lui de supprimer les containers (libérer plus de mémoire)​

La commande make down va arrêter les containers et les supprimer. Mais dans notre cas, nous aurons toujours les fichiers sur notre disque dur, donc nous ne perdrons pas notre site.

$ make down▋

... ou demandons-lui de se suicider (supprimer les containers et les fichiers)​

La commande make reset arrêtera les containers mais supprimera aussi les fichiers sur le disque.

$ make reset▋

Il est temps de démarrer le site​

Une fois make up lancé et vos containers dans l'état Up, notre site Joomla est prêt.

$ make up▋

Vous aurez besoin de quelques informations comme les identifiants de la base de données ; c'est pour ça que l'écran make start a été défini.

Lancez make start dans la console. Vous obtiendrez un écran comme celui-ci :

$ make start▋

To start your site, please jump to http://127.0.0.1:8080

Go to http://127.0.0.1:8080/administrator to open your backend.

Below a summary of your current installation:

JOOMLA

  * Project name              running-joomla-in-docker
  * Version                   latest
  * Port                      8080

DATABASE

  * Host                      joomla-db
  * User name                 joomla
  * Password                  examplepass
  * Database name             joomla
  * Version                   8.4.2
  * Port                      3306

Comme vous le voyez, le numéro de port est 8080 ; celui que nous avons spécifié dans notre fichier .env. Faites simplement CTRL + clic sur l'URL si votre terminal le supporte (sinon, démarrez manuellement votre navigateur préféré et rendez-vous sur l'URL indiquée) — vous arriverez sur l'écran d'installation montré en haut de cet article.

Félicitations, vous venez d'installer un site Joomla tout neuf avec Docker !

Vous devrez configurer votre nouveau site. Dans l'écran Database Configuration, vous devrez remplir l'Host, le nom d'utilisateur, le mot de passe et le nom de la base de données. Ces informations sont affichées dans la console ; merci make start. Utilisez simplement ces valeurs quand on vous les demande.

Petite pause​

Allons un peu plus loin.

Configuration avancée pour Joomla​

L'image Docker officielle de Joomla est maintenue par la communauté Joomla sur Docker Hub : https://hub.docker.com/_/joomla.

Vous y retrouverez une liste de tags, c'est-à-dire une liste de versions que vous pouvez installer avec Docker, mais vous y trouverez aussi une section How to use this image et celle-là est vraiment utile.

Voici la liste des variables supportées par Joomla fin septembre 2024 :

Les variables d'environnement suivantes sont aussi reconnues pour configurer le déploiement automatique (c'est-à-dire sauter la configuration via le navigateur) de votre instance Joomla :

Faites attention au dernier tableau ci-dessus.

Essayons.

Nous allons mettre à jour nos trois fichiers pour sauter le processus d'installation en prédéfinissant des valeurs comme le nom et le mot de passe de notre administrateur.

compose.yaml mis à jour​

Nous allons éditer notre fichier compose.yaml et ajouter de nouvelles entrées :

name: ${PROJECT_NAME:-your-project-name}?

services:
  joomla:
    image: joomla:${JOOMLA_VERSION:-latest}?
    container_name: ${CONTAINER_PREFIX:-joomla}-app?
    restart: always
    ports:
      - ${WEB_PORT:-8080}:80?
    environment:
      - JOOMLA_DB_HOST=joomladb
      - JOOMLA_DB_NAME=${DB_NAME:-joomla}
      - JOOMLA_DB_PASSWORD=${DB_PASSWORD:-examplepass}
      - JOOMLA_DB_USER=${DB_USER:-joomla}
      # highlight-next-line
      - JOOMLA_SITE_NAME=${JOOMLA_SITE_NAME:-Joomla}
      # highlight-next-line
      - JOOMLA_ADMIN_USER=${JOOMLA_ADMIN_USER:-Joomla Hero}
      # highlight-next-line
      - JOOMLA_ADMIN_USERNAME=${JOOMLA_ADMIN_USERNAME:-joomla}
      # highlight-next-line
      - JOOMLA_ADMIN_PASSWORD=${JOOMLA_ADMIN_PASSWORD:-joomla@secured}
      # highlight-next-line
      - JOOMLA_ADMIN_EMAIL=${JOOMLA_ADMIN_EMAIL:-joomla@example.com}
    depends_on:
      joomladb:
        condition: service_healthy
    user: ${UID:-1000}:${GID:-1000}?
    volumes:
      - ./joomla_data:/var/www/html
    networks:
      - joomla_network

  joomladb:
    image: mysql:${MYSQL_VERSION:-latest}
    container_name: ${CONTAINER_PREFIX:-joomla}-db
    restart: always
    ports:
      - ${MYSQL_PORT-:3306}:3306?
    environment:
      - MYSQL_DATABASE=${DB_NAME:-joomla}
      - MYSQL_PASSWORD=${DB_PASSWORD:-examplepass}
      - MYSQL_RANDOM_ROOT_PASSWORD='1'?
      - MYSQL_USER=${DB_USER:-joomla}
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]?
      timeout: 20s?
      retries: 10
    user: ${UID:-1000}:${GID:-1000}
    volumes:
      - ./db_data:/var/lib/mysql
    networks:
      - joomla_network

networks:
  joomla_network:

.env mis à jour​

Et nous allons aussi mettre à jour notre fichier .env comme ceci :

CONTAINER_PREFIX=joomla?
DB_NAME=joomla
DB_PASSWORD=examplepass?
DB_USER=joomla
// highlight-next-line
JOOMLA_ADMIN_EMAIL=joomla@example.com?
// highlight-next-line
JOOMLA_ADMIN_PASSWORD=joomla@secured?
// highlight-next-line
JOOMLA_ADMIN_USER=Joomla Hero?
// highlight-next-line
JOOMLA_ADMIN_USERNAME=joomla?
// highlight-next-line
JOOMLA_SITE_NAME=Joomla?
JOOMLA_VERSION=5.2.0-php8.3-apache?
MYSQL_PORT=3306?
MYSQL_VERSION=8.4.2?
PROJECT_NAME=running-joomla-in-docker?
WEB_PORT=8080?

makefile mis à jour​

Et, enfin, mettre aussi à jour le makefile comme ceci :

-include .env?

config:
	@UID=$$(id -u) GID=$$(id -g) docker compose config?

down: stop?
	-@UID=$$(id -u) GID=$$(id -g) docker compose down?

log:
	-@UID=$$(id -u) GID=$$(id -g) docker compose logs

reset: down
	-@rm -rf db_data joomla_data?

start:
	@clear?
	@printf "\033[1;33m%s\033[0m\n\n" "To start your site, please jump to http://127.0.0.1:${WEB_PORT}"?
	@printf "\033[1;33m%s\033[0m\n\n" "Go to http://127.0.0.1:${WEB_PORT}/administrator to open your backend."

	@printf "\033[1;104m%s\033[0m\n\n" "Below a summary of your current installation:"?

	@printf "\033[1;34m%s\033[0m\n\n" "JOOMLA"
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n" "  * Project name" "${PROJECT_NAME}"?
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n" "  * Version" "${JOOMLA_VERSION}"
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n" "  * Port" "${WEB_PORT}"

    # highlight-next-line
	@printf "\n\033[1;34m%s\033[0m\n\n" "  Administration"
    # highlight-next-line
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n" "  * Site name" "${JOOMLA_SITE_NAME}"
    # highlight-next-line
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n" "  * Admin friendly username" "${JOOMLA_ADMIN_USER}"
    # highlight-next-line
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n" "  * Admin username" "${JOOMLA_ADMIN_USERNAME}"
    # highlight-next-line
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n" "  * Admin password" "${JOOMLA_ADMIN_PASSWORD}"
    # highlight-next-line
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n\n" "  * Admin email" "${JOOMLA_ADMIN_EMAIL}"

	@printf "\033[1;34m%s\033[0m\n\n" "DATABASE"
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n" "  * Host" "joomla-db"
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n" "  * User name" "${DB_USER}"
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n" "  * Password" "${DB_PASSWORD}"
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n" "  * Database name" "${DB_NAME}"
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n" "  * Version" "${MYSQL_VERSION}"
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n\n" "  * Port" "${MYSQL_PORT}"

stop:
	-@UID=$$(id -u) GID=$$(id -g) docker compose stop

up:
	-@mkdir -p db_data joomla_data?
	@UID=$$(id -u) GID=$$(id -g) docker compose up --detach --build?

Comme vous le voyez, nous avons configuré quelques clés JOOMLA_ADMIN_xxx et défini JOOMLA_SITE_NAME à Joomla ; le nom de notre site.

Lancer le site et sauter le processus d'installation​

Une fois les trois fichiers mis à jour, lancez make reset (pour supprimer notre site précédent s'il y en a un) puis make up pour en créer un nouveau. Enfin, lancez make start pour afficher la liste des variables importantes :

$ make reset && make up && make start▋

To start your site, please jump to http://127.0.0.1:8080

Go to http://127.0.0.1:8080/administrator to open your backend.

Below a summary of your current installation:

JOOMLA

  * Project name              running-joomla-in-docker
  * Version                   5.2.0-php8.3-apache
  * Port                      8080

  Administration

  * Site name                 Joomla
  * Admin friendly username   Joomla Hero
  * Admin username            joomla
  * Admin password            joomla@secured
  * Admin email               joomla@example.com

DATABASE

  * Host                      joomla-db
  * Version                   8.4.2
  * Name                      joomla
  * User                      joomla
  * Password                  examplepass
  * Port                      3306

Maintenant, en allant sur http://127.0.0.1:8080/administrator, vous ne verrez plus les écrans d'installation mais, immédiatement, l'écran de connexion. Le nom d'utilisateur à utiliser est joomla et son mot de passe est joomla@secured (comme affiché dans la console).

Votre site Joomla est déjà configuré ; sympa non ?

Deuxième pause​

Bon, à ce stade, nous avons vu comment créer un site Joomla tout neuf en quelques secondes avec la seule commande make up et comment contourner les écrans d'installation en fournissant déjà les informations utiles dans notre fichier .env.

Essayons un exemple concret : nous sommes une petite agence web, nous voulons utiliser Docker pour nos prochains projets et nous en avons déjà trois en tête. Ou alors vous êtes un particulier avec plusieurs sites, tous avec des versions de Joomla différentes.

Démarrer trois projets différents​

Créez une structure comme ci-dessous, c'est-à-dire cd /tmp/joomla && mkdir project_1 project_2 project_3.

$ cd /tmp/joomla && mkdir project_1 project_2 project_3▋

Revenez ensuite au chapitre compose.yaml mis à jour et créez le fichier compose.yaml dans chacun des trois dossiers de projet. Faites de même pour le .env et le makefile.

Les mêmes trois fichiers dans les trois dossiers de projet.

Au final, vous devriez avoir cette structure dans votre dossier /tmp/joomla :

Un répertoire par projet et, encore une fois, nos trois fichiers.

$ sudo apt-get update && sudo apt-get install tree▋

Projet 1 - Joomla 5.2​

Configurez le fichier project_1/.env avec le contenu suivant.

Comme vous le voyez (lignes surlignées), ce fichier est le même que le dernier .env utilisé plus haut, mais :

• Nous allons définir CONTAINER_PREFIX avec une valeur unique ; dans notre exemple joomla_5,
• Nous devons faire pareil (définir une valeur unique) pour le numéro de port MySQL ; nous pourrions utiliser le port standard 3306 pour notre premier projet mais utilisons plutôt 3301 (1 parce que c'est notre premier projet)
• Vous avez compris ; nous ferons de même pour JOOMLA_SITE_NAME et PROJECT_NAME ; restons humbles et optons pour Joomla_5 et joomla5, et
• Enfin, nous devons définir un numéro de port web ; nous utiliserons 8081 (notre site sera donc disponible sur http://127.0.0.1:8081).

Voici le fichier .env pour notre premier projet :

// highlight-next-line
CONTAINER_PREFIX=joomla_5?
DB_NAME=joomla
DB_PASSWORD=examplepass
DB_USER=joomla
JOOMLA_ADMIN_EMAIL=joomla@example.com
JOOMLA_ADMIN_PASSWORD=joomla@secured
JOOMLA_ADMIN_USER=Joomla Hero
JOOMLA_ADMIN_USERNAME=joomla
// highlight-next-line
JOOMLA_SITE_NAME=Joomla_5
// highlight-next-line
JOOMLA_VERSION=5.2.0-php8.3-apache
// highlight-next-line
MYSQL_PORT=3301?
// highlight-next-line
MYSQL_VERSION=8.4.2
// highlight-next-line
PROJECT_NAME=joomla5
// highlight-next-line
WEB_PORT=8081?

Allez dans votre console et lancez cd project_1 pour entrer dans le dossier du premier projet puis make up pour créer les containers Docker du projet 1.

En allant sur http://127.0.0.1:8081/administrator/ nous avons notre première page d'administration (comme vous le voyez, le site s'appelle bien Joomla_5, comme prévu).

Projet 2 - Joomla 4.0​

Configurez le project_2/.env avec le contenu suivant. Comme vous le voyez (lignes surlignées), ce fichier est le même que le dernier .env utilisé plus haut mais, simplement, nous allons ajuster le nom du projet et le port web (notre site sera donc disponible sur http://127.0.0.1:8082).

Faites les mêmes changements que pour le projet 1 mais remplacez juste 1 par 2 :

// highlight-next-line
CONTAINER_PREFIX=joomla_4?
DB_NAME=joomla
DB_PASSWORD=examplepass
DB_USER=joomla
JOOMLA_ADMIN_EMAIL=joomla@example.com
JOOMLA_ADMIN_PASSWORD=joomla@secured
JOOMLA_ADMIN_USER=Joomla Hero
JOOMLA_ADMIN_USERNAME=joomla
// highlight-next-line
JOOMLA_SITE_NAME=Joomla_4
// highlight-next-line
JOOMLA_VERSION=4.0.2-apache
// highlight-next-line
MYSQL_PORT=3302?
// highlight-next-line
MYSQL_VERSION=5.7.37
// highlight-next-line
PROJECT_NAME=joomla4
// highlight-next-line
WEB_PORT=8082?

Enregistrez le fichier et lancez make up pour démarrer le deuxième site. Allez sur http://127.0.0.1:8082/administrator et oui, nous avons notre deuxième site qui tourne sur notre machine.

$ make up▋

Projet 3 - Joomla 3.5​

Configurez maintenant le project_3/.env avec le contenu suivant.

Cette fois, nous utiliserons 3 comme suffixes :

// highlight-next-line
CONTAINER_PREFIX=joomla_3?
DB_NAME=joomla
DB_PASSWORD=examplepass
DB_USER=joomla
JOOMLA_ADMIN_EMAIL=joomla@example.com
JOOMLA_ADMIN_PASSWORD=joomla@secured
JOOMLA_ADMIN_USER=Joomla Hero
JOOMLA_ADMIN_USERNAME=joomla
// highlight-next-line
JOOMLA_SITE_NAME=Joomla_3
// highlight-next-line
JOOMLA_VERSION=3.5.1-apache?
// highlight-next-line
MYSQL_PORT=3303?
// highlight-next-line
MYSQL_VERSION=5.7.31?
// highlight-next-line
PROJECT_NAME=joomla3
// highlight-next-line
WEB_PORT=8083?

Enregistrez le fichier et lancez make up && make start pour démarrer le troisième site. Allez sur http://127.0.0.1:8083/administrator et oui, nous avons notre troisième site qui tourne sur notre machine.

$ make up && make start▋

Démarrer les trois projets en une seule commande​

Si je suis dans mon dossier /tmp/joomla, je peux démarrer mes trois projets d'un coup comme ceci :

$ cd project_1 && make up && cd ../project_2 && make up && cd ../project_3 &&
make up▋

Voici ce que vous pouvez obtenir :

$ cd project_1

$ make up
[+] Running 3/23
✔ Network joomla_5_network Created 0.0s
✔ Container joomla_5-db Healthy 11.5s
✔ Container joomla_5-app Started 0.4s

$ cd ../project_2

$ make up
[+] Running 3/3
✔ Network joomla_4_network Created 0.0s
✔ Container joomla_4-db Healthy 31.0s
✔ Container joomla_4-app Started 31.4s

$ cd ../project_3

$ make up
[+] Running 3/3
✔ Network joomla_3_network Created 0.0s
✔ Container joomla_3-db Healthy 62.7s
✔ Container joomla_3-app Started 61.5s
▋

D'autres projets ? Combien de sites puis-je avoir ?​

Comme nous venons de le voir, nous pouvons lancer plusieurs projets Joomla en même temps sur notre machine et y accéder le plus simplement possible en faisant varier le numéro de port web (8081, 8082, 8083, ...).

Mais combien puis-je en avoir ? Eh bien, ça dépend juste de votre machine.

Pour information, voici ce que je vois en ce moment sur mon ordinateur Windows (j'utilise Docker Desktop et WSL2).

Comme vous le voyez, j'ai en fait quatre projets : mon blog actuel (qui tourne aussi sous Docker) et les trois projets Joomla.

Si vous regardez la colonne CPU (%), vous pouvez voir que les projets sont presque endormis. Et c'est normal : une fois la page web affichée, Joomla et MySQL n'ont plus besoin de CPU. La page est affichée, donc ils dorment.

Pour la mémoire, j'ai alloué 20 Go max. à WSL/Docker et en ce moment, mes quatre projets (blog inclus) consomment 3,3 Go au total. Je peux donc démarrer bien plus de projets.

Mais ai-je besoin de travailler sur les trois projets en même temps ? Probablement pas. Alors pourquoi ne pas arrêter, par exemple, le premier et le troisième projet ?

Dans la console, lancez simplement make stop dans les dossiers des projets 1 et 3, en exécutant ( cd project_1 ; make stop ; cd ../project_3 ; make stop). Nous allons ainsi arrêter (pas supprimer ; juste geler et libérer de la mémoire) notre premier et notre troisième projet.

$ ( cd project_1 ; make stop ; cd ../project_3 ; make stop )▋

En revenant sur Docker Desktop, on voit effectivement que nous avons gagné 1 Go de RAM.

$ ( cd project_1 && make up )▋

Sous le capot : les logs Docker​

Optionnel — passez cette section si tout fonctionne et que vous n'avez pas besoin de débugger.

Parfois, si quelque chose se passe mal, c'est bien d'avoir accès aux logs Docker. Lancez simplement make log pour ça.

$ make log▋

Les logs ressembleront à ceci :

joomla-db  | 2024-10-13 13:30:25+00:00 [Note] [Entrypoint]: Entrypoint script for MySQL Server 8.4.2-1.el9 started.
joomla-db  | '/var/lib/mysql/mysql.sock' -> '/var/run/mysqld/mysqld.sock'
joomla-db  | 2024-10-13T13:30:26.058140Z 0 [System] [MY-015015] [Server] MySQL Server - start.
joomla-db  | 2024-10-13T13:30:26.238267Z 0 [System] [MY-010116] [Server] /usr/sbin/mysqld (mysqld 8.4.2) starting as process 1
joomla-db  | 2024-10-13T13:30:26.239450Z 0 [Warning] [MY-010122] [Server] One can only use the --user switch if running as root
joomla-db  | 2024-10-13T13:30:26.246482Z 1 [System] [MY-013576] [InnoDB] InnoDB initialization has started.
joomla-db  | 2024-10-13T13:30:26.568703Z 1 [System] [MY-013577] [InnoDB] InnoDB initialization has ended.
joomla-db  | 2024-10-13T13:30:26.852192Z 0 [Warning] [MY-010068] [Server] CA certificate ca.pem is self signed.

[...]

joomla-db  | 2024-10-13T13:30:26.852232Z 0 [System] [MY-013602] [Server] Channel mysql_main configured to support TLS. Encrypted connections are now
joomla-app  | ========================================================================
joomla-app  |
joomla-app  |
joomla-app  | Ensuring Joomla database is present
joomla-app  |
joomla-app  | MySQL Database Created
joomla-app  |  This server is now configured to run Joomla!
joomla-app  |
joomla-app  |   NOTE: You will need your database server address, database name,
joomla-app  |         and database user credentials to install Joomla.
joomla-app  |
joomla-app  | ========================================================================
joomla-app  | AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 172.19.0.3. Set the 'ServerName' directive globally to suppress this message

[...]

joomla-app  | [Fri Oct 04 13:31:46.880743 2024] [mpm_prefork:notice] [pid 1:tid 1] AH00163: Apache/2.4.62 (Debian) PHP/8.3.12 configured -- resuming normal operations
joomla-app  | [Fri Oct 04 13:31:46.880782 2024] [core:notice] [pid 1:tid 1] AH00094: Command line: 'apache2 -D FOREGROUND'
joomla-app  | 172.19.0.1 - - [04/Oct/2024:06:57:36 +0000] "POST /installation/index.php HTTP/1.1" 200 6497 "http://127.0.0.1:8080/installation/index.php" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0"

Conclusion​

Trois petits fichiers — compose.yaml, .env, makefile — et make up devient toute votre histoire de déploiement Joomla : installations neuves, sites préconfigurés qui sautent l'assistant d'installation, et autant de projets isolés (versions différentes de Joomla/PHP/MySQL) que votre machine peut en supporter, chacun démarré, arrêté ou détruit en une seule commande.

À ce stade, vous vous demandez peut-être : tout ça c'est bien beau, mais j'ai déjà un site Joomla et j'aimerais en faire une sauvegarde puis la restaurer en local avec Docker ; comment faire ?

Si c'est bien votre question, lisez l'article suivant : Restaurer une sauvegarde Joomla avec Docker