TP N°2 : Migrer la stack manuelle vers un docker-compose.yml structuré

Objectif

Dans la section précédente, nous avons déployé notre application PHP manuellement avec plusieurs commandes docker run :

un conteneur MariaDB
un conteneur PHP-FPM
un conteneur Apache
un réseau Docker pour faire communiquer les services

Cette méthode fonctionne, mais elle devient vite difficile à maintenir.
L’objectif de ce TP est de recréer exactement la même stack avec Docker Compose, en utilisant une structure de projet claire.

Préparer la structure du projet

Commencez par créer un dossier pour votre projet.

mkdir monprojet-compose
cd monprojet-compose

Créez ensuite la structure suivante :

monprojet-compose/
├── docker-compose.yml
├── .env
├── app/
│   └── index.php
├── conf/
│   └── apache/
│       └── vhost.conf
└── data/
    └── mariadb/

Cette organisation sépare :

le code de l’application (app)
les fichiers de configuration (conf)
les données persistantes (data)

Préparer l’application PHP

Dans le dossier app, créez le fichier :

index.php

Exemple simple pour tester la connexion à la base de données :

<?php

$host = "mariadb";
$user = "root";
$password = "rootpassword";
$db = "testdb";

$conn = new mysqli($host, $user, $password, $db);

if ($conn->connect_error) {
    die("Erreur connexion BDD");
}

echo "Connexion BDD OK";

Remarquez un point important :
le serveur de base de données est nommé mariadb, ce qui correspondra au nom du service Docker Compose.

Configuration Apache

Dans :

conf/apache/vhost.conf

Ajoutez :

ServerName localhost

# Modules
LoadModule mpm_event_module modules/mod_mpm_event.so
LoadModule authz_core_module modules/mod_authz_core.so
LoadModule proxy_module modules/mod_proxy.so
LoadModule proxy_fcgi_module modules/mod_proxy_fcgi.so
LoadModule dir_module modules/mod_dir.so

DocumentRoot "/usr/local/apache2/htdocs"
DirectoryIndex index.php index.html

<Directory "/usr/local/apache2/htdocs">
    Options Indexes FollowSymLinks
    AllowOverride All
    Require all granted
</Directory>

# Protection et passage à PHP-FPM
<FilesMatch \.php$>
    # On vérifie d'abord si le fichier existe pour éviter des erreurs bizarres
    SetHandler "proxy:fcgi://php:9000"
</FilesMatch>

# Désactiver le proxy direct pour la sécurité
ProxyRequests Off

Apache va ainsi envoyer les fichiers PHP vers le conteneur PHP-FPM.

Créer le fichier `.env`

Le fichier .env permet de centraliser les paramètres :

MYSQL_ROOT_PASSWORD=rootpassword
MYSQL_DATABASE=testdb

Créer le fichier `docker-compose.yml`

Voici maintenant notre stack complète :

services:

  mariadb:
    image: mariadb:10.11
    container_name: monprojet-mariadb
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
      MYSQL_DATABASE: ${MYSQL_DATABASE}
    volumes:
      - ./data/mariadb:/var/lib/mysql

  php-fpm:
    image: php:8.2-fpm
    container_name: monprojet-php
    volumes:
      - ./app:/var/www/html

  apache:
    image: httpd:2.4
    container_name: monprojet-apache
    ports:
      - "8080:80"
    volumes:
      - ./app:/var/www/html
      - ./conf/apache/vhost.conf:/usr/local/apache2/conf/httpd.conf
    depends_on:
      - php-fpm

Chaque service correspond à un conteneur de notre ancienne stack.

Lancer la stack

Avant de démarrer, téléchargez les images :

docker compose pull

Puis lancez votre stack :

docker compose up -d

Vérifiez que les conteneurs tournent :

docker compose ps

Tester l’application

Ouvrez votre navigateur :

http://localhost:8080

Si tout fonctionne correctement, vous devriez voir :

Connexion BDD OK

Votre stack Apache + PHP-FPM + MariaDB fonctionne maintenant entièrement via Docker Compose.

Conclusion

Dans ce TP, nous avons transformé plusieurs commandes docker run complexes en un seul fichier docker-compose.yml.

Les avantages sont immédiats :

un déploiement plus simple
une configuration centralisée
une stack reproductible
une maintenance beaucoup plus facile

Il suffit désormais d’une seule commande pour démarrer toute l’infrastructure :

docker compose up -d

Compléments

Visualisation de la stack

Notre application est composée de trois services distincts qui communiquent entre eux à travers le réseau Docker créé automatiquement par Docker Compose.

Le fonctionnement est le suivant :

        Navigateur
             │
             ▼
        ┌─────────┐
        │ Apache  │
        │  (HTTP) │
        └────┬────┘
             │
             │ requêtes PHP (FastCGI)
             ▼
        ┌──────────┐
        │ PHP-FPM  │
        │ (moteur  │
        │   PHP)   │
        └────┬─────┘
             │
             │ requêtes SQL
             ▼
        ┌──────────┐
        │ MariaDB  │
        │ Base de  │
        │ données  │
        └──────────┘

Voici ce qui se passe lorsqu’un utilisateur visite votre site :

Le navigateur envoie une requête HTTP vers Apache.
Si la page contient du PHP, Apache transmet le traitement à PHP-FPM.
PHP exécute le code et interroge MariaDB pour récupérer ou stocker des données.
Le résultat remonte ensuite jusqu’au navigateur.

Grâce à Docker Compose, ces trois services peuvent communiquer simplement en utilisant leurs noms de services :

apache
php-fpm
mariadb

Par exemple, dans le code PHP nous utilisons :

$host = "mariadb";

Docker résout automatiquement ce nom vers le bon conteneur grâce au réseau interne de la stack.

Pourquoi activer `mod_proxy_fcgi` ?

Apache ne sait pas exécuter du PHP directement.
Il doit envoyer les fichiers .php à PHP-FPM, qui agit comme moteur PHP.

Le module mod_proxy_fcgi permet justement à Apache de transmettre les requêtes PHP au conteneur PHP-FPM.

Sans ce module :

Apache renvoie une erreur
ou propose de télécharger le fichier PHP

📌 À retenir
Avec Docker Compose :
chaque service = un conteneur
chaque service est accessible par son nom
tous les services du projet partagent un réseau Docker automatique
C’est ce qui permet à votre application de fonctionner comme une petite infrastructure complète, mais reproductible sur n’importe quelle machine.