GLPI Docker Compose : déployer un ITSM fiable en production avec Docker

Bot Linux man

✅ Testé sur Debian 13 (Trixie) avec Docker 29.3 et Docker Compose v5.1 — mars 2026.

Déployer GLPI avec Docker Compose en environnement professionnel, c’est le moyen le plus rapide et reproductible de mettre en place un outil ITSM complet pour gérer ton parc informatique. Que tu sois admin sys dans une PME ou prestataire infogérance, cette méthode te permet d’avoir un GLPI opérationnel, sécurisé et maintenable en quelques minutes — sans les galères d’installation classique sur bare-metal. Dans ce guide, je te montre ma méthode complète pour déployer GLPI docker compose en production : avec un Dockerfile from scratch basé sur les images officielles php:8.2-apache et mariadb:11, sans dépendre d’images communautaires tierces. On couvre GLPI 10.0.x avec des configurations testées et validées en conditions réelles.

GLPI Docker Compose déploiement production avec Docker et MariaDB
Déploiement GLPI avec Docker Compose, Traefik et MariaDB en environnement de production Linux.

📦 Tout le code de cet article est disponible sur GitLab : gitlab.com/babidi34/glpi-docker-compose
Le repo contient le Dockerfile, le docker-compose.yml, le .env.example et le script de sauvegarde. L’image Docker est publiée sur la registry GitLab : registry.gitlab.com/babidi34/glpi-docker-compose:1.0

Réponse rapide : déployer GLPI avec Docker Compose en 5 étapes

  1. Préparer un serveur Linux (Debian 12/13 ou Ubuntu 22.04+) avec Docker et Docker Compose installés
  2. Créer un Dockerfile basé sur php:8.2-apache qui télécharge GLPI depuis le dépôt officiel GitHub
  3. Écrire un docker-compose.yml avec MariaDB, GLPI et Traefik comme reverse proxy HTTPS
  4. Configurer les variables d’environnement dans un fichier .env et lancer docker compose up -d
  5. Finaliser l’installation via l’interface web, sécuriser et mettre en place les sauvegardes

Pourquoi Docker Compose pour GLPI ?

GLPI (Gestionnaire Libre de Parc Informatique) est l’outil ITSM open source de référence en France. Historiquement installé en bare-metal avec Apache, PHP et MySQL, le déploiement classique pose plusieurs problèmes en contexte professionnel : dépendances PHP conflictuelles, mises à jour risquées, difficultés de migration entre serveurs. Docker Compose résout ces problèmes en isolant chaque composant dans un conteneur dédié.

Les avantages concrets d’un déploiement GLPI Docker Compose en production :

Prérequis techniques

Avant de commencer, assure-toi d’avoir les éléments suivants :

Pour installer Docker et Docker Compose sur Debian 13 :

sudo apt update
sudo apt install -y ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
chmod a+r /etc/apt/keyrings/docker.asc
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian $(. /etc/os-release && echo $VERSION_CODENAME) stable" | sudo tee /etc/apt/sources.list.d/docker.list
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

Architecture de la stack GLPI Docker

Notre stack repose sur 3 services, tous basés sur des images Docker officielles — aucune image communautaire tierce :

Le tout est orchestré par un docker-compose.yml avec volumes nommés pour la persistance et un fichier .env pour les secrets.

Le Dockerfile GLPI from scratch

Crée un fichier Dockerfile dans ton répertoire de projet. Ce fichier construit une image GLPI complète à partir de l’image officielle php:8.2-apache, avec toutes les extensions PHP requises et les bonnes pratiques de sécurité (données hors du webroot) :

FROM php:8.2-apache

ARG GLPI_VERSION=10.0.18

# Dépendances système pour les extensions PHP requises par GLPI
RUN apt-get update && apt-get install -y --no-install-recommends \
    libpng-dev \
    libjpeg62-turbo-dev \
    libfreetype6-dev \
    libicu-dev \
    libxml2-dev \
    libzip-dev \
    libldap2-dev \
    libbz2-dev \
    libcurl4-openssl-dev \
    cron \
    curl \
    ca-certificates \
    && rm -rf /var/lib/apt/lists/*

# Extensions PHP requises par GLPI
RUN docker-php-ext-configure gd --with-freetype --with-jpeg \
    && docker-php-ext-install -j$(nproc) \
    gd \
    intl \
    mysqli \
    pdo_mysql \
    opcache \
    bz2 \
    zip \
    ldap \
    exif \
    curl \
    xml

# Configuration PHP optimisée pour GLPI
RUN { \
    echo "memory_limit = 256M"; \
    echo "upload_max_filesize = 20M"; \
    echo "post_max_size = 20M"; \
    echo "max_execution_time = 600"; \
    echo "session.cookie_httponly = On"; \
    echo "date.timezone = Europe/Paris"; \
    } > /usr/local/etc/php/conf.d/glpi.ini

# OPcache optimisé
RUN { \
    echo "opcache.enable=1"; \
    echo "opcache.memory_consumption=256"; \
    echo "opcache.max_accelerated_files=10000"; \
    echo "opcache.revalidate_freq=60"; \
    } > /usr/local/etc/php/conf.d/opcache-recommended.ini

# Activer mod_rewrite pour GLPI
RUN a2enmod rewrite

# Télécharger et installer GLPI depuis le GitHub officiel
RUN curl -fsSL "https://github.com/glpi-project/glpi/releases/download/${GLPI_VERSION}/glpi-${GLPI_VERSION}.tgz" \
    -o /tmp/glpi.tgz \
    && tar -xzf /tmp/glpi.tgz -C /var/www/html/ \
    && rm /tmp/glpi.tgz \
    && chown -R www-data:www-data /var/www/html/glpi

# Configuration Apache — DocumentRoot pointe vers GLPI
RUN { \
    echo '<VirtualHost *:80>'; \
    echo '    DocumentRoot /var/www/html/glpi/public'; \
    echo '    <Directory /var/www/html/glpi/public>'; \
    echo '        AllowOverride All'; \
    echo '        Require all granted'; \
    echo '        RewriteEngine On'; \
    echo '        RewriteCond %{REQUEST_FILENAME} !-f'; \
    echo '        RewriteRule ^(.*)$ index.php [QSA,L]'; \
    echo '    </Directory>'; \
    echo '</VirtualHost>'; \
    } > /etc/apache2/sites-available/000-default.conf

# Répertoires de données GLPI hors du webroot (bonne pratique sécurité)
RUN mkdir -p /var/glpi/files /var/glpi/config /var/glpi/log /var/glpi/marketplace \
    && chown -R www-data:www-data /var/glpi

# Script de configuration des chemins GLPI (downstream config)
RUN { \
    echo '<?php'; \
    echo 'define("GLPI_VAR_DIR", "/var/glpi/files");'; \
    echo 'define("GLPI_CONFIG_DIR", "/var/glpi/config");'; \
    echo 'define("GLPI_LOG_DIR", "/var/glpi/log");'; \
    echo 'define("GLPI_MARKETPLACE_DIR", "/var/glpi/marketplace");'; \
    } > /var/www/html/glpi/inc/downstream.php \
    && chown www-data:www-data /var/www/html/glpi/inc/downstream.php

# Crontab GLPI (tâches planifiées)
RUN echo "*/2 * * * * www-data php /var/www/html/glpi/front/cron.php &>/dev/null" > /etc/cron.d/glpi \
    && chmod 0644 /etc/cron.d/glpi

EXPOSE 80

# Démarrer cron + Apache
CMD ["sh", "-c", "cron && apache2-foreground"]

Points clés de ce Dockerfile :

Le fichier docker-compose.yml complet pour GLPI

Voici le docker-compose.yml testé et validé pour un déploiement GLPI production avec MariaDB et Traefik comme reverse proxy HTTPS :

services:
  mariadb:
    image: mariadb:11
    container_name: glpi-mariadb
    restart: unless-stopped
    environment:
      MARIADB_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
      MARIADB_DATABASE: ${DB_DATABASE}
      MARIADB_USER: ${DB_USER}
      MARIADB_PASSWORD: ${DB_PASSWORD}
    volumes:
      - glpi-db:/var/lib/mysql
    networks:
      - glpi-net
    healthcheck:
      test: ["CMD", "healthcheck.sh", "--connect", "--innodb_initialized"]
      interval: 30s
      timeout: 10s
      retries: 5

  glpi:
    build:
      context: .
      args:
        GLPI_VERSION: ${GLPI_VERSION:-10.0.18}
    container_name: glpi-app
    restart: unless-stopped
    environment:
      TZ: ${TZ:-Europe/Paris}
    volumes:
      - glpi-config:/var/glpi/config
      - glpi-files:/var/glpi/files
      - glpi-log:/var/glpi/log
      - glpi-marketplace:/var/glpi/marketplace
    depends_on:
      mariadb:
        condition: service_healthy
    networks:
      - glpi-net
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.glpi.rule=Host(`${GLPI_DOMAIN}`)"
      - "traefik.http.routers.glpi.entrypoints=websecure"
      - "traefik.http.routers.glpi.tls.certresolver=letsencrypt"
      - "traefik.http.services.glpi.loadbalancer.server.port=80"

  traefik:
    image: traefik:v3
    container_name: glpi-traefik
    restart: unless-stopped
    command:
      - "--api.dashboard=false"
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "--entrypoints.web.http.redirections.entrypoint.to=websecure"
      - "--certificatesresolvers.letsencrypt.acme.tlschallenge=true"
      - "--certificatesresolvers.letsencrypt.acme.email=${ACME_EMAIL}"
      - "--certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - traefik-certs:/letsencrypt
    networks:
      - glpi-net

volumes:
  glpi-db:
  glpi-config:
  glpi-files:
  glpi-log:
  glpi-marketplace:
  traefik-certs:

networks:
  glpi-net:
    driver: bridge

Configuration des variables d’environnement

Crée un fichier .env à côté de ton docker-compose.yml pour stocker les informations sensibles et la version GLPI :

# .env — Ne jamais commiter ce fichier dans Git

# Version GLPI (tag officiel GitHub)
GLPI_VERSION=10.0.18

# MariaDB
DB_ROOT_PASSWORD=MonMotDePasseRootSecure2026!
DB_PASSWORD=GlpiDbPassword_Secure2026!
DB_DATABASE=glpi
DB_USER=glpi

# Timezone
TZ=Europe/Paris

# Traefik — email Let's Encrypt
ACME_EMAIL=admin@example.com

# Domaine GLPI (utilisé par Traefik)
GLPI_DOMAIN=glpi.example.com

Important : ajoute .env dans ton .gitignore si tu versionnes ton déploiement. Ne commite jamais les mots de passe en clair dans un dépôt Git.

Lancement et première configuration

Une fois les trois fichiers prêts (Dockerfile, docker-compose.yml, .env), lance le déploiement :

# Créer le répertoire de déploiement
mkdir -p /opt/glpi && cd /opt/glpi

# Copier Dockerfile, docker-compose.yml et .env dans ce répertoire

# Construire l'image GLPI et lancer les services
docker compose up -d --build

# Vérifier que tout tourne
docker compose ps

# Suivre les logs en temps réel
docker compose logs -f glpi

Le premier docker compose up --build prend 2 à 3 minutes (téléchargement GLPI + compilation des extensions PHP). Les démarrages suivants sont quasi instantanés grâce au cache Docker.

Après le démarrage (30 à 60 secondes), accède à https://glpi.example.com. L’assistant d’installation GLPI s’affiche. Suis les étapes :

  1. Choisis la langue (Français)
  2. Accepte la licence GPLv3
  3. Clique sur « Installer »
  4. Renseigne les paramètres de connexion base de données : hôte = mariadb, utilisateur = glpi, mot de passe = celui du .env
  5. Sélectionne la base glpi
  6. Laisse l’assistant créer les tables
  7. Note les identifiants par défaut (glpi/glpi, tech/tech, normal/normal, post-only/postonly)

Action critique post-installation : change immédiatement les mots de passe par défaut et supprime le fichier d’installation :

docker exec glpi-app rm -f /var/www/html/glpi/install/install.php

Vérifications post-déploiement

Après le déploiement, vérifie que tous les composants fonctionnent correctement :

# Vérifier l'état des conteneurs
docker compose ps

# Tester la connectivité base de données depuis le conteneur GLPI
docker exec glpi-app php -r "new PDO('mysql:host=mariadb;dbname=glpi', 'glpi', 'MOT_DE_PASSE'); echo 'DB OK';"

# Vérifier les extensions PHP chargées
docker exec glpi-app php -m | grep -iE "gd|intl|mysql|opcache|zip|ldap|curl"

# Vérifier les versions
docker exec glpi-app php -v | head -1
docker exec glpi-mariadb mariadb --version

# Tester l'accès HTTP
curl -sL -o /dev/null -w "HTTP %{http_code}\n" http://localhost:80

Sécurisation du déploiement GLPI Docker

Un déploiement GLPI en production exige des mesures de sécurité au-delà de l’installation de base :

Sécuriser l’accès réseau

Durcir la configuration GLPI

Sauvegardes automatisées

La sauvegarde est le point critique souvent négligé dans un déploiement Docker. Pour GLPI, il faut sauvegarder deux éléments : la base de données MariaDB et les fichiers GLPI (documents uploadés, plugins). Voici un script de sauvegarde complet :

#!/bin/bash
# backup-glpi.sh — Sauvegarde GLPI + MariaDB
set -euo pipefail

BACKUP_DIR="/opt/backups/glpi"
DATE=$(date +%Y%m%d_%H%M)
RETENTION_DAYS=30

mkdir -p "$BACKUP_DIR"

# Sauvegarde base de données
docker exec glpi-mariadb mariadb-dump -u root -p"$DB_ROOT_PASSWORD" \
  --single-transaction --routines --triggers glpi \
  | gzip > "$BACKUP_DIR/glpi-db-$DATE.sql.gz"

# Sauvegarde fichiers GLPI (config, documents, plugins)
docker run --rm \
  -v glpi-config:/data/config:ro \
  -v glpi-files:/data/files:ro \
  -v glpi-marketplace:/data/marketplace:ro \
  -v "$BACKUP_DIR":/backup \
  alpine tar czf "/backup/glpi-files-$DATE.tar.gz" -C /data .

# Rotation des anciennes sauvegardes
find "$BACKUP_DIR" -name "glpi-*" -mtime +$RETENTION_DAYS -delete

echo "[$(date)] Sauvegarde GLPI terminée : $BACKUP_DIR"

Ajoute ce script en crontab pour une exécution quotidienne :

# Sauvegarde GLPI tous les jours à 2h du matin
0 2 * * * /opt/glpi/backup-glpi.sh >> /var/log/glpi-backup.log 2>&1

Mise à jour de GLPI avec Docker Compose

L’un des avantages de cette stack from scratch : la mise à jour consiste simplement à changer la variable GLPI_VERSION dans le .env et reconstruire l’image :

# 1. Sauvegarder avant toute mise à jour
./backup-glpi.sh

# 2. Modifier la version dans .env
# GLPI_VERSION=10.0.18  →  GLPI_VERSION=10.0.24

# 3. Reconstruire et relancer
docker compose up -d --build glpi

# 4. Vérifier les logs
docker compose logs -f glpi

# 5. Accéder à l'interface web et valider la migration de la DB si nécessaire

En cas de problème, le rollback est simple :

# Rollback vers la version précédente
# Remettre GLPI_VERSION=10.0.18 dans .env
docker compose up -d --build glpi

# Restaurer la base si nécessaire
gunzip < /opt/backups/glpi/glpi-db-YYYYMMDD_HHMM.sql.gz | \
  docker exec -i glpi-mariadb mariadb -u root -p"$DB_ROOT_PASSWORD" glpi

Diagnostic et résolution des erreurs courantes

Voici les problèmes les plus fréquents rencontrés lors d’un déploiement GLPI Docker Compose et leurs solutions :

Erreur « Database connection failed »

Cause : le conteneur GLPI démarre avant que MariaDB soit prêt, ou les identifiants sont incorrects.

Solution : vérifie le healthcheck MariaDB dans le compose et utilise depends_on avec condition: service_healthy. Vérifie aussi que les variables DB_PASSWORD sont identiques dans le .env.

# Vérifier la connectivité DB
docker exec glpi-app php -r "new PDO('mysql:host=mariadb;dbname=glpi', 'glpi', 'MOT_DE_PASSE');"

# Vérifier les logs MariaDB
docker compose logs mariadb

Erreur de permissions sur les fichiers

Cause : l’utilisateur du conteneur Apache (www-data) n’a pas les droits sur les volumes montés.

Solution :

docker exec glpi-app chown -R www-data:www-data /var/glpi/files
docker exec glpi-app chown -R www-data:www-data /var/glpi/marketplace
docker exec glpi-app chmod -R 755 /var/glpi/files

GLPI ne répond pas après mise à jour

Cause : la migration de la base de données n’a pas été exécutée automatiquement.

Solution : lance la migration manuellement via la CLI GLPI :

docker exec glpi-app php /var/www/html/glpi/bin/console db:update
docker exec glpi-app php /var/www/html/glpi/bin/console cache:clear

Certificat SSL non généré par Traefik

Cause : le domaine ne pointe pas vers le serveur, ou le port 443 est bloqué.

Solution : vérifie le DNS (dig +short glpi.example.com), ouvre les ports 80 et 443, et consulte les logs Traefik :

docker compose logs traefik | grep -i "acme\|error\|certificate"

Erreur de build du Dockerfile

Cause : la version GLPI spécifiée n’existe pas sur GitHub, ou problème réseau.

Solution : vérifie que la version existe sur github.com/glpi-project/glpi/releases et que le serveur a accès à Internet :

# Tester le téléchargement manuellement
curl -fsSL "https://github.com/glpi-project/glpi/releases/download/10.0.18/glpi-10.0.18.tgz" -o /dev/null -w "HTTP %{http_code}\n"

Checklist de déploiement production

Avant de considérer ton déploiement GLPI Docker Compose comme prêt pour la production, vérifie chaque point :

Erreurs fréquentes à éviter

FAQ — GLPI Docker Compose

Clique sur une question pour afficher la réponse.

Pourquoi ne pas utiliser une image Docker communautaire pour GLPI ?

Les images communautaires comme diouxx/glpi sont pratiques pour un test rapide, mais en production elles posent des risques : maintenance incertaine, retard sur les patches de sécurité, impossibilité de personnaliser les extensions PHP ou la configuration Apache. Avec un Dockerfile from scratch basé sur php:8.2-apache, tu maîtrises chaque couche de ta stack.

GLPI Docker Compose fonctionne-t-il avec MySQL au lieu de MariaDB ?

Oui, GLPI supporte MySQL 8.0+ et MariaDB 10.5+. MariaDB est recommandé pour des raisons de licence (GPL) et de compatibilité. Remplace simplement l’image mariadb:11 par mysql:8.0 et adapte les variables d’environnement.

Comment installer des plugins GLPI avec Docker ?

Le volume glpi-marketplace est monté sur /var/glpi/marketplace. Tu peux installer des plugins directement depuis le Marketplace GLPI via l’interface d’administration, ou copier manuellement un plugin extrait dans le volume :

docker cp ./mon-plugin glpi-app:/var/glpi/marketplace/
docker exec glpi-app chown -R www-data:www-data /var/glpi/marketplace/mon-plugin
Peut-on utiliser GLPI Docker Compose avec FusionInventory ?

FusionInventory est remplacé par l’agent d’inventaire natif dans GLPI 10+. Si tu utilises une version antérieure, installe le plugin FusionInventory via le volume marketplace. Pour GLPI 10+, l’inventaire natif est intégré et ne nécessite aucun plugin supplémentaire.

Comment migrer un GLPI existant vers Docker Compose ?

Exporte la base de données avec mysqldump, copie le répertoire files/ de GLPI, puis importe-les dans les volumes Docker correspondants. Lance GLPI et exécute php bin/console db:update pour finaliser la migration.

Quel est l’espace disque nécessaire pour GLPI Docker ?

Compte 2 Go pour les images Docker, 1 Go pour la base de données initiale, et un espace variable pour les documents uploadés. Un déploiement standard PME (500 tickets/mois) consomme environ 5 à 10 Go au total après un an d’utilisation.

Comment passer à GLPI 11 ?

GLPI 11 est disponible depuis début 2026. Pour migrer, modifie simplement GLPI_VERSION=11.0.6 dans ton .env, reconstruis avec docker compose up -d --build, puis lance la migration de la base via docker exec glpi-app php /var/www/html/glpi/bin/console db:update. Fais toujours une sauvegarde complète avant de migrer.

Conclusion

Déployer GLPI avec Docker Compose et un Dockerfile from scratch, c’est la méthode la plus fiable et la plus maintenable pour mettre en place un ITSM professionnel. En utilisant uniquement des images Docker officielles (php:8.2-apache, mariadb:11, traefik:v3), tu gardes le contrôle total sur ta stack sans dépendre d’images communautaires. Le docker-compose.yml présenté dans ce guide te donne une base solide, testée sur Debian 13 en conditions réelles, avec HTTPS, sauvegardes et les bonnes pratiques de sécurité.

Si tu cherches à industrialiser le déploiement GLPI sur plusieurs serveurs ou à l’intégrer dans une infrastructure as code, Linux-Man accompagne les PME et éditeurs SaaS dans la mise en place d’environnements Docker sécurisés et maintenables. N’hésite pas à nous contacter pour un audit de ton infrastructure.

Quitter la version mobile