# Découvrir Docker Compose en déployant un GLPI de lab
Dans cet article, nous allons découvrir Docker Compose en nous appuyant sur GLPI qui sera utilisé ici comme un exemple d'application multi-conteneurs (serveur web + base de données) avec Docker Compose.
> [!danger] Attention ! <span style="font-weight: normal; color: var(--text-normal)">Cette configuration est destinée à un environnement de test. Ne pas utiliser en production.</span>
## Qu'est-ce que Docker Compose ?
> [!info] À savoir ! <span style="font-weight: normal; color: var(--text-normal)">Docker Compose permet de créer et de gérer des applications multi-conteneurs.</span>
Docker Compose permet de définir toute une application (conteneurs, réseau, stockage) dans un seul fichier `docker-compose.yml`.
Chaque composant de l’application est défini comme un **service**. Chaque service correspond à un conteneur. Ces services travaillent ensemble et peuvent :
- communiquer via un réseau commun
- démarrer en même temps
## Ce que fait Docker Compose
Avec une seule commande (`docker compose up`), Docker Compose :
- crée un réseau
- lance les conteneurs
- configure leur communication
- démarre l’application complète.
## Cas d'usage
Dans un environnement classique, GLPI nécessite :
- une application web (GLPI)
- une base de données (MySQL)
Chaque service sera exécuté dans un conteneur distinct. Docker Compose va lancer ces deux services ensemble avec une seule commande.
## Préparer l'environnement
La démonstration est réalisée sur une machine Windows 11 avec Docker Desktop installé.
La procédure d’installation de [[tuto-docker-desktop-windows|Docker Desktop sous Windows 11]] n’est pas détaillée ici.
### Prérequis
- Docker Desktop installé
- Port 80 disponible sur la machine hôte
- 2 Go de RAM libre recommandés
## Configuration du fichier Docker Compose
Afin de déployer GLPI et MySQL, deux fichiers sont nécessaires avant de lancer les conteneurs :
- Un fichier `docker-compose.yml` avec l'ensemble des paramètres pour chaque service
- Un fichier `.env` contenant les variables d'environnement utilisées par Docker Compose, par exemple :
- Nom de la base de données GLPI
- Utilisateur de la base de données GLPI
- Mot de passe de la base de données GLPI
### Créer docker-compose.yml
Choisissez le dossier de stockage de ces fichiers puis :
- Créez un fichier nommé `docker-compose.yml`
- Collez l'exemple de fichier YAML Docker Compose ci-dessous.
```yml
services:
glpi:
image: glpi/glpi:11.0
restart: unless-stopped
volumes:
- glpi_data:/var/glpi
env_file: .env
depends_on:
- db
ports:
- "80:80"
db:
image: mysql:8.0
restart: unless-stopped
volumes:
- db_data:/var/lib/mysql
environment:
MYSQL_RANDOM_ROOT_PASSWORD: "yes"
MYSQL_DATABASE: ${GLPI_DB_NAME}
MYSQL_USER: ${GLPI_DB_USER}
MYSQL_PASSWORD: ${GLPI_DB_PASSWORD}
volumes:
glpi_data:
db_data:
```
Ce fichier `docker-compose.yml` exécutera une pile de services avec :
- `services` : liste des conteneurs à lancer
- `glpi` : dernière version stable de l’application web, port `80`.
- `db` : une instance MySQL qui contient une base de données nommée `glpi`, port `3306`.
- `image` : image Docker utilisée pour créer le conteneur
- `restart` : redémarre automatiquement les conteneurs en cas d’arrêt
- `volumes` : permet de conserver les données même après suppression des conteneurs
- `glpi_data` : volume contenant les répertoires `config`, `marketplace` et `files`.
- `db_data` : volume contenant les données de `/var/lib/mysql`
- `env_file` : charge des variables depuis un fichier `.env`
- `depends_on` : indique que GLPI dépend de la base de données
- `ports` : expose le service sur la machine hôte (`localhost:80`)
- `environment` : définit les variables nécessaires au conteneur (ici MySQL)
### Créer le fichier .env
Ajouter un fichier nommé `.env` dans le répertoire de travail et collez les variables suivantes :
```.env
GLPI_DB_HOST=db
GLPI_DB_PORT=3306
GLPI_DB_NAME=glpi
GLPI_DB_USER=glpi
GLPI_DB_PASSWORD=glpi
```
> [!warning] Rappel ! <span style="font-weight: normal; color: var(--text-normal)">Adaptez les configurations si nécessaire.</span>
> [!info] À savoir ! <span style="font-weight: normal; color: var(--text-normal)">Docker Compose crée automatiquement un réseau permettant aux services de communiquer entre eux (ici `glpi` peut joindre `db`).</span>
### Lancer les services
Dans le dossier du projet, exécuter la commande :
```powershell
docker compose up -d
```
- `up` : lance les services listés dans le `docker-compose.yml`
- `-d` : exécution en arrière-plan
Vérifier l'état :
```powershell
docker compose ps
```
![[_asset-tuto-docker-compose.png]]
### Accéder à GLPI
Une fois les conteneurs exécutés, GLPI s'installera ou se mettra à jour automatiquement si nécessaire. Cette étape peut prendre quelques minutes.
Vous pouvez à présent accéder à GLPI à l'adresse `http://localhost` directement depuis votre machine Windows.
> [!done] <span style="font-weight: normal; color: var(--text-normal)">Si la mire d'authentification GLPI s'affiche, le déploiement est réussi !</span>
> [!info] À savoir ! <span style="font-weight: normal; color: var(--text-normal)">Pour plus de détail sur les déploiement de GLPI, consultez le tutoriel dédié [[tuto-glpi-docker-install|installer GLPI avec Docker Desktop]].</span>
## Arrêter et supprimer l'environnement
Pour finaliser la prise en main de Docker Compose, nous allons :
- supprimer les conteneurs `glpi` et `db`
- supprimer leur réseau dédié de communication
- supprimer les volumes (données).
> [!danger] Attention ! <span style="font-weight: normal; color: var(--text-normal)">Toutes les données seront supprimées, y compris les volumes de données persistantes.</span>
```powershell
docker compose down -v
```
## Bonnes pratiques (niveau débutant)
- Utiliser des images officielles
- Éviter `latest` en production
- Comprendre chaque service avant d’ajouter de la complexité
- Utiliser Docker Compose pour les applications multi-conteneurs
## Pour aller plus loin
- Ajouter des volumes pour persister les données
- Séparer la configuration dans un fichier `.env`
- Utiliser [[tuto-dockerfile|Dockerfile]] pour :
- [[kb-dockerfile-non-root|ajouter un utilisateur non root]]
- optimiser les images utilisées
## Conclusion
Docker Compose permet de lancer facilement une application complète composée de plusieurs conteneurs.
Dans cet exemple, nous avons utilisé :
- un conteneur pour GLPI
- un conteneur pour la base de données
Ce fonctionnement est identique pour la majorité des applications modernes.