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

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 :

• Reproductibilité : le même fichier docker-compose.yml fonctionne sur n’importe quel serveur Linux
• Isolation : chaque version de PHP, MariaDB et GLPI est encapsulée, pas de conflit système
• Portabilité : migration simple entre serveurs (copie des volumes + fichier compose)
• Contrôle total : contrairement aux images communautaires (type diouxx/glpi), tu maîtrises l’intégralité de ta stack — Dockerfile, extensions PHP, configuration Apache
• Rollback facile : retour arrière instantané en changeant la version GLPI dans le .env
• Scalabilité : possibilité d’ajouter un reverse proxy, du monitoring, des sauvegardes automatisées

Prérequis techniques

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

• Un serveur Linux (Debian 12/13 ou Ubuntu 22.04+) avec accès root ou sudo
• Docker Engine 26+ et Docker Compose v2 installés
• Un nom de domaine pointant vers ton serveur (pour le HTTPS)
• Au minimum 2 Go de RAM et 20 Go de stockage disponible
• Les ports 80 et 443 ouverts dans le pare-feu

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 :

• php:8.2-apache — Serveur web Apache + PHP, avec GLPI téléchargé depuis le GitHub officiel du projet
• mariadb:11 — Base de données MariaDB avec healthcheck intégré
• traefik:v3 — Reverse proxy avec gestion automatique des certificats Let’s Encrypt

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 :

• Image de base officielle : php:8.2-apache depuis Docker Hub, pas d’image tierce
• Version GLPI paramétrable : via l’argument GLPI_VERSION, modifiable dans le .env
• Données hors du webroot : fichiers, config et logs dans /var/glpi/ (recommandation officielle GLPI)
• Crontab intégrée : les tâches planifiées GLPI tournent toutes les 2 minutes
• Extensions PHP complètes : gd, intl, mysqli, pdo_mysql, opcache, bz2, zip, ldap, exif, curl, xml

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

• N’expose jamais le port 3306 (MariaDB) sur l’interface publique — le réseau Docker interne suffit
• Configure un pare-feu (UFW ou iptables) pour n’autoriser que les ports 80, 443 et 22
• Utilise HTTPS obligatoire via Traefik (déjà configuré dans le compose ci-dessus)
• Restreins l’accès à l’interface d’administration GLPI par IP si possible

Durcir la configuration GLPI

• Supprimer le fichier d’installation après setup (install/install.php)
• Changer tous les mots de passe par défaut
• Désactiver les comptes inutilisés (normal, post-only)
• Activer l’authentification LDAP/Active Directory si disponible
• Configurer les logs GLPI pour tracer les connexions
• Vérifier régulièrement les CVE publiées sur le dépôt officiel 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 :

• ☐ Docker et Docker Compose installés et à jour
• ☐ Dockerfile basé sur php:8.2-apache avec toutes les extensions PHP
• ☐ Fichier .env avec mots de passe forts et non versionnés
• ☐ MariaDB avec healthcheck configuré
• ☐ HTTPS actif via Traefik
• ☐ Fichier install/install.php supprimé
• ☐ Mots de passe par défaut changés (glpi, tech, normal, post-only)
• ☐ Sauvegardes automatisées (base + fichiers)
• ☐ Pare-feu configuré (80, 443, 22 uniquement)
• ☐ Monitoring en place (au minimum : espace disque, RAM, état des conteneurs)
• ☐ Documentation interne à jour
• ☐ Test de restauration effectué au moins une fois

Erreurs fréquentes à éviter

• Dépendre d’images communautaires : des images comme diouxx/glpi peuvent être abandonnées ou en retard sur les mises à jour de sécurité. Avec un Dockerfile from scratch, tu gardes le contrôle total
• Utiliser latest sans version fixée : préfère un tag de version précis dans ton .env (GLPI_VERSION=10.0.18) pour éviter les surprises
• Exposer MariaDB sur 0.0.0.0:3306 : ne le fais jamais, utilise uniquement le réseau Docker interne
• Oublier les volumes : sans volumes nommés, tu perds tout à chaque docker compose down
• Négliger les sauvegardes : un dump SQL + fichiers quotidien est le minimum vital
• Ignorer les mises à jour de sécurité : surveille les CVE de GLPI, PHP et MariaDB
• Pas de monitoring : un conteneur qui crashe silencieusement, c’est un ticket qui n’arrivera jamais dans GLPI

FAQ — GLPI Docker Compose

Clique sur une question pour afficher la réponse.

docker cp ./mon-plugin glpi-app:/var/glpi/marketplace/
docker exec glpi-app chown -R www-data:www-data /var/glpi/marketplace/mon-plugin

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.