Déployer un environnement PHP avec Docker Compose : tutoriel DNMP complet (Nginx+MySQL+PHP)

Dans le terminal, les messages d’erreur défilent — « Nginx ne trouve pas le socket PHP-FPM ». La huitième erreur ce soir. Installation manuelle LNMP : j’ai modifié nginx.conf, php-fpm.conf et my.cnf, redémarré les services une dizaine de fois, l’environnement refuse toujours de démarrer.

Le collègue d’à côté dit : « Chez moi ça tourne, tu n’as pas la mauvaise version de PHP ? »

Il est en PHP 7.4, moi en 8.1. Lui en MySQL 5.7, moi j’ai installé 8.0 par erreur. Pas étonnant que le code ne passe pas.

Chaque développeur a un environnement différent. L’onboarding prend une demi-journée, avec accompagnement individuel. Le code fonctionne sur A, plante sur B. Le déploiement serveur relève du hasard.

Avec Docker Compose et DNMP en un clic, ces problèmes disparaissent. Nginx, MySQL et PHP en 10 minutes, toute l’équipe sur le même fichier de configuration. Fini le « chez moi ça marche ».

Pourquoi déployer un environnement PHP avec Docker Compose

Les trois douleurs du déploiement LNMP traditionnel

Douleur 1 : installation manuelle fastidieuse, une erreur et tout s’effondre

Vous vous souvenez de votre première installation LNMP ? apt-get install nginx, puis php-fpm, puis MySQL. Ensuite les fichiers de config : nginx.conf pour les règles location, php.ini pour les extensions, my.cnf pour les paramètres.

Trois fichiers éparpillés : /etc/nginx/, /etc/php/, /etc/mysql/. Une erreur de config, le service ne démarre pas. Pour déboguer, il faut lire les logs Nginx, PHP-FPM et MySQL — épuisant.

J’ai vu quelqu’un bloquer trois heures parce que listen = 127.0.0.1:9000 dans php-fpm.conf était devenu listen = /run/php/php7.4-fpm.sock : Nginx ne trouvait plus PHP.

Douleur 2 : compatibilité de versions, casse-tête permanent

Il y a toujours des « fidèles » à une version. Ancien projet en PHP 5.6, nouveau en PHP 8.1. Le GROUP BY MySQL 5.7 casse en 8.0 avec ONLY_FULL_GROUP_BY activé par défaut.

Pire encore, les versions varient d’une machine à l’autre :

• Mac de Xiao Li : PHP 7.4 + MySQL 5.7
• Ubuntu de Lao Wang : PHP 8.0 + MySQL 8.0
• Windows du stagiaire : PHP 8.1 + MariaDB 10.6

Le code passe chez Xiao Li, échoue chez Lao Wang après un pull. L’environnement de test a encore d’autres versions, la prod encore d’autres. Ingérable.

Douleur 3 : collaboration à l’efficacité désespérante

Premier jour d’un nouveau : une demi-journée d’accompagnement pour l’environnement :

1. Installer Nginx (20 min)
2. Installer PHP et extensions (30 min, parfois compilation)
3. Installer MySQL (15 min)
4. Configurer la communication entre services (1 h, plein de pièges)
5. Importer les données de test (10 min)

Avec de la chance, il code l’après-midi. Sinon, demain.

Dans une startup, un simple enregistrement utilisateur passait en dev, plantait en prod : « échec de connexion base de données ». Root sans mot de passe en dev, avec mot de passe en prod, config oubliée. Rollback d’urgence à minuit.

Les trois avantages de Docker Compose

Avantage 1 : configuration as code, un fichier pour toute l’équipe

Docker Compose centralise tout dans docker-compose.yml :

• Quelle version de Nginx ? (nginx:1.25-alpine)
• Quelles extensions PHP ? (mysqli, pdo_mysql, redis)
• Paramètres MySQL ? (my.cnf unifié)
• Communication inter-services ? (résolution DNS automatique)

Ce fichier dans Git, toute l’équipe a le même environnement. Nouveau arrivant ? clone, docker-compose up -d, un café plus tard c’est prêt.

Plus besoin de demander « quel est ton mot de passe MySQL ? », « où est ton php.ini ? », « montre-moi ta config Nginx ». Un fichier règle tout.

Avantage 2 : démarrage/destruction en un clic, propre et net

Démarrer tous les services :

docker-compose up -d

Arrêter et supprimer tous les conteneurs :

docker-compose down

Changer de version PHP ? Une ligne : image: php:7.4-fpm → image: php:8.1-fpm, puis up. Terminé.

Contrairement à l’installation traditionnelle où désinstaller PHP laisse des résidus partout. Les conteneurs Docker sont isolés : on supprime, c’est propre.

Railway - Plateforme de déploiement moderne, sans opérations complexes, en ligne en quelques minutes

Commencer →Pub

Avantage 3 : isolation et coexistence multi-versions

PHP 7.4 et 8.1 en parallèle ? En traditionnel, deux installations PHP, deux ports, Nginx avec des fastcgi_pass différents. Fastidieux.

Avec Docker Compose, deux services PHP dans le fichier :

php74:
  image: php:7.4-fpm

php81:
  image: php:8.1-fpm

Nginx pointe vers le service voulu. Ancien projet sur php74, nouveau sur php81, sans conflit.

Le projet DNMP le plus star sur GitHub (imeepo/dnmp) dépasse 5000 étoiles : une solution mature, validée par de nombreuses équipes.

Architecture DNMP en détail

Qu’est-ce que DNMP

DNMP, c’est LNMP en version Docker. Quatre lettres, quatre composants :

• D = Docker : plateforme de conteneurisation, chaque service dans son « conteneur »
• N = Nginx : serveur web, reçoit HTTP, transmet à PHP
• M = MySQL : base relationnelle (remplaçable par MariaDB, PostgreSQL)
• P = PHP : PHP-FPM, exécute le code PHP

On ajoute souvent :

• Redis : cache, accélération des lectures
• PHPMyAdmin : administration visuelle MySQL

En LNMP traditionnel, tout est installé sur le système, mélangé. DNMP met chaque service dans un conteneur — comme des machines virtuelles légères.

Architecture d’orchestration

Imaginez une chaîne hi-fi : ampli, enceintes, lecteur. Chaque appareil fonctionne seul, mais il faut des câbles pour jouer ensemble.

Nginx, PHP et MySQL sont des conteneurs indépendants, reliés par le réseau Docker :

Flux de traitement :

1. Le navigateur envoie HTTP à localhost:80
2. Nginx reçoit, détecte un fichier PHP
3. Nginx transmet au conteneur PHP sur le port 9000 (service php)
4. PHP exécute le code, se connecte à MySQL si besoin (service mysql)
5. PHP renvoie le résultat à Nginx
6. Nginx renvoie le HTML au navigateur

Mécanisme de communication :
Docker Compose crée un réseau bridge et y connecte tous les services. Chaque service a un nom, résolu par DNS Docker.

Pour PHP → MySQL, pas besoin de 127.0.0.1:3306, écrivez mysql:3306. Docker résout mysql vers l’IP du conteneur.

Mapping de ports :

• Nginx :80 → hôte :80 (localhost)
• MySQL :3306 → hôte :3306 (Navicat, etc.)
• PHPMyAdmin :80 → hôte :8080 (localhost:8080)
• Redis :6379 → hôte :6379

Volumes :
Supprimer un conteneur efface les données ? Non, avec les volumes :

• ./www → /var/www/html (Nginx et PHP)
• ./mysql/data → /var/lib/mysql (fichiers MySQL)
• ./nginx/logs → /var/log/nginx (logs)

Recréer un conteneur, les données restent sur l’hôte.

Structure de répertoires

Structure DNMP standard :

dnmp/
├── docker-compose.yml       # Fichier d'orchestration principal
├── .env                     # Variables d'environnement (mots de passe, ports)
├── .gitignore               # .env exclu du Git
├── nginx/
│   ├── conf.d/
│   │   └── default.conf    # Config site (racine, règles PHP)
│   └── logs/
│       ├── access.log
│       └── error.log
├── php/
│   ├── Dockerfile          # Image PHP personnalisée (extensions)
│   ├── php.ini             # Config PHP (mémoire, upload)
│   └── php-fpm.conf        # Config PHP-FPM (processus)
├── mysql/
│   ├── data/               # Persistance base de données
│   └── my.cnf              # Config MySQL (charset, connexions max)
└── www/                    # Code projet
    └── index.php           # Fichier de test

Fichiers clés :

• docker-compose.yml : images, volumes, ports
• .env : ex. MYSQL_ROOT_PASSWORD=123456, infos sensibles à part
• nginx/conf.d/default.conf : racine web, règles PHP
• php/Dockerfile : image officielle + mysqli, redis, etc.
• mysql/data/ : données persistantes après recréation conteneur

Beaucoup de fichiers, mais chaque rôle est clair — contrairement au LNMP traditionnel éparpillé.

Pratique en 10 minutes : DNMP from scratch

Prérequis

1. Installer Docker

• Mac/Windows : Docker Desktop, docker-compose inclus
• Linux (Ubuntu) :

  sudo apt update
  sudo apt install docker.io docker-compose -y
  sudo systemctl start docker
  sudo systemctl enable docker

2. Vérifier l’installation

docker --version
# Sortie : Docker version 24.0.6, build xxx

docker-compose --version
# Sortie : Docker Compose version v2.21.0

3. Configuration recommandée

• RAM : au moins 4 Go (réglable dans Docker Desktop)
• Disque : au moins 20 Go libres
• Réseau : accès Docker Hub (miroir local si connexion lente)

Option 1 : projet open source mature (recommandé)

Pas envie de tout écrire ? Projet prêt, 10 minutes.

1. Cloner le projet

Je recommande imeepo/dnmp, compatible ARM (puces Apple M) :

git clone https://github.com/imeepo/dnmp.git
cd dnmp

2. Variables d’environnement

cp .env.example .env

Ouvrez .env et ajustez :

# Mot de passe root MySQL (évitez 123456)
MYSQL_ROOT_PASSWORD=your_strong_password

# Fuseau horaire
TZ=Asia/Shanghai

# Ports (8080 si 80 occupé)
NGINX_HTTP_PORT=80
MYSQL_PORT=3306

3. Démarrage en un clic

docker-compose up -d

-d = arrière-plan. Premier lancement : téléchargement d’images, quelques minutes. Succès typique :

Creating network "dnmp_default" with the default driver
Creating dnmp_mysql_1 ... done
Creating dnmp_php_1   ... done
Creating dnmp_nginx_1 ... done
Creating dnmp_redis_1 ... done

4. Vérifier

Navigateur → http://localhost : page phpinfo (version PHP, extensions).

Puis http://localhost:8080 : PHPMyAdmin

• Serveur : mysql (pas localhost)
• Utilisateur : root
• Mot de passe : celui du .env

5. État des conteneurs

docker-compose ps

Exemple :

Name               Command              State           Ports
--------------------------------------------------------------------
dnmp_nginx_1   nginx -g daemon off;   Up      0.0.0.0:80->80/tcp
dnmp_php_1     php-fpm                Up      9000/tcp
dnmp_mysql_1   docker-entrypoint...   Up      0.0.0.0:3306->3306/tcp
dnmp_redis_1   redis-server           Up      6379/tcp

State = Up : conteneur actif.

Option 2 : docker-compose.yml à la main (avancé)

Pour comprendre en profondeur.

1. Créer le projet

mkdir my-dnmp && cd my-dnmp
mkdir -p nginx/conf.d php mysql/data www

2. docker-compose.yml

Vultr - Serveur cloud NVMe haute performance, 32 emplacements mondiaux, déploiement Docker en un clic

Voir les tarifs →Pub

version: '3.8'

services:
  # Nginx
  nginx:
    image: nginx:1.25-alpine
    container_name: dnmp-nginx
    ports:
      - "80:80"
    volumes:
      - ./www:/var/www/html
      - ./nginx/conf.d:/etc/nginx/conf.d
      - ./nginx/logs:/var/log/nginx
    depends_on:
      - php
    networks:
      - dnmp-network

  # PHP
  php:
    build: ./php
    container_name: dnmp-php
    volumes:
      - ./www:/var/www/html
    networks:
      - dnmp-network

  # MySQL
  mysql:
    image: mysql:8.0
    container_name: dnmp-mysql
    ports:
      - "3306:3306"
    environment:
      MYSQL_ROOT_PASSWORD: root123456
      MYSQL_DATABASE: test_db
      TZ: Asia/Shanghai
    volumes:
      - ./mysql/data:/var/lib/mysql
    networks:
      - dnmp-network

  # Redis (optionnel)
  redis:
    image: redis:7-alpine
    container_name: dnmp-redis
    ports:
      - "6379:6379"
    networks:
      - dnmp-network

networks:
  dnmp-network:
    driver: bridge

3. Dockerfile PHP

php/Dockerfile :

FROM php:8.1-fpm

RUN apt-get update && apt-get install -y \
    libzip-dev \
    zip \
    unzip

RUN docker-php-ext-install \
    mysqli \
    pdo_mysql \
    zip \
    opcache

RUN pecl install redis && docker-php-ext-enable redis

WORKDIR /var/www/html

4. Config Nginx

nginx/conf.d/default.conf :

server {
    listen 80;
    server_name localhost;
    root /var/www/html;
    index index.php index.html;

    access_log /var/log/nginx/access.log;
    error_log /var/log/nginx/error.log;

    location ~ \.php$ {
        fastcgi_pass php:9000;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }

    location ~ \.(js|css|png|jpg|gif|ico)$ {
        expires 7d;
    }
}

5. Fichiers de test

www/index.php :

<?php
phpinfo();

www/db_test.php :

<?php
$host = 'mysql';
$user = 'root';
$pass = 'root123456';
$db = 'test_db';

try {
    $pdo = new PDO("mysql:host=$host;dbname=$db", $user, $pass);
    echo "Connexion base de données réussie !<br />";
    echo "Version MySQL : " . $pdo->getAttribute(PDO::ATTR_SERVER_VERSION);
} catch(PDOException $e) {
    echo "Échec connexion : " . $e->getMessage();
}

6. Démarrer

docker-compose up --build -d

--build reconstruit l’image PHP. Premier démarrage plus long.

Vérification et tests

1. PHP

http://localhost → phpinfo : PHP 8.1, extensions mysqli, pdo_mysql, redis enabled.

2. Base de données

http://localhost/db_test.php → « Connexion base de données réussie » et version MySQL.

Si échec :

• MySQL démarré ? docker-compose ps
• host = mysql, pas localhost
• mot de passe correct ?

3. État conteneurs

docker-compose ps

Tous en Up.

4. Logs

docker-compose logs php
docker-compose logs -f nginx

Bonnes pratiques en équipe

Stratégie de contrôle de version

Principe : config dans Git, secrets hors Git

.gitignore :

.env

mysql/data/

nginx/logs/*.log
php/logs/*.log

www/*
!www/.gitkeep

Fichiers à committer :

git add docker-compose.yml
git add .env.example
git add nginx/conf.d/
git add php/Dockerfile
git add php/php.ini
git add mysql/my.cnf
git commit -m "feat: add DNMP environment config"
git push

Onboarding (3 minutes) :

1. git clone xxx
2. cp .env.example .env
3. Modifier MYSQL_ROOT_PASSWORD dans .env
4. docker-compose up -d
5. docker exec -i dnmp-mysql mysql -uroot -p < backup.sql

Tout est dans les fichiers de config.

Coexistence multi-versions PHP

Scénario : ancien projet PHP 7.4, nouveau en 8.1.

Option : plusieurs services PHP dans docker-compose.yml

services:
  php74:
    image: php:7.4-fpm
    container_name: dnmp-php74
    volumes:
      - ./www:/var/www/html
    networks:
      - dnmp-network

  php81:
    image: php:8.1-fpm
    container_name: dnmp-php81
    volumes:
      - ./www:/var/www/html
    networks:
      - dnmp-network

Nginx par projet :

nginx/conf.d/old-project.conf :

server {
    listen 80;
    server_name old.local;
    root /var/www/html/old-project;

    location ~ \.php$ {
        fastcgi_pass php74:9000;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }
}

nginx/conf.d/new-project.conf :

server {
    listen 80;
    server_name new.local;
    root /var/www/html/new-project;

    location ~ \.php$ {
        fastcgi_pass php81:9000;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }
}

hosts :

127.0.0.1 old.local
127.0.0.1 new.local

http://old.local → PHP 7.4, http://new.local → PHP 8.1.

Persistance et sauvegarde

Persistance via ./mysql/data → /var/lib/mysql.

Script de backup — scripts/backup.sh :

#!/bin/bash
BACKUP_DIR="./backups"
DATE=$(date +%Y%m%d_%H%M%S)
MYSQL_CONTAINER="dnmp-mysql"
MYSQL_USER="root"
MYSQL_PASSWORD="root123456"
DATABASE="test_db"

mkdir -p $BACKUP_DIR

echo "Sauvegarde de $DATABASE..."
docker exec $MYSQL_CONTAINER mysqldump -u$MYSQL_USER -p$MYSQL_PASSWORD $DATABASE > $BACKUP_DIR/${DATABASE}_${DATE}.sql

echo "Terminé : $BACKUP_DIR/${DATABASE}_${DATE}.sql"

Cron :

crontab -e
0 2 * * * /path/to/scripts/backup.sh

Restauration :

docker exec -i dnmp-mysql mysql -uroot -proot123456 test_db < ./backups/test_db_20251218.sql

Problèmes courants et dépannage

Problème 1 : port occupé, échec de démarrage

Symptôme :

Error starting userland proxy: listen tcp4 0.0.0.0:80: bind: address already in use

Diagnostic :

🔥 Ne perdez plus des mois sur des produits sans demande ! Validez vos promesses SaaS avec Adsterra à petit budget →

Tester l'MVP →Pub

# Mac/Linux
lsof -i :80

# Windows
netstat -ano | findstr :80

Solutions :

• Arrêter le processus sur le port 80 (Apache, IIS)
• Ou NGINX_HTTP_PORT=8080 dans .env, accès via localhost:8080

Problème 2 : permissions de fichiers (Linux/Mac)

Symptômes : Nginx 403 Forbidden, PHP Permission denied

Cause : UID www-data (33) dans le conteneur ≠ UID hôte (1000).

Temporaire (dev) :

chmod -R 777 ./www

Correct (aligner UID) — php/Dockerfile :

FROM php:8.1-fpm

RUN usermod -u 1000 www-data && groupmod -g 1000 www-data

docker-compose build php
docker-compose up -d

Problème 3 : extension PHP manquante

Symptôme :

Fatal error: Call to undefined function mysqli_connect()

Diagnostic :

docker exec dnmp-php php -m

Solution : ajouter dans php/Dockerfile :

RUN docker-php-ext-install mysqli pdo_mysql

docker-compose build php
docker-compose restart php

Problème 4 : échec connexion base de données

Symptôme :

SQLSTATE[HY000] [2002] Connection refused

Erreurs fréquentes :

• host = localhost ou 127.0.0.1 (incorrect)
• MySQL pas encore prêt
• mauvais mot de passe

Correct :

$host = 'mysql';
$user = 'root';
$pass = 'root123456';

try {
    $pdo = new PDO("mysql:host=$host;dbname=test_db", $user, $pass);
    echo "Connexion réussie";
} catch(PDOException $e) {
    echo "Échec : " . $e->getMessage();
}

Vérifier MySQL :

docker-compose logs mysql

Attendre mysqld: ready for connections.

Problème 5 : conteneur qui s’arrête immédiatement

Symptôme : docker-compose ps → Exit 1 ou Exit 127

Diagnostic :

docker-compose logs nom_service

Causes :

1. Erreur syntaxe config (Nginx, indentation docker-compose.yml)
2. Variable manquante (MYSQL_ROOT_PASSWORD)
3. Dépendance non démarrée (PHP down → Nginx échoue)

Solution :

docker-compose down
docker-compose up -d

Conclusion

La valeur de Docker Compose pour DNMP se résume en trois points :

1. Gain de temps : 10 minutes, deux cafés en plus
2. Moins de pièges : environnement unifié, fini le « chez moi ça marche » à minuit
3. Maintenance simple : la config est la documentation

Avant, installation LNMP manuelle jusqu’à 2 h du matin. Avec Docker Compose : up, café, c’est prêt.

Essayez 10 minutes avant de quitter le bureau. Clonez imeepo/dnmp, sentez le démarrage en un clic, puis écrivez votre propre compose.

En cas de problème :

1. docker-compose logs
2. GitHub Issues du projet
3. Ouvrir une Issue — la communauté est active

Docker Compose ne sert pas qu’à PHP : Node.js, Python, Go — la même logique s’applique partout.

Prochaines étapes :

• Action immédiate : git clone https://github.com/imeepo/dnmp.git
• Approfondir : documentation Docker Compose (docker-compose.override.yml)
• Partager : transmettre à vos collègues qui installent encore à la main