# Create your joomla website using Docker

A series of 6 article(s), in reading order.

<!--
  canonical-url: https://www.avonture.be/fr/blog/frankenphp-docker-joomla
  published:     2023-11-21
  This is a static plain-Markdown mirror generated at build time.
  Visit the canonical URL above for the fully rendered page, with images and interactive components.
-->

# FrankenPHP : un serveur d'applications moderne pour PHP

> Apprenez à mettre en place un site Joomla avec Docker et FrankenPHP, un serveur PHP moderne jusqu'à 3,5 fois plus rapide que PHP-FPM. Avec un compose.yaml tout simple.

---
![FrankenPHP](/img/v2/frankenphp.webp)

**TL;DR**

Cet article teste FrankenPHP, un serveur d'applications PHP moderne annoncé comme jusqu'à 3,5 fois plus rapide que PHP-FPM, en lançant une installation Joomla prête à l'emploi (signée Alexandre Elisé) via `docker compose pull && docker compose up`. On y voit la lente montée en route de la connexion MySQL au premier lancement, puis l'accès au site Joomla en HTTPS sur un port attribué dynamiquement.

D'après [leur documentation](https://speakerdeck.com/dunglas/the-php-revolution-is-underway-frankenphp-1-dot-0-beta), [FrankenPHP](https://frankenphp.dev/) est 3,5 fois plus rapide que PHP FPM. Il a atteint une release stable depuis, et il vaut clairement la peine d'être testé en développement local.

Alors, à quoi ressemble un vrai site dessus ? Lançons une installation Joomla complète pour le découvrir.

## Ce que FrankenPHP vous apporte {#what-frankenphp-gives-you}

Un site Joomla complet, en https, servi par FrankenPHP, démarré en deux commandes :

> Screenshot — https\://localhost:54408
>
> ![Joomla is now running on FrankenPHP](./images/frankenphp_joomla_homepage.webp)

Vous ne verrez peut-être pas de gain de vitesse spectaculaire sur votre machine puisque vous êtes le seul visiteur, mais c'est agréable de se dire qu'on surfe aussi vite en local.

Maintenant, la partie honnête du contrat, avant de vous lancer :

> **Aïe, c'est terriblement lent à démarrer:**
>
> Pour être honnête, avant de pouvoir voir la page d'accueil de mon Joomla en localhost, j'ai attendu plus de 15 minutes (la première fois). Je n'aurais jamais attendu aussi longtemps si je n'avais pas dû terminer ce chapitre.

## Pourquoi ça fonctionne {#why-it-works}

* FrankenPHP est un serveur d'applications PHP moderne construit sur le serveur web Caddy : un seul processus sert PHP *et* gère le https, au lieu du classique duo *« le serveur web parle à PHP-FPM »*.
* Comme il garde le runtime PHP vivant entre les requêtes, ses auteurs le mesurent jusqu'à 3,5 fois plus rapide que PHP-FPM.
* Vous n'avez rien à assembler : [Alexandre Elisé](https://github.com/alexandreelise) publie une image FrankenPHP + Joomla prête à l'emploi, donc toute la mise en place tient dans un fichier `compose.yaml` et un `docker compose up`.

## Le mettre en route {#getting-it-running}

Je vous invite à jouer avec sur votre machine de développement (sauf si vous avez vos propres serveurs ; vous ne pourrez certainement pas utiliser FrankenPHP chez votre hébergeur).

Rendez-vous par exemple dans votre dossier `/tmp/joomla` et créez le fichier `compose.yaml` ci-dessous. La source du projet est <https://github.com/alexandreelise/frankenphp-joomla> et le fichier readme `Getting Started` d'Alexandre couvre les autres façons de le lancer.

> **Ne construisez pas l'image vous-même:**
>
> Ma suggestion est de remplacer le fichier `compose.yaml` par celui ci-dessous. Ainsi, vous réutiliserez l'image publiée par Alexandre et vous n'aurez pas besoin de la construire vous-même (beaucoup plus rapide) :
>
> **compose.yaml**
>
> ```yaml
> services:
>
>   joomla:
>     image: alexandreelise/frankenphp-joomla:hardened-mysql-0.1.1
>     restart: always
>     ports:
>       - 80:80
>       - 443:443
>     environment:
>       - MYSQL_ROOT_PASSWORD=test
>       - JOOMLA_DB_HOST=db
>       - JOOMLA_DB_USER=exampleuser
>       - JOOMLA_DB_PASSWORD=examplepass
>       - JOOMLA_DB_NAME=exampledb
>     volumes:
>       - joomla:/app/public
>     depends_on:
>       - db
>
>   db:
>     image: mysql:8.2
>     environment:
>       - MYSQL_DATABASE=exampledb
>       - MYSQL_USER=exampleuser
>       - MYSQL_PASSWORD=examplepass
>       - MYSQL_ROOT_PASSWORD=test
>     volumes:
>       - db:/var/lib/mysql
>
> volumes:
>   joomla:
>   db:
> ```

En lançant `docker compose pull`, Docker va télécharger les deux images ; celle avec FrankenPHP et Joomla et celle pour MySQL. Selon la vitesse de votre connexion Internet, cela prendra quelques secondes ; uniquement la première fois.

Ensuite, il ne vous reste plus qu'à créer les containers basés sur les images en lançant `docker compose up`.

## Ce qui se passe pendant ces longues minutes {#what-happens-during-those-long-minutes}

Vous allez commencer à recevoir des messages de logs dans la console *(parce qu'ici, pour l'illustration, vous n'avez pas utilisé le flag `--detach`)* :

![Running FrankenPHP](./images/running_frankenphp.webp)

> **Patientez jusqu'à ce que MySQL soit prêt:**
>
> Vous devez maintenant attendre **quelques minutes** avant que la connexion à la base de données ne soit prête. Vous aurez l'impression que l'installation échoue à cause des nombreuses lignes `[ERROR] Connection refused`, mais patientez.

La raison est que Joomla va essayer de se connecter à MySQL alors que le container MySQL n'est pas prêt à accepter les connexions. Vous verrez donc défiler beaucoup de `[ERROR] Connection refused`. Restez patient et, après un moment, vous obtiendrez ceci :

![Joomla has been installed](./images/frankenphp_joomla_installed.webp)

> **Les logs peuvent différer dans votre version:**
>
> Selon la version des images Docker utilisées, des scripts et de la version de Joomla, les lignes de logs peuvent varier dans le temps.

Quand tout s'est bien déroulé, rendez-vous simplement sur `https://localhost:443` pour voir votre site Joomla tourner sur FrankenPHP. Pour accéder à la page d'administration, allez sur `https://localhost:443/administrator`. Les identifiants à utiliser se retrouvent dans les logs, comme indiqué par la flèche rouge sur l'image ci-dessus. Vous pouvez aussi les récupérer avec cette commande : `docker compose logs | grep -i "Here are your Joomla credentials:"`.

> **FrankenPHP utilise SSL et donc https:**
>
> Notez que FrankenPHP sert votre site en `https`. Vu la façon dont Alexandre a construit son script, le numéro de port n'est pas fixe. Pour déterminer quel port utiliser, ouvrez une nouvelle console Linux et lancez `docker container list` pour obtenir la liste des containers en cours d'exécution. Vous verrez le port à utiliser pour accéder à votre site FrankenPHP dans la colonne `PORTS`. C'est aussi affiché dans l'application Windows `Docker Desktop` ; allez dans la liste des containers pour obtenir le port.

## Sous le capot (passez votre chemin si vous voulez juste l'utiliser) {#under-the-hood-skip-this-if-you-just-want-to-use-it}

Ces lignes `Connection refused` ne sont pas un problème FrankenPHP : c'est l'erreur classique du *« mon container est démarré, donc mon service est prêt »*. Un container démarré n'est pas une base de données qui accepte les connexions, et rien dans `docker compose up` ne fait la différence.

*C'est exactement le problème que les healthchecks résolvent ; [Get health information from your running containers](/blog/docker-healthy) montre comment savoir si un container est vraiment prêt, et pas seulement démarré.*

## Conclusion {#conclusion}

Pour une machine de développement locale, FrankenPHP vaut le détour : une seule image, du https directement, et un runtime PHP qui reste chaud entre les requêtes. Le prix à payer, c'est un premier démarrage qui prend un bon quart d'heure ; après ça, `docker compose up` est instantané.

Si vous préférez avoir un site Joomla qui tourne tout de suite avec la stack classique Apache + PHP-FPM, [Start Joomla with Docker in just a few clicks](/blog/docker-joomla-right-to-the-point) vous y amène en deux minutes.


---

<!--
  canonical-url: https://www.avonture.be/fr/blog/docker-joomla
  published:     2023-12-22
  This is a static plain-Markdown mirror generated at build time.
  Visit the canonical URL above for the fully rendered page, with images and interactive components.
-->

# Créer votre site Joomla avec Docker - Partie 1

> Apprenez à mettre en place rapidement votre site Joomla en local avec Docker. Ce guide pas à pas couvre Docker Compose, la configuration de la base de données (MySQL/MariaDB) et le lancement de vos services.

---
![Créer votre site Joomla avec Docker - Partie 1](/img/v2/joomla.webp)

**TL;DR**

Cet article détaille comment mettre en place rapidement un site Joomla en
local avec Docker, en configurant un fichier `compose.yaml` pour orchestrer le
service applicatif et celui de la base de données. Il explique les étapes
essentielles pour assurer la persistance des données via la synchronisation
des volumes, gérer les ports pour plusieurs projets et personnaliser les
connexions à la base. Le tutoriel se termine par une commande CLI en une ligne
pour déployer tout l'environnement en quelques secondes.

Dans cet article, nous allons voir comment utiliser Docker pour installer Joomla sur votre localhost et démarrer un nouveau site **en quelques secondes**.

J'utilise une console Linux *(je fais tourner WSL sur mon ordinateur Windows et j'ai choisi Ubuntu comme distribution)* mais comme Docker fonctionne aussi sous Windows, vous pouvez lancer exactement les mêmes commandes dans une console MS-DOS / PowerShell.

**Quick Jump:** [Deux minutes, un fichier](#two-minutes-one-file-your-joomla-is-running) | [Bonus - une seule ligne de commande](#bonus---install-joomla-with-a-cli-one-liner)

Si vous n'avez pas encore Docker, consultez mon article « [Installer Docker et jouer avec PHP](/blog/install-docker) » pour en savoir plus sur Docker et obtenir un guide d'introduction simple.

**Nous partons du principe, dans cet article, que vous avez Docker et que vous travaillez sous Linux ou avec WSL.**

## Deux minutes, un fichier, et votre Joomla tourne {#two-minutes-one-file-your-joomla-is-running}

Cliquez sur `Generate install script` ci-dessous et copiez/collez le script dans un terminal :

**Project: /tmp/joomla**

**compose.yaml**

```yaml
services:
  joomla:
    image: joomla
    restart: always
    ports:
      - 8080:80
    environment:
      - JOOMLA_DB_HOST=joomladb
      - JOOMLA_DB_PASSWORD=example

  joomladb:
    image: mysql:8.0.13
    restart: always
    environment:
      - MYSQL_ROOT_PASSWORD=example
```

> **Note:**
>
> Maintenant, lancez simplement 'docker compose up -d' pour démarrer le projet
> puis ouvrez votre navigateur et rendez-vous sur <http://localhost:8080>

Lancez `docker compose up --detach`, attendez le téléchargement des images, puis ouvrez `http://localhost:`8080 :

> Screenshot — http\://localhost:8080
>
> ![Installateur Joomla](./images/joomla_installation_screen.webp)

Répondez aux questions de l'installateur et, quelques secondes plus tard, vous voilà ici :

> Screenshot — http\://localhost:8080/aministrator/index.php
>
> ![Tableau de bord d'administration Joomla](./images/admin_dashboard.webp)

Un site Joomla complet, sur votre machine, avec une base de données — et pas un seul fichier de Joomla ou de MySQL installé sur votre disque.

## Que vient-il de se passer {#what-just-happened}

Cette unique commande a demandé à Docker de lire le fichier `compose.yaml` et, à partir de là :

1. un réseau `joomla_default` est créé,
2. le container `joomla-joomladb-1` est créé (c'est votre serveur de base de données) et
3. le container `joomla-joomla-1` est créé lui aussi (c'est votre service Joomla).

Les deux containers partagent le réseau, c'est comme ça que Joomla peut joindre la base de données par son nom de service. La suite de cet article explique ce fichier ligne par ligne, puis va beaucoup plus loin : persister votre site sur le disque, lancer des commandes CLI, changer de port, passer à PostgreSQL ou MariaDB.

## Avant de commencer {#before-starting}

**Comme vous le savez, pour faire tourner un CMS comme Joomla, il nous faut trois choses + 1 :**

1. Il nous faut un serveur web comme **Apache** ou **nginx**

2. Il nous faut un service de base de données comme **MySQL**, **MariaDB** ou **PostgreSQL** ou toute autre base supportée et

3. Il nous faut **PHP** et

4. Bien sûr, il nous faut **Joomla**

En termes Docker : il nous faut trois services.

## Docker compose {#docker-compose}

Quand vous avez besoin de plusieurs services (Apache doit pouvoir communiquer avec PHP et PHP doit pouvoir demander des données à MySQL), vous devez configurer un fichier particulier appelé `compose.yaml`. Ce fichier doit être placé à la racine du projet et va définir la liste des services nécessaires ainsi que la manière dont ils collaborent.

Vous trouverez un exemple de fichier `compose.yaml` sur la page de description de l'image Joomla : <https://hub.docker.com/_/joomla> *cherchez `docker-compose` sur cette page.*

> **L'image Docker Joomla est construite sur PHP et Apache:**
>
> C'est sûrement trop technique à ce stade mais si vous cliquez sur le lien
> <https://github.com/joomla-docker/docker-joomla/blob/master/6.1/php8.4/apache/Dockerfile>,
> vous verrez que l'image Docker de Joomla 6.1 est construite sur une image
> `php:8.4-apache`. Autrement dit, avec cette image vous obtenez PHP, Apache et
> Joomla, le tout dans une seule image.

## Télécharger les images {#download-images}

Revenons au script de génération du début de cet article et regardons ce qu'il a réellement fait. Pour que ce soit le plus clair possible, voici le contenu de mon dossier temporaire une fois le script exécuté :

```bash
cd /tmp/joomla

$ ls -alh
total 12K
drwxr-xr-x 2 christophe christophe 4.0K Jan 4 15:31 .
drwxrwxrwt 12 root root 4.0K Jan 4 15:31 ..
-rw-r--r-- 1 christophe christophe 279 Jan 4 15:31 compose.yaml
```

Donc je n'ai qu'un seul fichier, et c'est le fichier `compose.yaml` fraîchement créé.

> **`docker compose up --detach` est l'une des commandes les plus importantes à connaître. Elle demande à Docker de traiter le fichier `compose.yaml` et de lancer les services. En bref : elle démarre votre site.:**

Docker va commencer à télécharger `joomla` et `joomladb`, les deux services mentionnés dans le fichier `compose.yaml`.

**compose.yaml**

```yaml
services:
  // highlight-next-line
  joomla:
    [...]
  // highlight-next-line
  joomladb:
    [...]
```

Vous obtiendrez quelque chose comme ceci, patientez le temps que tout soit téléchargé.

```bash
$ docker compose up --detach

[+] Running 16/35
⠹ joomladb 12 layers [⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀] 0B/0B Pulling 19.3s
⠧ 177e7ef0df69 Waiting 15.8s
⠧ cac25352c4c8 Waiting 15.8s
⠧ 8585afabb40a Waiting 15.8s
[...]
⠹ joomla 21 layers [⣿⣿⣦⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⣿⣿⣿⣿⣀⠀⠀] 94.59MB/155.9MB Pulling 19.3s
✔ 578acb154839 Pull complete 11.3s
✔ c053f6f43c12 Pull complete 11.9s
⠋ 65cebbf4d847 Downloading [==============> ] 68.41MB/104.4MB 16.1s
✔ 34045bc93960 Download complete 1.0s
[...]
```

À la fin, une fois les images téléchargées, la console affichera quelque chose comme ceci :

```bash
$ docker compose up --detach

[+] Running 35/35
✔ joomladb 12 layers [⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿] 0B/0B Pulled 84.9s
✔ 177e7ef0df69 Pull complete 26.9s
✔ cac25352c4c8 Pull complete 27.5s
✔ 8585afabb40a Pull complete 28.2s
[...]
✔ joomla 21 layers [⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿] 0B/0B Pulled 146.4s
✔ 578acb154839 Pull complete 11.3s
✔ c053f6f43c12 Pull complete 11.9s
✔ 65cebbf4d847 Pull complete 31.2s
[...]
[+] Running 3/3
✔ Network joomla_default Created 0.3s
✔ Container joomla-joomladb-1 Started 52.9s
✔ Container joomla-joomla-1 Started 38.8s
```

Les deux images ont été téléchargées, et le réseau ainsi que les deux containers cités plus haut ont été créés.

À ce stade, votre site est déjà en cours d'installation. Rendez-vous sur l'URL `http://127.0.0.1:`8080 pour le voir (veillez à utiliser le protocole `http` et pas `https`).

> **Pas encore prêt:**
>
> Vous obtiendrez peut-être une page d'erreur `ERR_EMPTY_RESPONSE` ; c'est
> parce que, par exemple, MySQL n'est pas encore complètement chargé et Joomla
> doit l'attendre avant de pouvoir afficher la page d'installation. Dans ce cas,
> patientez encore un peu... ou lisez la suite de cet article.

> **Résolvez-le en ajoutant une condition depends\_on:**
>
> Joomla peut donc être prêt avant la base de données, et ce n'est pas bon. En effet, Joomla doit pouvoir créer sa base, ajouter des tables et des enregistrements mais si MySQL n'est pas encore prêt, nous aurons un problème.
>
> La solution proposée par Docker est la notion de `healthcheck`. Nous devons définir comment Docker peut *savoir* que MySQL est *healthy*. Ensuite, nous demanderons à Joomla d'attendre que le layer base de données soit *healthy*.
>
> **compose.yaml**
>
> ```yaml
> services:
>   // highlight-next-line
>   joomla:
>     [...]
>     // highlight-next-line
>     depends_on:
>       // highlight-next-line
>       joomladb:
>         // highlight-next-line
>         condition: service_healthy
>
>   // highlight-next-line
>   joomladb:
>     [...]
>     // highlight-next-line
>     healthcheck:
>       // highlight-next-line
>       test: ["CMD", "mysqladmin" ,"ping", "-h", "localhost"]
>       // highlight-next-line
>       timeout: 20s
>       // highlight-next-line
>       retries: 10
> ```

### Pourquoi des noms joomla-joomlaxxx {#why-joomla-joomlaxxx-names}

Nous n'avons pas donné de nom à votre projet, nous avons juste créé un fichier `compose.yaml` dans votre dossier `/tmp/joomla`. Docker a donc nommé votre projet en utilisant le nom du dossier (`joomla`) concaténé au nom du service (regardez le fichier `compose.yaml` : nous avons deux services, un appelé `joomladb` et un appelé `joomla`). Voilà pourquoi...

Introduisons une petite modification, facultative : nous allons donner un nom à votre projet Docker et à vos containers. Éditez le fichier `compose.yaml` et ajoutez une ligne avec `name: xxxx` où `xxxx` est le nom de votre choix. Faites de même mais avec `container_name` cette fois pour les deux services ; par exemple :

**compose.yaml**

```yaml
// highlight-next-line
name: kingsbridge
services:
  joomla:
    // highlight-next-line
    container_name: kingsbridge-app
    [...]

  joomladb:
    // highlight-next-line
    container_name: kingsbridge-db
    [...]
```

Nous n'allons pas encore redémarrer vos containers Docker. Pour l'instant, le nom kingsbridge ne sera pas pris en compte. Pour cela, il faudrait lancer `docker compose down` suivi de `docker compose up --detach`, mais attendons encore un peu avant de le faire.

## Les images Docker {#docker-images}

Si vous êtes curieux, vous pouvez lancer la commande `docker image list` pour obtenir la liste des images Docker déjà téléchargées sur votre machine.

```bash
$ docker image list

REPOSITORY TAG IMAGE ID CREATED SIZE
joomla latest 882b2151d890 2 days ago 663MB
mysql 8.0.13 102816b1ee7d 4 years ago 486MB
```

Ok, donc Docker a téléchargé Joomla (dans sa version *latest*) et MySQL (version 8.0.13).

**Comment utiliser une version spécifique de Joomla ?**

Par défaut, quand on ne précise aucun numéro de version (ce qui est déconseillé en production), Docker télécharge la version dite `latest`. `latest` est ce que Docker appelle un « tag ».

Pour que votre installation soit stable et prévisible, mieux vaut utiliser un tag de version précis. Vous trouverez tous les tags disponibles sur la [page officielle Joomla sur Docker Hub](https://hub.docker.com/_/joomla/tags).

Par exemple, pour utiliser Joomla 5.3.3 avec PHP 8.2, vous modifieriez la ligne `image` de votre `compose.yaml` comme ceci :

**compose.yaml**

```yaml
services:
  joomla:
    image: joomla:5.3.3-php8.2-apache

[...]
```

## Les containers Docker {#docker-containers}

Nous y sommes presque. Lancez `docker container list` pour obtenir la liste des containers créés par Docker :

```bash
$ docker container list

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
0798f8f25d2b joomla "/entrypoint.sh apac…" 8 minutes ago Up 5 minutes 0.0.0.0:8080->80/tcp joomla-joomla-1
7b7fcd3809b0 mysql:8.0.13 "docker-entrypoint.s…" 8 minutes ago Up 7 minutes 3306/tcp, 33060/tcp joomla-joomladb-1
```

Nous avons deux containers en cours d'exécution (vos deux services). Faites attention à la colonne `PORTS` : votre container `joomla` écoute sur le port 8080 et votre container `mysql` écoute sur le port `3306`.

Hé, le port 8080, ça vous dit quelque chose ? C'est un port pour une page web, non ?

Essayons : démarrez votre navigateur préféré et allez sur `http://localhost:`8080 (*ou `http://127.0.0.1:8080`, c'est strictement pareil*) et... Waouh ! L'installateur Joomla montré au début de cet article vous attend.

## Installer Joomla {#install-joomla}

Retour sur `http://localhost:`8080 et continuons l'installation.

Sur le premier écran, sélectionnez simplement votre langue préférée puis saisissez un nom pour votre site Joomla :

> Screenshot — http\://localhost:8080
>
> ![Nommez votre site](./images/admin_step_1.webp)

Quand Joomla demandera vos identifiants d'administration, remplissez simplement les valeurs de votre choix :

> Screenshot — http\://localhost:8080
>
> ![Données de connexion](./images/joomla_admin_login_data.webp)

**En revanche, pour la configuration de la base de données, il faut être rigoureux :**

* Le type de base doit être `MySQLi` (puisque nous utilisons MySQL),

* Le nom de l'host doit être `joomladb` (le nom choisi pour le service de base de données),

* L'utilisateur doit être `root` (valeur par défaut) et

* Le mot de passe de cet utilisateur doit être `example`

> **Pourquoi ces valeurs ?:**
>
> Ces valeurs se retrouvent dans le fichier `compose.yaml`. Si vous avez nommé votre service de base de données autrement que `joomladb`, utilisez le nom que vous avez choisi.

**compose.yaml**

```yaml
services:
  [...]
  // highlight-next-line
  joomladb:
    [...]
    environment:
      // highlight-next-line
      - MYSQL_ROOT_PASSWORD=example
```

> Screenshot — http\://localhost:8080
>
> ![Configuration de la base de données Joomla](./images/joomla_admin_database_configuration.webp)

Et, après quelques secondes, tadaaa...

> Screenshot — http\://localhost:8080
>
> ![L'installation de Joomla est terminée](./images/joomla_admin_ready.webp)

La page d'administration :

> Screenshot — http\://localhost:8080/administrator
>
> ![L'installation de Joomla est terminée](./images/joomla_start_administrator.webp)

Et derrière, le tableau de bord d'administration montré au début de cet article.

**Félicitations, vous avez installé avec succès un site Joomla tout neuf avec Docker !**

## Tout se passe en RAM {#everything-is-done-in-ram}

Laissons le navigateur quelques minutes et retournons dans votre console Linux.

Au chapitre précédent, nous avons installé Joomla, donc nous devrions avoir Joomla sur votre ordinateur, non ?

Vérifions en revenant dans notre console Linux :

```bash
$ pwd
/tmp/joomla

$ ls -alh
total 12K
drwxr-xr-x 2 christophe christophe 4.0K Jan 4 15:31 .
drwxrwxrwt 12 root root 4.0K Jan 4 15:31 ..
-rw-r--r-- 1 christophe christophe 279 Jan 4 15:31 compose.yaml
```

Ah ? Rien... **Rien n'a été téléchargé dans votre dossier.** Vous n'avez pas Joomla sur votre ordinateur. Comment est-ce possible ?

Nous en reparlerons plus loin mais oui, par défaut avec Docker, tout se passe en mémoire, rien sur le disque. Si vous ne pouvez pas attendre, lisez mon article « [Partager des données entre votre container Docker et votre ordinateur](/blog/docker-volume) » pour mieux comprendre pourquoi et comment.

## Jouer avec les containers {#play-with-containers}

Toujours dans votre console, tapez à nouveau `docker container list` :

```bash
$ docker container list

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
0798f8f25d2b joomla "/entrypoint.sh apac…" 8 minutes ago Up 5 minutes 0.0.0.0:8080->80/tcp joomla-joomla-1
7b7fcd3809b0 mysql:8.0.13 "docker-entrypoint.s…" 8 minutes ago Up 7 minutes 3306/tcp, 33060/tcp joomla-joomladb-1
```

Faites attention cette fois à la dernière colonne, appelée `NAMES`.

Nous avons donc deux containers, un nommé `joomla-joomla-1` et un nommé `joomla-joomladb-1`.

Nous allons les arrêter en lançant `docker compose down` :

```bash
$ docker compose down

[+] Running 3/3
✔ Container joomla-joomla-1 Removed 2.6s
✔ Container joomla-joomladb-1 Removed 4.2s
✔ Network joomla Removed
```

Si vous retournez sur `http://localhost:`8080 avec votre navigateur et que vous rafraîchissez la page, le site n'existe plus.

Relancez `docker compose up --detach`.

```bash
$ docker compose up --detach
```

Retournez sur le site, rafraîchissez la page et le site, ah, ne répond pas encore. Attendez un peu... encore un peu... et après un certain temps, le site sera là. Pourquoi ?

Docker doit (re)démarrer deux services, celui de Joomla et le serveur de base de données. L'initialisation des deux peut prendre quelques secondes, et le service de base de données doit être en route pour que Joomla puisse poursuivre son initialisation.

Vous pouvez le voir en lançant `docker compose logs --follow` (appuyez sur `CTRL`+`C` pour quitter).

```bash
$ docker compose logs --follow
```

Une fois Joomla prêt, vous retrouverez l'assistant d'installation de Joomla... comme la première fois. Donc, en lançant `docker compose down`, vous avez perdu votre travail.

```bash
$ docker compose down
```

> **Danger:**
>
> Comme mentionné plus haut, tout se passe en RAM. En arrêtant un container Docker, vous perdez tout ce qui n'est pas sauvegardé sur votre ordinateur. C'est parfait pour jouer/apprendre mais pas ce que vous attendez quand vous développez un vrai site.

> **Information:**
>
> Rappelez-vous de la modification faite plus tôt. Nous avions ajouté le nom kingsbridge comme nom de projet dans votre fichier `compose.yaml`, et nous avions nommé les deux containers. Vous pouvez voir qu'après avoir relancé `docker compose up`, ce n'est plus `joomla-joomlaxxxx` mais kingsbridge-app et kingsbridge-db. C'est parce que les modifications faites dans le fichier yaml ne sont prises en compte qu'après une commande `down / up`. Si vous modifiez le fichier yaml, vous devez redémarrer vos containers Docker.

## Synchroniser avec votre ordinateur {#synchronize-with-your-computer}

Nous allons maintenant demander à Docker de stocker des fichiers/dossiers sur votre ordinateur.

**Nous voulons deux choses :**

* Nous voulons que tout le site soit sauvegardé sur votre disque dur et

* nous voulons que la base de données soit sauvegardée sur le disque dur également.

Pour cela, éditez le fichier `compose.yaml` et ajoutez les lignes surlignées ci-dessous :

**compose.yaml**

```yaml
name: kingsbridge

services:
  joomla:
    image: joomla
    restart: always
    ports:
      - 8080:80
    environment:
      - JOOMLA_DB_HOST=joomladb
      - JOOMLA_DB_PASSWORD=example
    depends_on:
      joomladb:
        condition: service_healthy
    // highlight-next-line
    user: ${UID:-1000}:${GID:-1000}
    // highlight-next-line
    volumes:
      // highlight-next-line
      - ./site_joomla:/var/www/html

  joomladb:
    image: mysql:8.0.13
    restart: always
    environment:
      - MYSQL_ROOT_PASSWORD=example
    healthcheck:
      test: ["CMD", "mysqladmin" ,"ping", "-h", "localhost"]
      timeout: 20s
      retries: 10
    // highlight-next-line
    user: ${UID:-1000}:${GID:-1000}
    // highlight-next-line
    volumes:
      // highlight-next-line
      - ./db:/var/lib/mysql
```

Le dossier `/var/www/html` du service Joomla doit être synchronisé avec le sous-dossier `site_joomla` sur votre ordinateur. C'est pour le site Joomla.

Et le dossier `/var/lib/mysql` du service MySQL doit être synchronisé avec votre sous-dossier local `db`.

> **Créez d'abord les dossiers:**
>
> Veillez à créer d'abord ces deux répertoires sur votre ordinateur, comme ça les permissions des dossiers seront correctes !
>
> ```bash
> $ mkdir site_joomla db
> ```

Les deux lignes `user: ${UID:-1000}:${GID:-1000}` sont vraiment importantes et indiquent à Docker de réutiliser votre utilisateur local (celui de votre session Linux).

> **L'UID/GID de l'utilisateur:**
>
> Cette partie est cruciale : si vous tapez `id -u` et `id -g` sous Linux, vous obtiendrez votre propre user\_id et group\_id (autrement dit UID et GID). La plupart du temps, ce sera `1000` pour les deux mais... parfois non.
>
> La syntaxe `user: ${UID:-1000}:${GID:-1000}` signifie d'utiliser `1000` comme valeur par défaut sauf si les variables système `UID` et `GID` existent, auquel cas on utilise leurs valeurs.

Vérifiez simplement le contenu de votre dossier :

```bash
$ pwd
/tmp/joomla

$ ls -alh
total 20K
drwxr-xr-x 4 christophe christophe 4.0K Jan 4 15:57 .
drwxrwxrwt 12 root root 4.0K Jan 4 15:31 ..
-rw-r--r-- 1 christophe christophe 279 Jan 4 15:31 compose.yaml
drwxr-xr-x 2 christophe christophe 4.0K Jan 4 15:57 db
drwxr-xr-x 2 christophe christophe 4.0K Jan 4 15:57 site_joomla
```

Relancez Docker mais avant, assurez-vous que les containers précédents ont bien été supprimés (et pas seulement arrêtés) : `docker compose kill`.

```bash
$ docker compose kill

[+] Killing 2/2
✔ Container kingsbridge-db Killed 2.1s
✔ Container kingsbridge-app Killed 1.5s
```

Lancez maintenant la commande suivante et, comme vous le voyez, nous initialisons d'abord les variables UID et GID pour ne pas rencontrer de problèmes de permissions :

```bash
$ UID=$(id -u) GID=$(id -g) docker compose up --detach

[+] Running 3/3
✔ Network kingsbridge_default Created 0.3s
✔ Container kingsbridge-db Started 3.3s
✔ Container kingsbridge-app Started
```

Et vous pouvez déjà relancer `ls` pour constater que, oui, vos dossiers locaux `site_joomla` et `db` sont maintenant remplis. C'est le résultat de l'entrée `volumes` ajoutée dans votre `compose.yaml`.

```bash
$ pwd
/tmp/joomla

$ ls -alh site_joomla
total 132K
drwxr-xr-x 19 christophe christophe 4.0K Jan 4 15:59 .
drwxr-xr-x 4 christophe christophe 4.0K Jan 4 15:57 ..
-rw-r--r-- 1 christophe christophe 6.8K Jan 4 15:59 .htaccess
-rw-r--r-- 1 christophe christophe 18K Nov 19 19:54 LICENSE.txt
-rw-r--r-- 1 christophe christophe 5.2K Nov 19 19:54 README.txt
drwxr-xr-x 11 christophe christophe 4.0K Nov 19 19:54 administrator
drwxr-xr-x 5 christophe christophe 4.0K Nov 19 19:54 api
drwxr-xr-x 2 christophe christophe 4.0K Nov 19 19:54 cache
drwxr-xr-x 2 christophe christophe 4.0K Nov 19 19:54 cli
drwxr-xr-x 18 christophe christophe 4.0K Nov 19 19:54 components
drwxr-xr-x 2 christophe christophe 4.0K Nov 19 19:54 files
-rw-r--r-- 1 christophe christophe 6.8K Nov 19 19:54 htaccess.txt
drwxr-xr-x 5 christophe christophe 4.0K Nov 19 19:54 images
drwxr-xr-x 2 christophe christophe 4.0K Nov 19 19:54 includes
-rw-r--r-- 1 christophe christophe 1.6K Nov 19 19:54 index.php
drwxr-xr-x 10 christophe christophe 4.0K Nov 19 19:54 installation
drwxr-xr-x 4 christophe christophe 4.0K Nov 19 19:54 language
drwxr-xr-x 6 christophe christophe 4.0K Nov 19 19:54 layouts
drwxr-xr-x 6 christophe christophe 4.0K Nov 19 19:57 libraries
drwxr-xr-x 75 christophe christophe 4.0K Nov 19 19:58 media
drwxr-xr-x 27 christophe christophe 4.0K Nov 19 19:54 modules
drwxr-xr-x 26 christophe christophe 4.0K Nov 19 19:54 plugins
-rw-r--r-- 1 christophe christophe 764 Nov 19 19:54 robots.txt.dist
drwxr-xr-x 5 christophe christophe 4.0K Nov 19 19:54 templates
drwxr-xr-x 2 christophe christophe 4.0K Nov 19 19:54 tmp
-rw-r--r-- 1 christophe christophe 3.0K Nov 19 19:54 web.config.txt

$ ls -alh db
total 176M
drwxr-x--- 2 christophe christophe 4.0K Jan 4 15:59 '#innodb_temp'
drwxr-xr-x 7 christophe christophe 4.0K Jan 4 15:59 .
drwxr-xr-x 4 christophe christophe 4.0K Jan 4 15:57 ..
-rw-r----- 1 christophe christophe 56 Jan 4 15:59 auto.cnf
-rw-r----- 1 christophe christophe 3.0M Jan 4 15:59 binlog.000001
-rw-r----- 1 christophe christophe 358 Jan 4 15:59 binlog.000002
-rw-r----- 1 christophe christophe 32 Jan 4 15:59 binlog.index
-rw------- 1 christophe christophe 1.7K Jan 4 15:59 ca-key.pem
-rw-r--r-- 1 christophe christophe 1.1K Jan 4 15:59 ca.pem
-rw-r--r-- 1 christophe christophe 1.1K Jan 4 15:59 client-cert.pem
-rw------- 1 christophe christophe 1.7K Jan 4 15:59 client-key.pem
-rw-r----- 1 christophe christophe 5.9K Jan 4 15:59 ib_buffer_pool
-rw-r----- 1 christophe christophe 48M Jan 4 15:59 ib_logfile0
-rw-r----- 1 christophe christophe 48M Jan 4 15:59 ib_logfile1
-rw-r----- 1 christophe christophe 12M Jan 4 15:59 ibdata1
-rw-r----- 1 christophe christophe 12M Jan 4 15:59 ibtmp1
drwxr-x--- 2 christophe christophe 4.0K Jan 4 15:59 joomla
drwxr-x--- 2 christophe christophe 4.0K Jan 4 15:59 mysql
-rw-r----- 1 christophe christophe 30M Jan 4 15:59 mysql.ibd
drwxr-x--- 2 christophe christophe 4.0K Jan 4 15:59 performance_schema
-rw------- 1 christophe christophe 1.7K Jan 4 15:59 private_key.pem
-rw-r--r-- 1 christophe christophe 452 Jan 4 15:59 public_key.pem
-rw-r--r-- 1 christophe christophe 1.1K Jan 4 15:59 server-cert.pem
-rw------- 1 christophe christophe 1.7K Jan 4 15:59 server-key.pem
drwxr-x--- 2 christophe christophe 4.0K Jan 4 15:59 sys
-rw-r----- 1 christophe christophe 12M Jan 4 15:59 undo_001
-rw-r----- 1 christophe christophe 10M Jan 4 15:59 undo_002
```

Retournez dans votre navigateur et poursuivez l'installation de Joomla comme au chapitre précédent.

Quand l'assistant d'installation s'est terminé avec succès, revenez dans votre console Linux et vérifiez si vous voyez le fichier `configuration.php` maintenant.

```bash
$ pwd
/tmp/joomla

$ ls site_joomla/configuration.php
.rw-r--r-- 2.0k christophe christophe 6.8K Jan 4 15:59 .htaccess

$ head -n 10 site_joomla/configuration.php
{`<?php
class JConfig \{
        public \$offline = false;
        public \$offline_message = 'Ce site est en maintenance.<br>Merci de revenir ultérieurement.';
        public \$display_offline_message = 1;
        public \$offline_image = '';
        public \$sitename = 'kingsbridge';
        public \$editor = 'tinymce';
        public \$captcha = '0';
        public \$list_limit = 20;
`}
```

Oui ! Cette fois, votre site Joomla est stocké sur votre ordinateur.

Pour l'exercice, tuons vos containers avec `docker compose kill` puis relançons `docker compose up --detach` pour les redémarrer : cette fois, nous retrouverons votre site Joomla tel que nous l'avons laissé. Plus rien n'est perdu.

```bash
$ docker compose kill && docker compose up --detach
```

Et puisque les fichiers/dossiers sont maintenant sur votre ordinateur, vous pouvez en faire ce que vous voulez, comme les commiter dans un repository GitHub par exemple.

> **La synchronisation a un coût:**
>
> Quand vous utilisez un ou plusieurs volumes, Docker doit vérifier en permanence si les fichiers/dossiers de votre ordinateur sont synchronisés avec les containers. Cela a un coût en performances. De même, si Docker doit écrire dans un fichier (ou dans votre base Joomla) ; si c'est uniquement en mémoire, ce sera plus rapide que s'il faut aussi écrire la base sur votre disque. Cela dit, la différence de vitesse n'est pas flagrante en temps normal. Si vous êtes développeur et que vous écrivez des centaines voire des milliers d'enregistrements, vous verrez une différence notable.

## Lancer une commande CLI {#start-a-cli-command}

Quand vous travaillez sur un site Joomla, vous avez parfois besoin de lancer une commande PHP comme `php joomla.php`.

Pour cela, vous devez démarrer une *session shell interactive* dans le container Joomla.

Vous vous souvenez du nom de votre service Joomla ? Sinon, rouvrez simplement le fichier `compose.yaml`.

**compose.yaml**

```yaml
services:
  // highlight-next-line
  joomla:
    [...]
```

Le nom de votre service Joomla est `joomla` (et `joomladb` est le nom de votre service de base de données).

Nous savons maintenant tout ce qu'il faut : pour lancer une session shell interactive dans le container Joomla, il suffit de lancer `docker compose exec joomla /bin/sh` pour *sauter* dans le container Joomla (*et `docker compose exec joomladb /bin/sh` pour le container de la base de données*).

```bash
$ docker compose exec joomla /bin/sh
```

Rembobinons quelques secondes parce que c'est compliqué à saisir.

Sur votre ordinateur, dans votre console Linux, si vous tapez `pwd` pour connaître le dossier courant, vous verrez `/tmp/joomla` puisque c'est le répertoire utilisé dans ce tutoriel.

Ensuite, nous sautons dans le container Docker Joomla en lançant `docker compose exec joomla /bin/sh` et, vous le voyez, nous n'avons plus un prompt qui commence par `>` mais par `$`, et ce n'est pas la seule différence. Si maintenant nous relançons `pwd`, nous ne sommes plus dans votre dossier `/tmp/joomla` mais dans `/var/www/html`.

Ça peut rendre fou mais... quand vous entrez dans le container Docker, vous n'êtes *plus* sur votre ordinateur, vous êtes virtuellement sur un autre ordinateur, le container. Dans cet *ordinateur*, le dossier courant est donc `/var/www/html`. En tapant `exit`, vous quittez le container, vous revenez sur votre ordinateur et dans le dossier `/tmp/joomla`.

```bash
$ pwd
/tmp/joomla

$ docker compose exec joomla /bin/sh

$ pwd
/var/www/html

$ exit

$ pwd
/tmp/joomla
```

Autre chose à essayer :

```bash
$ php --version
command not found: php

$ docker compose exec joomla /bin/sh

$ php --version
PHP 8.3.29 (cli) (built: Dec 29 2025 23:29:22) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.3.29, Copyright (c) Zend Technologies
with Zend OPcache v8.3.29, Copyright (c), by Zend Technologies

$ exit
```

Donc, sur mon ordinateur (et probablement sur le vôtre), en tapant `php --version`, j'obtiens une erreur. C'est normal. Je n'ai pas PHP sur mon ordinateur. *Je travaille avec PHP au quotidien depuis des années et je ne l'ai pas sur ma machine.* 😄

Ensuite je saute dans le container Joomla, je retape la même commande et, oui, dans le container Docker de Joomla, PHP est bien installé et ici, c'est la version 8.3.29.

## Utiliser un alias {#using-alias}

Docker démarrera toujours votre projet sur votre localhost et sur un port du type `http://127.0.0.1:`8080.

Plutôt que d'utiliser l'adresse IP, ce serait bien plus agréable d'utiliser un alias comme `http://`kingsbridge`:`8080.

Pour cela, sous Windows, éditez le fichier `C:\Windows\System32\Drivers\etc\hosts` et ajoutez la ligne kingsbridge comme illustré ci-dessous :

**C:\Windows\System32\Drivers\etc\hosts**

```
127.0.0.1 localhost
// highlight-next-line
127.0.0.1 kingsbridge
```

Enregistrez le fichier. Vous pouvez maintenant aller sur `http://`kingsbridge`:`8080

> Screenshot — http\://kingsbridge:8080
>
> ![Utilisation de l'alias Kingsbridge](./images/using_alias.webp)

> **Note:**
>
> Quand ils créent un alias dans le fichier hosts, certains préfèrent utiliser
> le suffixe `.local` comme dans `127.0.0.1` kingsbridge`.local` pour
> bien montrer qu'il s'agit d'un site local. Si vous préférez ça, l'URL sera
> `http://`
> kingsbridge`.local:`8080

## Utiliser un autre port {#using-another-port}

Imaginez que vous ayez un autre projet, pas `Kingsbridge` cette fois. Pouvez-vous faire tourner plusieurs projets Docker en même temps ? Oui, bien sûr !

Il faut juste veiller à utiliser un autre port, non utilisé.

Prenons le fichier `compose.yaml` du projet `shiring`

**compose.yaml**

```yaml
// highlight-next-line
name: shiring

services:
  joomla:
    image: joomla
    ports:
      // highlight-next-line
      - 8081:80

  [...]
```

Nous allons utiliser le port `8081` pour ce projet et, dans votre fichier hosts, nous ajouterons `127.0.0.1 shiring`.

Donc, maintenant et en même temps, nous pouvons accéder à `http://`kingsbridge`:`8080 et à `http://shiring:8081` sans conflits puisque nous avons utilisé un numéro de port distinct.

Kingsbridge peut être un site Joomla 4.4 / PHP 7.4 tandis que shiring tourne sur Joomla 5.0 / PHP 8.2, sans le moindre conflit. **Et c'est d'une simplicité stupéfiante, quand on repense à la façon dont on travaillait avant Docker.**

> **Information:**
>
> Utiliser un autre port n'est pas obligatoire. Vous pouvez avoir plusieurs sites sur le même port, par exemple 8080. Mais dans ce cas, vous ne pourrez pas les utiliser en même temps. Vous pouvez démarrer le premier et, en essayant de démarrer le second, Docker dira *port already in use*. Ce n'est pas un problème ; lancez simplement `docker compose stop` pour le premier afin de libérer le port, puis démarrez le second.
>
> ```bash
> $ docker compose stop
> ```

> **Note:**
>
> Dans cet article, j'utilise le port 8080 parce que Joomla l'utilise
> dans son fichier `compose.yaml` par défaut. Vous n'êtes pas obligé de le
> garder, vous pouvez parfaitement utiliser `80` et pas 8080. Dans mon
> travail quotidien, j'utilise les ports `80`, `81`, `82`, `83`, ... en variant
> le second chiffre pour mes projets.

## Vous préférez PostgreSQL ou MariaDB {#did-you-prefer-postgresql-or-mariadb}

Jusqu'ici, nous avons choisi MySQL comme gestionnaire de base de données. Notre fichier `compose.yaml` est celui, légèrement modifié, que l'on trouve sur <https://hub.docker.com/_/joomla>.

Pourriez-vous opter pour autre chose que MySQL ? Bien sûr, tant que Joomla supporte ce système (voir <https://manual.joomla.org/docs/next/get-started/technical-requirements/>).

Il suffit de remplacer le service `joomladb`, de ne plus utiliser `mysql` mais celui que nous voulons.

**Utiliser PostgreSQL**

Essayons PostgreSQL... Nous allons remplacer `mysql`. L'image Docker officielle de PostgreSQL se trouve sur <https://hub.docker.com/_/postgres>. La documentation nous indique quelle `image` utiliser et comment définir des variables comme le mot de passe par défaut (`POSTGRES_PASSWORD`).

Nous devons aussi changer quelques variables :

* L'utilisateur par défaut de la base doit être précisé, ce sera par exemple `postgres`,
* Nous devons aussi définir le nom de la base dans les deux services ; nous l'appellerons `joomla_db` et
* Nous devons indiquer à Joomla que nous utilisons PostgreSQL, il faut donc mettre `JOOMLA_DB_TYPE` à `pgsql` (soit `mysql`, soit `pgsql`).

> **Note:**
>
> Cette information provient de cette pull request :
> <https://github.com/joomla-docker/docker-joomla/pull/156>.

Notre `compose.yaml` devient :

**compose.yaml**

```yaml
name: kingsbridge

services:
  joomla:
    image: joomla
    container_name: kingsbridge-app
    restart: always
    ports:
      - 8080:80
    environment:
      - JOOMLA_DB_HOST=joomladb
      // highlight-next-line
      - JOOMLA_DB_USER=postgres
      - JOOMLA_DB_PASSWORD=example
      // highlight-next-line
      - JOOMLA_DB_NAME=joomla_db
      // highlight-next-line
      - JOOMLA_DB_TYPE=pgsql
    depends_on:
      - joomladb

  joomladb:
    // highlight-next-line
    image: postgres:16.0-alpine
    container_name: kingsbridge-db
    restart: always
    environment:
      // highlight-next-line
      - POSTGRES_DB=joomla_db
      // highlight-next-line
      - POSTGRES_USER=postgres
      // highlight-next-line
      - POSTGRES_PASSWORD=example
```

Maintenant, pendant la configuration de Joomla, veillez à choisir `PostgreSQL (PDO)` comme type de base et à remplir l'assistant avec les bonnes valeurs.

> **Utilisez des images alpine dès que possible:**
>
> Pour la première fois dans ce tutoriel, nous utilisons une image `alpine` (`postgres:16.0-alpine` ici). Ces images sont plus légères qu'une image non-alpine. Elles contiennent le strict nécessaire pour faire tourner le service, alors qu'une image *traditionnelle* contient des outils, binaires... supplémentaires dont vous pourriez avoir besoin mais que vous n'utiliserez pas forcément.

**Utiliser MariaDB**

Si vous comptez utiliser MariaDB, voici l'image officielle Docker : <https://hub.docker.com/_/mariadb>.

**compose.yaml**

```yaml
name: kingsbridge

services:
  joomla:
    image: joomla
    container_name: kingsbridge-app
    restart: always
    ports:
      - 8080:80
    environment:
      - JOOMLA_DB_HOST=joomladb
      - JOOMLA_DB_PASSWORD=example
    depends_on:
      - joomladb

  joomladb:
    // highlight-next-line
    image: mariadb:11.1.2
    container_name: kingsbridge-db
    restart: always
    environment:
      - MYSQL_ROOT_PASSWORD=example
```

Pour MariaDB, sélectionnez `MySQLi` dans l'assistant d'installation.

## Informations complémentaires {#extra-information}

### Le container sera redémarré par Windows {#the-container-will-be-restarted-by-windows}

Si vous éteignez votre ordinateur alors qu'un ou plusieurs containers tournent encore, Docker les relancera au démarrage suivant.

Autrement dit, la prochaine fois que vous démarrez votre ordinateur, votre site sera toujours accessible et vous n'aurez pas une seule commande à lancer. C'est tellement simple !

### Travailler avec Windows {#working-with-windows}

Imaginez que vous soyez dans votre console (par exemple après un `cd /tmp/joomla` dans la console Linux) et que vous vouliez ouvrir le site avec Visual Studio Code, déjà installé sur votre machine Windows.

C'est facile : lancez simplement `code .` pour ouvrir le dossier courant, donc votre projet, dans vscode.

Autre cas d'usage : vous voulez démarrer l'Explorateur Windows et naviguer dans la structure de votre projet. Là aussi c'est possible, lancez simplement `explorer.exe .` pour l'ouvrir sur le répertoire courant. Voyez mon article « [Ouvrir votre dossier Linux dans l'Explorateur Windows](/blog/wsl-windows-explorer) » pour en savoir plus sur cette fonctionnalité.

## Bonus - Installer Joomla avec une seule ligne de commande {#bonus---install-joomla-with-a-cli-one-liner}

Le `compose.yaml` utilisé au début de cet article était le minimum. Voici la version **finale**, avec tout ce que nous avons ajouté depuis : un nom de projet, des noms de containers explicites et les deux volumes pour que votre site et votre base survivent à un `docker compose down`.

Cliquez simplement sur `Generate install script` ci-dessous, copiez/collez le script dans votre console, exécutez-le et suivez les instructions. Après quelques secondes, vous aurez un site Joomla fonctionnel — un que vous pourrez vraiment garder.

**Project: /tmp/joomla**

> **Note:**
>
> Maintenant, lancez 'UID=$(id -u) GID=$(id -g) docker compose up --detach'
> pour créer votre site Joomla. Patientez un peu et ouvrez votre navigateur,
> rendez-vous sur <http://localhost:8080> pour ouvrir votre site Joomla. Le type
> de base de données doit être `MySQLi`, le nom de l'host doit être
> `joomladb`, l'utilisateur doit être `root` et le mot de passe de cet
> utilisateur doit être `example`.

**compose.yaml**

```yaml
name: yourprojectname

services:
  joomla:
    image: joomla:6.0.1-php8.3-apache
    container_name: kingsbridge-app
    restart: always
    ports:
      - 8080:80
    environment:
      - JOOMLA_DB_HOST=joomladb
      - JOOMLA_DB_PASSWORD=example
    depends_on:
      joomladb:
        condition: service_healthy
    user: ${UID:-1000}:${GID:-1000}
    volumes:
      - ./site_joomla:/var/www/html

  joomladb:
    image: mysql:8.0.13
    container_name: kingsbridge-db
    restart: always
    environment:
      - MYSQL_ROOT_PASSWORD=example
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      timeout: 20s
      retries: 10
    user: ${UID:-1000}:${GID:-1000}
    volumes:
      - ./db:/var/lib/mysql
```

(create empty directory: site\_joomla)

(create empty directory: db)

> **Caution:**
>
> Veillez, pour chaque projet, à mettre à jour la ligne `name:` et, si vous comptez faire tourner vos sites Joomla en parallèle, à mettre à jour le numéro de port de Joomla en en choisissant un nouveau à chaque fois (ce peut être `80`, `81`, `82` et ainsi de suite).

## Conclusion {#conclusion}

Ce que je préfère dans cette approche, ce n'est pas la vitesse — c'est qu'un site Joomla devient un *dossier*. Un `compose.yaml`, deux sous-dossiers, et vous pouvez en avoir cinq côte à côte, chacun sur son port, chacun avec sa base, sans qu'aucun ne puisse casser les autres. Supprimer un site, c'est supprimer un dossier.

À partir d'ici, deux suites naturelles : [Create your Joomla website using Docker - Part 2](/blog/docker-joomla-part-2) va plus loin sur le workflow au quotidien, et [Utiliser Adminer, pgadmin ou phpmyadmin](/blog/docker-adminer-pgadmin-phpmyadmin) montre comment parcourir la base de données qui vient d'être créée pour vous.


---

<!--
  canonical-url: https://www.avonture.be/fr/blog/docker-php-ini
  published:     2023-12-22
  This is a static plain-Markdown mirror generated at build time.
  Visit the canonical URL above for the fully rendered page, with images and interactive components.
-->

# Mettre à jour php.ini quand on utilise une image Docker

> Un guide pas à pas pour mettre à jour votre fichier php.ini dans un container Docker via un volume monté dans compose.yaml. Réglez les problèmes courants comme la taille maximale d'upload.

---
![Mettre à jour php.ini quand on utilise une image Docker](/img/v2/docker_tips.webp)

**TL;DR**

Cet article montre comment surcharger les réglages de `php.ini` (p. ex. la taille maximale d'upload) sur un site PHP dockerisé : créez un fichier `php.ini` local, montez-le par-dessus le fichier de config du container via une entrée `volumes` dans `compose.yaml`, puis lancez `docker compose down && docker compose up --detach` pour appliquer le changement.

Cet article répond à la situation suivante : *j'utilise une image Docker pour faire tourner mon site et je dois modifier le fichier php.ini ; comment faire ?*

Un exemple concret : vous avez suivi mon article [Créez votre site web Joomla avec Docker](/blog/docker-joomla) et tout fonctionne bien. Le site tourne, et vous voulez uploader un gros fichier via l'interface d'administration de Joomla. Et là, vous obtenez l'erreur *The selected file cannot be transferred because it is larger than the maximum upload size allowed*.

![Vos réglages PHP avant modification](./images/before.webp)

Une des façons les plus simples de faire est de créer un fichier `.ini` sur votre disque et de [le partager avec votre container](/blog/docker-volume).

Vous avez très probablement un fichier `compose.yaml` ; ouvrez-le dans votre éditeur.

Pour l'illustration, vous trouverez ci-dessous une copie du fichier `compose.yaml` le plus simple que vous pouvez récupérer dans mon article [Créez votre site web Joomla avec Docker](/blog/docker-joomla). *Le vôtre peut évidemment être différent.* C'est juste pour l'exemple.

**compose.yaml**

```yaml
services:
  joomla:
    image: joomla
    restart: always
    ports:
      - 8080:80
    environment:
      - JOOMLA_DB_HOST=joomladb
      - JOOMLA_DB_PASSWORD=example

  joomladb:
    image: mysql:8.0.13
    restart: always
    environment:
      - MYSQL_ROOT_PASSWORD=example
```

## Étape un - Mettre à jour votre fichier yaml {#step-one---update-your-yaml-file}

La solution consiste à ajouter la ligne `volumes` si elle n'est pas déjà présente dans votre fichier et, surtout, la ligne qui *surcharge* le fichier `php.ini` comme ci-dessous :

**compose.yaml**

```yaml
services:
  joomla:
    image: joomla
    restart: always
    ports:
      - 8080:80
    environment:
      - JOOMLA_DB_HOST=joomladb
      - JOOMLA_DB_PASSWORD=example
    # highlight-next-line
    volumes:
      # highlight-next-line
      - ./php.ini:/usr/local/etc/php/php.ini

  joomladb:
    image: mysql:8.0.13
    restart: always
    environment:
      - MYSQL_ROOT_PASSWORD=example
```

## Étape deux - Créer votre propre fichier php.ini {#step-two---create-your-own-phpini-file}

La deuxième chose à faire est de créer un fichier appelé `php.ini` dans le même dossier que votre `compose.yaml`, où vous définirez vos variables ; par exemple :

**php.ini**

```ini
file_uploads = On
memory_limit = 500M
upload_max_filesize = 500M
post_max_size = 500M
max_execution_time = 600
```

Votre dossier contient donc maintenant au moins deux fichiers :

```bash
$ pwd
/tmp/joomla

$ ls -alh
Permissions Size User       Group      Date Modified    Name
drwxr-xr-x     - christophe christophe 2023-11-04 09:32  .
drwxrwxrwt     - christophe christophe 2023-11-04 09:32 ..
.rw-r--r--   325 christophe christophe 2023-11-04 09:32 compose.yaml
-rw-r--r--     1 christophe christophe 2023-12-22 19:51 php.ini
```

## Étape trois - Redémarrer votre container {#step-three---restart-your-container}

Ceci fait, lancez simplement `docker compose down ; docker compose up --detach` dans votre terminal pour arrêter votre/vos container(s) actuel(s) et le/les redémarrer.

Au redémarrage, Docker prendra en compte vos derniers changements et mettra à jour le fichier `php.ini` présent dans Docker.

![Vos réglages PHP après modification](./images/after.webp)


---

<!--
  canonical-url: https://www.avonture.be/fr/blog/docker-joomla-right-to-the-point
  published:     2024-10-03
  This is a static plain-Markdown mirror generated at build time.
  Visit the canonical URL above for the fully rendered page, with images and interactive components.
-->

# Démarrer Joomla avec Docker en quelques clics

> Lancez votre site Joomla avec Docker en quelques clics ! Suivez ce guide rapide et direct pour démarrer votre projet Joomla instantanément grâce à une configuration Docker Compose toute simple.

---
![Démarrer Joomla avec Docker en quelques clics](/img/v2/joomla.webp)

**TL;DR**

Voici un guide minimaliste, sans fioritures, pour lancer Joomla avec Docker : copiez le snippet officiel `compose.yaml` depuis Docker Hub, lancez `docker compose up --detach` et connectez-vous sur `http://127.0.0.1:8080/administrator` avec les identifiants par défaut `joomla`/`joomla@secured` définis dans ce fichier.

Hier midi, en discutant avec un ami, il m'a lancé un défi tout simple : expliquer la manière la plus facile au monde de démarrer un projet Joomla avec Docker.

L'objectif : hop, hop, on copie/colle un fichier, hop, Joomla est lancé et vous pouvez commencer à jouer avec le site.

*Trois choses dont vous aurez envie très vite : un [volume](/blog/docker-volume) pour que le site survive à un `docker compose down`, [Adminer ou phpmyadmin](/blog/docker-adminer-pgadmin-phpmyadmin) pour regarder à l'intérieur de la base de données, et [Update php.ini when using a Docker image](/blog/docker-php-ini) le jour où Joomla refusera votre upload de fichier parce qu'il est trop gros.*

Regardons ça ; pas en détail, mais droit au but.

**Voici les quelques étapes à suivre pour démarrer votre site Joomla avec Docker :**

1. Rendez-vous sur <a href="https://hub.docker.com/_/joomla"><https://hub.docker.com/_/joomla></a>

2. Descendez jusqu'à voir le contenu `yaml` et cliquez sur le bouton `Copy`. Ce bouton apparaît quand le pointeur de la souris survole le texte (il est caché sinon)

3. Sur votre ordinateur, créez un nouveau fichier appelé `compose.yaml` et collez-y le contenu

4. Le plus difficile arrive maintenant : ouvrez une nouvelle console et allez dans le dossier où vous venez de créer le fichier (dans mon cas, j'ai créé le fichier dans mon dossier `/tmp/joomla`, donc j'y saute avec `cd /tmp/joomla`)

5. Toujours dans votre console, lancez `docker compose up --detach`.

À partir de là, Docker va télécharger (uniquement la première fois) le CMS Joomla, PHP, Apache et MySQL. Ensuite, Docker démarrera les images téléchargées (appelées containers).

Rendez-vous sur `http://127.0.0.1:8080/administrator` et profitez !

> Screenshot — http\://127.0.0.1:8080/administrator
>
> ![Administration Joomla](./images/administrator.webp)

> **Caution:**
>
> Le compte admin à utiliser est `joomla` et son mot de passe est `joomla@secured` (tel que défini dans le fichier yaml que vous venez de copier).

> **Information:**
>
> Cet article est volontairement simple ; suivez le tag [Joomla](/blog/tags/joomla) si vous voulez aller plus loin que cette introduction.


---

<!--
  canonical-url: https://www.avonture.be/fr/blog/docker-joomla-part-2
  published:     2024-10-18
  This is a static plain-Markdown mirror generated at build time.
  Visit the canonical URL above for the fully rendered page, with images and interactive components.
-->

# Créez votre site Joomla avec Docker - Partie 2

> Créez votre site Joomla persistant avec Docker en une seule commande. Ce guide (Partie 2) se concentre sur l'automatisation avancée avec compose.yaml et makefile.

---
![Créez votre site Joomla avec Docker - Partie 2](/img/v2/joomla.webp)

**TL;DR**

Ce guide détaille comment automatiser le développement local de Joomla avec
Docker en combinant les configurations `compose.yaml`, `.env` et `makefile`
pour déployer des sites entièrement configurés en une seule commande. Il
explique comment contourner l'assistant d'installation standard en
prédéfinissant des variables d'environnement et montre comment gérer
plusieurs projets isolés avec différentes versions de Joomla et de PHP en
même temps sur une seule machine. Le tutoriel fournit des exemples de
configuration concrets pour garantir la persistance des données et permettre
un fonctionnement sans conflit entre instances concurrentes.

Fin 2023, j'ai écrit un très long article sur l'utilisation de Joomla avec Docker : [Create your Joomla website using Docker - Part 1](/blog/docker-joomla).

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.

> **Caution:**
>
> Voici le lien vers cet article : [Create your Joomla website using Docker - Part 1](/blog/docker-joomla).

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`.

**Quick Jump:** [Voir le résultat](#result) | [Avant de commencer](#before-starting)

## Résultat {#result}

```bash
$ 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.

> Screenshot — http\://127.0.0.1:8080/installation/index.php
>
> ![Installateur Joomla](./images/joomla_installer.webp)

> **Hé ! vous avez remarqué ?:**
>
> Nous avons créé notre site Joomla en **lançant une seule commande**. Vous ne me croyez pas ? Ouvrez votre navigateur et allez sur `http://127.0.0.1:8080`.

## Pourquoi ça fonctionne {#why-it-works}

* `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 {#create-the-three-configuration-files}

Contrairement à l'article [Create your Joomla website using Docker - Part 1](/blog/docker-joomla), 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 {#our-orchestration-file-composeyaml}

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.

> **Persistance:**
>
> Il existe deux types de persistance : celle gérée nativement par Docker (*volumes internes*) ou celle où nous voyons les fichiers dans le dossier de notre projet (*volumes montés*). Nous opterons pour la seconde. Voyez mon article [Using volumes with Docker, use cases](/blog/docker-volumes) si vous voulez en savoir plus.

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.

> **Note:**
>
> Ces derniers mois, le nom du fichier à utiliser est passé de `docker-compose.yaml` à `compose.yaml` ; l'ancien nom est toujours supporté pour l'instant, mais autant utiliser le nouveau. Voyez [docs.docker.com](https://docs.docker.com/compose/intro/compose-application-model/#the-compose-file) si vous voulez plus d'infos sur ce changement.

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 :

```bash
$ mkdir /tmp/joomla && cd $_
```

**compose.yaml**

```yaml
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 {#well-use-a-configuration-file-called-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 :

**.env**

```
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.

> **Information:**
>
> `WEB_PORT`, `PROJECT_NAME`, ... ne sont que des *variables*. Si vous regardez à nouveau le contenu du `compose.yaml` que vous venez de copier/coller, vous retrouverez ces variables, par exemple sur la ligne `image: joomla:${JOOMLA_VERSION:-latest}`.
>
> La syntaxe `${XXX:-yyy}` signifie : si la variable existe, utilise-la (la partie `XXX`), sinon utilise une valeur par défaut (la partie `yyy`).
>
> Donc ici, si `JOOMLA_VERSION` existe, et c'est le cas dans notre fichier `.env`, alors sa valeur est utilisée. Nous aurons donc `image: joomla:5.2.0-php8.3-apache`. Si `JOOMLA_VERSION` était absente de notre `.env`, alors nous utiliserions `latest` et donc `image: joomla:latest`.

### Simplifions-nous la vie et soyons paresseux ; utilisons un makefile {#lets-make-our-lives-simpler-and-lazier-using-a-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.

> **Caution:**
>
> Si vous ne savez pas si `GNU make` est déjà installé, lancez simplement `which make` dans la console. Si vous voyez `make not found`, exécutez `sudo apt-get update && sudo apt-get install make` pour terminer l'installation.
>
> ```bash
> $ which make
> ```
>
> ```bash
> $ sudo apt-get update && sudo apt-get install make
> ```

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

**makefile**

```
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
```

> **L'indentation doit utiliser des TAB, pas des espaces:**
>
> C'est terriblement vicieux parce que c'est totalement silencieux :
> l'indentation dans un makefile doit être faite avec des tabulations, pas des
> espaces. Quand vous copiez/collez le code ci-dessus pour créer votre fichier,
> assurez-vous que votre éditeur de texte utilise des tabulations. Sinon, les
> commandes définies dans le fichier ne fonctionneront pas.

> **Note:**
>
> Si vous voulez en savoir plus sur GNU Make, consultez mon article [Linux Makefile - When to use a makefile](/blog/makefile-using-make)

## Avant de commencer {#before-starting}

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

**Project: /tmp/joomla**

> **Note:**
>
> Maintenant, lancez 'UID=$(id -u) GID=$(id -g) docker compose up --detach'
> pour créer votre site Joomla. Patientez un peu et ouvrez votre navigateur,
> allez sur <http://localhost:8080> pour ouvrir votre site Joomla. Le type de
> base de données doit être `MySQLi`, le nom de l'host doit être `joomladb`,
> le nom d'utilisateur doit être `root` et le mot de passe de cet utilisateur
> doit être `example`.

**.env**

```
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
```

**compose.yaml**

```yaml
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:
```

**makefile**

```
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
```

```bash
$ 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 {#check-our-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é)*.

```bash
$ make config
```

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

```yaml
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
```

> **Information:**
>
> La sortie ci-dessus est un **contenu partiel** et ne montre que les premières lignes affichées dans la console par la commande `make config`.

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.

> **UID/GID:**
>
> Le **user\_id:group\_id** varie selon votre propre configuration. Ce sera `1000:1000` dans la plupart des cas, mais ça peut être autre chose si, par exemple, vous avez défini plus d'un utilisateur dans votre distribution Linux ; le premier utilisateur sera probablement `1000:1000`, le second `1001:1001` et ainsi de suite.

## Réveillons Joomla... {#lets-wake-up-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 :

```bash
$ {`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`.

> **Information:**
>
> Le port `8080` est celui spécifié dans notre `.env` (variable `WEB_PORT`) et, pareil pour MySQL, il utilise le port `3006` parce que c'est celui que nous avons défini (`MYSQL_PORT`).
>
> Notez que `3306` est le port standard de MySQL.

### ... ou demandons-lui de s'endormir (on garde les containers) {#-or-lets-ask-him-to-fall-asleep-keep-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.

```bash
$ make stop
```

### ... ou demandons-lui de supprimer les containers (libérer plus de mémoire) {#-or-lets-ask-him-to-remove-containers-free-more-memory}

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.

```bash
$ make down
```

### ... ou demandons-lui de se suicider (supprimer les containers et les fichiers) {#-or-lets-ask-him-to-suicide-remove-containers-and-files}

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

```bash
$ make reset
```

> **Danger:**
>
> En lançant `make reset`, vous perdrez tout et serez prêt à créer un nouveau site.

## Il est temps de démarrer le site {#time-to-starting-the-website}

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

```bash
$ 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 :

```bash
$ make start
```

```none
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 {#time-for-a-break}

**Qu'avons-nous vu jusqu'ici ?**

* Sans rien d'autre que Docker, vous pouvez installer Joomla et MySQL depuis la ligne de commande, dans la version que vous voulez ;

* Qu'avec un fichier `.env` nous pouvons faire varier certaines valeurs pour avoir plusieurs projets sur notre disque dur (plusieurs sites Joomla) ;

* Qu'avec le fichier `compose.yaml` nous disons à Docker quoi faire pour que Joomla et MySQL se parlent, et

* Que le fichier `compose.yaml` est précieux puisqu'il permet de définir un certain nombre de variables de configuration.

Allons un peu plus loin.

## Configuration avancée pour Joomla {#advanced-configuration-for-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 :

| Nom de la variable        | Description                                                                                       |
| ------------------------- | ------------------------------------------------------------------------------------------------- |
| `JOOMLA_DB_HOST`          | Par défaut, l'IP et le port du container mysql lié                                                |
| `JOOMLA_DB_USER`          | `root` par défaut                                                                                 |
| `JOOMLA_DB_PASSWORD`      | Par défaut, la valeur de la variable d'environnement `MYSQL_ROOT_PASSWORD` du container mysql lié |
| `JOOMLA_DB_PASSWORD_FILE` | Chemin vers un fichier contenant le mot de passe de la base                                       |
| `JOOMLA_DB_NAME`          | `joomla` par défaut                                                                               |
| `JOOMLA_DB_TYPE`          | `mysqli` par défaut ; options : `mysqli`, `pgsql`                                                 |

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 :

| Nom de la variable        | Description                                                                           |
| ------------------------- | ------------------------------------------------------------------------------------- |
| `JOOMLA_SITE_NAME`        | Nom du site Joomla                                                                    |
| `JOOMLA_ADMIN_USER`       | Nom complet de l'administrateur Joomla                                                |
| `JOOMLA_ADMIN_USERNAME`   | Nom d'utilisateur de l'administrateur Joomla                                          |
| `JOOMLA_ADMIN_PASSWORD`   | Mot de passe de l'administrateur Joomla                                               |
| `JOOMLA_ADMIN_EMAIL`      | Adresse e-mail de l'administrateur Joomla                                             |
| `JOOMLA_EXTENSIONS_URLS`  | Liste d'URLs séparées par des points-virgules pour installer des extensions Joomla    |
| `JOOMLA_EXTENSIONS_PATHS` | Liste de chemins séparés par des points-virgules pour installer des extensions Joomla |
| `JOOMLA_SMTP_HOST`        | Host SMTP pour les e-mails sortants                                                   |
| `JOOMLA_SMTP_HOST_PORT`   | Port SMTP pour les e-mails sortants                                                   |

Faites attention au dernier tableau ci-dessus.

> **Plutôt cool !:**
>
> Nous pourrions donc complètement ignorer les écrans de configuration de Joomla !!! En spécifiant certaines valeurs, nous pourrions installer un beau Joomla tout neuf et afficher directement un site fonctionnel.

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 {#updated-composeyaml}

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

**compose.yaml**

```yaml
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 {#updated-env}

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

**.env**

```
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 {#updated-makefile}

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

**makefile**

```
-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 {#running-the-website-and-skip-the-installation-process}

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 :

```bash
$ make reset && make up && make start
```

```none
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 {#time-for-a-second-break}

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 {#starting-three-different-projects}

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

```bash
$ 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` :

```tree expanded=true showJSX=false debug=false title="/tmp/joomla"
├── project_1
│   ├── .env
│   ├── compose.yaml
│   └── makefile
├── project_2
│   ├── .env
│   ├── compose.yaml
│   └── makefile
└── project_3
    ├── .env
    ├── compose.yaml
    └── makefile
```

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

> **Note:**
>
> La commande `tree` n'est pas native sous Linux. Si vous voulez l'installer, lancez simplement `sudo apt-get update && sudo apt-get install tree`.
>
> ```bash
> $ sudo apt-get update && sudo apt-get install tree
> ```

### Projet 1 - Joomla 5.2 {#project-1---joomla-52}

> **Le projet 1 sera un Joomla 5.2:**
>
> En très peu de mots : nous allons installer Joomla 5.2 et MySQL 8.4.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 :

**project\_1/.env**

```
// 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).

> Screenshot — http\://127.0.0.1:8081/administrator/
>
> ![Notre premier site tourne sous Joomla 5.2](./images/project_1.webp)

> **Caution:**
>
> Faites bien attention à indiquer le numéro de port de notre projet. Pour le projet 1, le numéro de port est `8081`. C'est en fait ce que nous avons voulu en définissant la variable `WEB_PORT`.
>
> Donc, pour accéder au premier projet, notre URL est bien `http://127.0.0.1:8081`.

### Projet 2 - Joomla 4.0 {#project-2---joomla-40}

> **Le projet 2 sera un Joomla 4.0:**
>
> En très peu de mots : nous allons installer Joomla 4.0 et MySQL 5.7.37.

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` :

**project\_2/.env**

```
// 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.

```bash
$ make up
```

> Screenshot — http\://127.0.0.1:8082/administrator
>
> ![Nos deux projets Joomla tournent](./images/project_1_2.webp)

> **Deux sites Joomla avec deux versions différentes de PHP et MySQL et ... aucun conflit !:**
>
> Vous avez vu ? Nous avons deux sites qui tournent sur notre ordinateur. Le premier est un Joomla 5.2 et le second un Joomla 4.0.
>
> Si vous êtes toujours réveillé après ce long article, pour accéder à notre deuxième site, il faut aller sur `http://127.0.0.1:8082`.

### Projet 3 - Joomla 3.5 {#project-3---joomla-35}

> **Le projet 3 sera un Joomla 3.5:**
>
> Et maintenant, vous devez faire de la maintenance sur un vieux site J3.5. Créons-en un sur notre ordinateur.

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

Cette fois, nous utiliserons `3` comme suffixes :

**project\_3/.env**

```
// 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.

```bash
$ make up && make start
```

> Screenshot — http\://127.0.0.1:8083/administrator
>
> ![Nos trois projets Joomla sont actifs en même temps sur notre machine de développement](./images/project_1_2_3.webp)

> **Juste wow non ?:**
>
> Trois versions différentes de Joomla, de MySQL et aussi de PHP, et aucun conflit !
>
> En fait, rien d'étonnant, c'est normal avec Docker : tout est isolé dans son propre container. 😊

### Démarrer les trois projets en une seule commande {#start-all-three-projects-in-just-one-command}

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

```bash
$ cd project_1 && make up && cd ../project_2 && make up && cd ../project_3 &&
make up
```

Voici ce que vous pouvez obtenir :

```bash
$ 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 ? {#other-projects-how-many-sites-can-i-have}

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).

![Docker desktop](./images/docker_desktop.webp)

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.

```bash
$ ( 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.

![Le premier et le troisième projet sont libérés](./images/docker_desktop_stopped.webp)

> **Note:**
>
> Dans notre exemple ici, nous n'avons gardé que le deuxième projet, nous pouvons donc toujours travailler sur `http://127.0.0.1:8082/` mais les deux autres projets (`http://127.0.0.1:8081/` et `http://127.0.0.1:8083/`) ne répondront plus. Nous les avons arrêtés.
>
> Relancez simplement `make up` dans le dossier `project_1` par exemple pour remettre le site en vie. Ou, si vous préférez l'interface graphique, dans Docker Desktop, cliquez juste sur le bouton `Start` :
>
> ```bash
> $ ( cd project_1 && make up )
> ```
>
> ![Démarrer un container dans Docker Desktop](./images/docker_desktop_start.webp)

## Sous le capot : les logs Docker {#under-the-hood-docker-logs}

*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.

```bash
$ make log
```

Les logs ressembleront à ceci :

```log
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 {#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 : [Restore a Joomla backup using Docker](/blog/docker-joomla-restore-jpa)


---

<!--
  canonical-url: https://www.avonture.be/fr/blog/docker-joomla-restore-jpa
  published:     2024-10-18
  This is a static plain-Markdown mirror generated at build time.
  Visit the canonical URL above for the fully rendered page, with images and interactive components.
-->

# Restaurer une sauvegarde Joomla avec Docker

> Restaurez facilement la sauvegarde de votre site Joomla en local avec Docker, Docker Compose et Akeeba Kickstart. Une simple commande make import suffit.

---
![Restaurer une sauvegarde Joomla avec Docker](/img/v2/joomla.webp)

**TL;DR**

Ce guide explique comment restaurer un site Joomla en local en combinant
Docker, une archive Akeeba Backup et l'utilitaire Akeeba Kickstart. On
configure un environnement sur mesure avec PHP et Apache, puis on lance une
simple commande d'import pour déployer les fichiers et les containers
nécessaires. Le processus se termine dans le navigateur, via l'assistant
Kickstart, pour finaliser la connexion à la base de données et la restauration
du site.

Dans les articles précédents ([Partie 1](/blog/docker-joomla) et [Partie 2](/blog/docker-joomla-part-2)), nous avons vu comment créer un site Joomla de zéro avec Docker : récupérer Joomla, PHP, Apache et MySQL depuis Docker Hub et faire un peu de magie pour obtenir un site local tout neuf sur `http://127.0.0.1:8080`.

Dans cet article, nous allons voir comment restaurer sur notre machine une sauvegarde créée grâce à l'excellent composant **[Akeeba Backup](https://www.akeeba.com/products/akeeba-backup.html)**.

Nous allons réutiliser certains fichiers de la [Partie 2](/blog/docker-joomla-part-2) et les adapter.

À la fin, nous aurons une commande `make import` qui démarrera **[Akeeba Kickstart](https://www.akeeba.com/download.html#kickstart)**.

## Résultat {#result}

Renseignez les informations de base de données affichées dans votre console, et Akeeba Kickstart s'occupe du reste —
d'une sauvegarde `.jpa` brute à un site consultable :

![Akeeba Kickstart](./images/kickstart.webp)

![Restauration de la base de données](./images/database.webp)

![Le site est restauré](./images/site_is_restored.webp)

## Pourquoi ça fonctionne {#why-it-works}

* Nous réutilisons le même trio `compose.yaml`/`.env`/`makefile` que dans la [Partie 2](/blog/docker-joomla-part-2), donc rien de neuf à apprendre là-dessus.
* Le seul vrai changement : comme la sauvegarde **est** déjà un site Joomla complet, les containers n'ont besoin que de PHP et Apache, pas d'une image Joomla fraîche — la base de données est reconstruite depuis la sauvegarde par Akeeba Kickstart, et non par l'installateur de Joomla.

## Créer les fichiers nécessaires {#creating-required-files}

> **Passer l'étape de création des fichiers:**
>
> Dans les chapitres suivants, vous devrez créer plusieurs fichiers par copier/coller. Si vous voulez aller plus vite, lancez simplement les commandes ci-dessous pour récupérer les fichiers depuis mon [repo Github](https://github.com/cavo789/docker_joomla_restore), vous n'aurez ainsi pas à les créer.
>
> ```bash
>   $ mkdir /tmp/joomla_restore && cd $_ $ curl -LOJ --silent
>   https://github.com/cavo789/docker_joomla_restore/archive/refs/tags/1.0.0.tar.gz
>   $ tar -xzvf docker_joomla_restore-1.0.0.tar.gz --strip-components 1 && rm -f
>   docker_joomla_restore-1.0.0.tar.gz $ tar -xzvf docker_joomla_restore.gz
>   --strip-components 1 && rm -f docker_joomla_restore.gz
> ```
>
> En suivant les instructions ci-dessous, vous créerez un dossier xxx dans lequel copier tous les fichiers nécessaires à la restauration d'un site Joomla avec Docker. Vous pouvez alors passer directement au chapitre « Lancer le processus d'importation », les fichiers étant déjà en place.

*Si vous préférez comprendre ce que vous faites et créer les fichiers à la main, poursuivez la lecture ci-dessous.*

Créez un nouveau dossier sur votre machine, par exemple `mkdir /tmp/joomla_restore && cd $_`.

```bash
$ mkdir /tmp/joomla_restore && cd $_
```

Dans ce dossier, vous devrez créer plusieurs fichiers (référez-vous à la [Partie 2](/blog/docker-joomla-part-2) si vous avez besoin de plus d'explications sur ces fichiers).

### Le fichier d'orchestration : compose.yaml {#the-orchestration-file-composeyaml}

Ci-dessous, en surbrillance, les petites différences par rapport au fichier `compose.yaml` vu dans la [Partie 2](/blog/docker-joomla-part-2#updated-composeyaml).

Voici pourquoi : cette fois, nous n'avons pas besoin de télécharger une copie fraîche de Joomla puisque **nous avons déjà un site Joomla** (notre sauvegarde). Ce dont nous avons besoin, c'est de **PHP** et **Apache**. Pas de Joomla, donc nous utiliserons cette fois une image Docker sur mesure, pas une image existante.

À part les lignes en surbrillance, tout le reste est identique à la [Partie 2](/blog/docker-joomla-part-2).

**compose.yaml**

```yaml
name: ${PROJECT_NAME:-your-project-name}

services:
  joomla:
    # highlight-next-line
    build:
      # highlight-next-line
      context: .
      # highlight-next-line
      args:
        # highlight-next-line
        - PHP_VERSION=${PHP_VERSION:-8.3-apache}
    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_ROOT_PASSWORD=${DB_ROOT_PASSWORD:-rootpass}
      - 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

  phpmyadmin:
    image: phpmyadmin
    container_name: ${CONTAINER_PREFIX:-joomla}-phpmyadmin
    restart: always
    depends_on:
      joomladb:
        condition: service_healthy
    ports:
      - 8081:80
    environment:
      - PMA_HOST=joomladb
      - PMA_PASSWORD=${DB_ROOT_PASSWORD:-rootpass}
    networks:
      - joomla_network

networks:
  joomla_network:
```

### Le fichier .env {#the-env-file}

Comme indiqué plus haut, nous n'avons plus besoin de Joomla, juste de PHP et Apache. Nous allons donc définir une variable `PHP_VERSION` et l'initialiser à la version voulue.

**.env**

```
CONTAINER_PREFIX=joomla
DB_NAME=joomla
DB_PASSWORD=examplepass
DB_USER=joomla
MYSQL_PORT=3306
MYSQL_VERSION=8.4.2
// highlight-next-line
PHP_VERSION=8.3-apache
PROJECT_NAME=running-joomla-in-docker
WEB_PORT=8080
```

> **Caution:**
>
> Comme nous devons restaurer un site existant, veillez à utiliser la même version de PHP que celle utilisée par votre site.

### Notre makefile {#our-makefile}

Il nous faut une nouvelle action appelée `import` :

**makefile**

```
-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

# highlight-next-line
import: reset
    # highlight-next-line
	-@mkdir -p db_data joomla_data
    # highlight-next-line

    # highlight-next-line
	@clear
    # highlight-next-line
	@printf "\033[1;33m%s\033[0m\n" "Copying Akeeba Kickstart to the Docker Joomla container..."
    # highlight-next-line
	@cp en-GB.kickstart.ini ./joomla_data
    # highlight-next-line
	@cp kickstart.php ./joomla_data/kickstart.php
    # highlight-next-line

    # highlight-next-line
	@printf "\033[1;33m%s\033[0m\n\n" "Copying your backup to the Docker Joomla container..."
    # highlight-next-line
	@cp backup.jpa ./joomla_data
    # highlight-next-line

    # highlight-next-line
	@UID=$$(id -u) GID=$$(id -g) docker compose up --detach
    # highlight-next-line

    # highlight-next-line
	@printf "\n\n\033[1;33m%s\033[0m\n\n" "Please now jump to http://127.0.0.1:${WEB_PORT}/kickstart.php to finalize your site restoration."
    # highlight-next-line

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

    # highlight-next-line
	@printf "\033[1;34m%s\033[0m\n\n" "JOOMLA"
    # highlight-next-line
	@printf "\033[1;34m%-30s\033[0m\033[1;104m%s\033[0m\n\n" "  * Port" "${WEB_PORT}"
    # highlight-next-line

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

> **Caution:**
>
> Si vous ne savez pas si vous avez déjà `GNU make`, lancez simplement `which make` dans la console. Si vous voyez `make not found`, lancez `sudo apt-get update && sudo apt-get install make` pour procéder à l'installation.
>
> ```bash
> $ which make
> ```
>
> ```bash
> $ sudo apt-get update && sudo apt-get install make
> ```

### Il nous faut aussi un fichier appelé Dockerfile {#we-also-need-a-file-called-dockerfile}

Dans les toutes premières lignes du fichier `compose.yaml`, nous avons ce passage :

**compose.yaml**

```yaml
name: ${PROJECT_NAME:-your-project-name}

services:
  joomla:
    # highlight-next-line
    build:
      # highlight-next-line
      context: .
      # highlight-next-line
      args:
        # highlight-next-line
        - PHP_VERSION=${PHP_VERSION:-8.3-apache}
```

On n'y voit pas d'instruction `image:` mais un `build:`. Cela signifie qu'il nous faut un fichier spécial appelé `Dockerfile`.

Créez un nouveau fichier appelé `Dockerfile` dans votre dossier avec ce contenu :

**Dockerfile**

```docker
ARG PHP_VERSION=8.3-apache

FROM php:${PHP_VERSION:-latest}

RUN set -e -x ; \
    docker-php-ext-install mysqli pdo pdo_mysql && docker-php-ext-enable pdo_mysql
```

Ce fichier est assez simple pour l'instant : il indique qu'il nous faut une image Docker PHP, et qu'il faut aussi installer les drivers `mysqli`.

### Il nous faut une sauvegarde, évidemment {#we-need-a-backup-for-sure}

Placez également une sauvegarde de votre site existant dans le même dossier. Par souci de standardisation, nommez ce fichier `backup.jpa`.

Pour être plus explicite : rendez-vous sur votre site Joomla existant et, avec Akeeba Backup, créez une sauvegarde (format de fichier : `.jpa`) puis téléchargez-la. Renommez le fichier de sauvegarde ainsi : `backup.jpa`.

### Et enfin, il nous faut Akeeba Kickstart {#and-finally-we-need-akeeba-kickstart}

Enfin, il nous faut aussi deux fichiers provenant d'**[Akeeba Kickstart](https://www.akeeba.com/download.html#kickstart)**.

En suivant le lien [Akeeba Kickstart](https://www.akeeba.com/download.html#kickstart), nous pourrons télécharger un fichier `.zip` (appelé `kickstart-core-xxx.zip` où `xxx` est un numéro de version). Téléchargez-le et ouvrez l'archive : elle contient deux fichiers. Copiez-les dans votre dossier.

Les deux fichiers dont nous avons besoin s'appellent `en-GB.kickstart.ini` et `kickstart.php`.

## Avant de démarrer {#before-starting}

Nous sommes prêts. Juste avant de commencer, vérifiez que vous avez bien tous les fichiers nécessaires (lancez `ls -alh`) :

```bash
$ ls -alh

Permissions Size User Group Date Modified Name
drwxr-xr-x - christophe christophe 2024-10-18 13:30 .
drwxrwxrwt - root root 2024-10-18 13:30 ..
.rw-r--r-- 151 christophe christophe 2024-10-18 13:30 .env
.rw-r--r-- 34M christophe christophe 2024-10-18 13:30 backup.jpa
.rw-r--r-- 1.3k christophe christophe 2024-10-18 13:30 compose.yaml
.rw-r--r-- 162 christophe christophe 2024-10-18 13:30 Dockerfile
.rw-r--r-- 11k christophe christophe 2024-10-18 13:30 en-GB.kickstart.ini
.rw-r--r-- 390k christophe christophe 2024-10-18 13:30 kickstart.php
.rw-r--r-- 2.9k christophe christophe 2024-10-18 13:30 makefile
```

> **Passer l'étape de création des fichiers:**
>
> Si vous avez sauté l'étape de création des fichiers plus haut en les téléchargeant depuis mon repo, vous aurez tous les fichiers listés ci-dessus.

> **Caution:**
>
> Rappel : pour les utilisateurs Linux, nous avons besoin de `GNU make` pour pouvoir lancer des commandes comme `make import` ou `make up`. Si vous voyez `make not found`, lancez `sudo apt-get update && sudo apt-get install make` pour procéder à l'installation.

## Lancer le processus d'importation {#run-the-importation-process}

Voilà, vous avez copié pas mal de fichiers. Il est temps de restaurer votre site.

Pour les utilisateurs Linux, profitez simplement de `GNU Make` et lancez l'instruction `make import`.

Pour Windows (Powershell ou DOS), lancez ces commandes :

```bash
mkdir db_data mkdir joomla_data copy en-GB.kickstart.ini joomla_data\ copy
kickstart.php joomla_data\ copy backup.jpa joomla_data\ docker compose up
--detach
```

Dans les deux cas (Linux et Windows), vous obtiendrez une sortie de ce genre dans la console :

```bash
[+] Building 1.4s (7/7) FINISHED                                 docker:default
=> [joomla internal] load build definition from Dockerfile                 0.0s
 => => transferring dockerfile: 200B                                       0.0s
 => [joomla internal] load metadata for docker.io/library/php:8.3-apache   1.2s
 => [joomla internal] load .dockerignore                                   0.0s
 => => transferring context: 2B                                            0.0s
 [...]
 => [joomla] resolving provenance for metadata file                        0.0s

[+] Running 3/3
✔ Network running-joomla-in-docker_joomla_network Created 0.0s
✔ Container joomla-db Healthy 31.0s
✔ Container joomla-app Started 31.3s
```

Une fois terminé, ouvrez votre navigateur et rendez-vous sur `http://127.0.0.1:8080/kickstart.php` pour démarrer la restauration de votre site avec l'assistant **Akeeba Kickstart** — les écrans montrés en haut de cet article.

Lorsque vous devez renseigner les informations de base de données, référez-vous à ce qui s'est affiché dans votre console.

Poursuivez la restauration comme d'habitude ; fermez la fenêtre quand Akeeba Kickstart le demande, puis cliquez sur le bouton *Clean Up* ; ensuite sur *Visit your site's frontend* et profitez.

> **Information:**
>
> Si vous avez utilisé le site de démo fourni, le compte admin est **joomla** et son mot de passe est **joomla\@secured**.

## Conclusion {#conclusion}

Comme nous venons de le voir, restaurer un site Joomla en local est devenu vraiment simple.

Il suffit de récupérer quelques fichiers de configuration, et seul celui nommé `.env` doit être mis à jour avec les versions de PHP et MySQL utilisées sur votre site de production.

Vous téléchargez la sauvegarde locale de votre site et, avec une seule commande (`make import`), votre site est restauré.

```bash
$ make import
```

Peu importe la version de Joomla ou de MySQL que vous utilisez.

Simple comme bonjour, non ?


---