0Pricing
PHP Academy · Leçon

Docker Compose pour les environnements locaux

Exécutez localement PHP, une base de données et un cache ensemble.

Docker Compose pour les environnements locaux est une leçon PHP Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage PHP Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours PHP Academy comprend 4 leçons au total.

Environnements locaux avec Compose

Les véritables applications PHP ne se limitent jamais à PHP : elles ont besoin d’une base de données, d’un cache, parfois d’une file d’attente et d’un outil de capture des courriels. Docker Compose déclare tous ces éléments comme des services dans un seul fichier et les relie à un réseau partagé afin qu’ils puissent se joindre par leur nom.

Cette leçon met en place un environnement local complet : PHP-FPM + nginx + MySQL + Redis, avec des volumes, des vérifications de santé et un ordre de dépendance.

Structure de service

Un fichier Compose répertorie les services sous services:. Chacun peut être construit à partir d’un Dockerfile avec build ou récupérer une image. Compose crée un réseau par défaut où chaque service est accessible via sa clé — votre application PHP se connecte à MySQL sur l’hôte db, et non à localhost.

services:
  app:
    build:
      context: .
      target: dev          # multi-stage dev target
    volumes:
      - ./:/app            # live code mount
    depends_on:
      db:
        condition: service_healthy
  db:
    image: mysql:8.4
  redis:
    image: redis:7-alpine

nginx devant FPM

FPM utilise FastCGI sur le port 9000, et non HTTP. nginx termine les connexions HTTP et transmet les requêtes .php par proxy à app:9000. La configuration nginx fait référence au service PHP par son nom Compose.

# docker/nginx/default.conf
server {
  listen 80;
  root /app/public;
  index index.php;

  location / {
    try_files $uri /index.php?$query_string;
  }

  location ~ \.php$ {
    fastcgi_pass app:9000;       # service name from compose
    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    include fastcgi_params;
  }
}

Raccorder le service web

Le service nginx monte le même code, afin de résoudre SCRIPT_FILENAME, ainsi que la configuration, publie le port 80 et dépend de l’application. Les deux partagent /app afin que les chemins correspondent de chaque côté de FastCGI.

services:
  web:
    image: nginx:1.27-alpine
    ports:
      - "8080:80"
    volumes:
      - ./:/app:ro
      - ./docker/nginx/default.conf:/etc/nginx/conf.d/default.conf:ro
    depends_on:
      - app

Volumes persistants

Les systèmes de fichiers des conteneurs sont éphémères. Les volumes nommés conservent les fichiers de base de données après docker compose down. Les montages liés (./:/app) synchronisent en direct le code de l’hôte pour le développement. Utilisez des volumes nommés pour les données persistantes et des montages liés pour le code source.

services:
  db:
    image: mysql:8.4
    environment:
      MYSQL_DATABASE: app
      MYSQL_USER: app
      MYSQL_PASSWORD: secret
      MYSQL_ROOT_PASSWORD: rootsecret
    volumes:
      - dbdata:/var/lib/mysql

volumes:
  dbdata:        # survives `down`, removed only by `down -v`

Vérifications de santé et dépendances

depends_on seul attend uniquement que le conteneur démarre, et non que MySQL accepte les connexions. Ajoutez une healthcheck et utilisez condition: service_healthy afin que votre application attende que la base de données soit réellement prête.

services:
  db:
    image: mysql:8.4
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-prootsecret"]
      interval: 5s
      timeout: 3s
      retries: 10
  app:
    build: .
    depends_on:
      db:
        condition: service_healthy   # waits for healthcheck pass

Environnement et .env

Compose charge automatiquement un fichier .env voisin pour l’interpolation des variables, et vous transmettez la configuration de l’application via environment ou env_file. Gardez les informations sensibles hors du fichier Compose versionné ; référencez plutôt les variables.

services:
  app:
    build: .
    env_file:
      - .env
    environment:
      DATABASE_URL: "mysql://app:secret@db:3306/app"
      REDIS_URL: "redis://redis:6379"
# .env (gitignored) provides ${...} substitutions
#   MYSQL_PASSWORD=secret

Se connecter depuis PHP

À l’intérieur du réseau, les noms d’hôte sont les noms des services. Votre code PHP se connecte directement à db et redis. Cet extrait analyse un DSN comme le ferait une couche de configuration, montrant comment le nom du service Compose se retrouve dans votre chaîne de connexion.

<?php
$dsn = 'mysql://app:secret@db:3306/app';
$p = parse_url($dsn);

printf("driver: %s\n", $p['scheme']);
printf("host:   %s\n", $p['host']);   // 'db' resolves via compose DNS
printf("port:   %d\n", $p['port']);
printf("db:     %s\n", ltrim($p['path'], '/'));

$pdoDsn = sprintf('mysql:host=%s;port=%d;dbname=%s', $p['host'], $p['port'], ltrim($p['path'], '/'));
echo $pdoDsn . PHP_EOL;
?>

Xdebug pour le développement local

Montez la configuration Xdebug uniquement en local, via la cible de construction dev. Définissez client_host sur host.docker.internal afin que le débogueur puisse atteindre votre IDE sur l’hôte. Ne déployez jamais Xdebug en production — cela dégrade fortement les performances.

; docker/php/xdebug.ini  (mounted only in dev)
zend_extension=xdebug
xdebug.mode=debug
xdebug.start_with_request=yes
xdebug.client_host=host.docker.internal
xdebug.client_port=9003

Exécuter des commandes ponctuelles

docker compose run lance un conteneur éphémère pour les migrations, les tests ou Composer ; exec exécute une commande dans un service déjà en cours d’exécution. Utilisez run --rm pour ces tâches afin que le conteneur jetable soit supprimé.

# Run migrations against the running db
docker compose exec app php bin/console doctrine:migrations:migrate

# One-off: install deps without a long-lived container
docker compose run --rm app composer install

# Tail logs of just the web service
docker compose logs -f web

Fichiers de surcharge

Compose fusionne automatiquement docker-compose.yml et docker-compose.override.yml. Conservez des valeurs par défaut proches de la production dans le fichier de base et placez les volumes, les ports et Xdebug réservés au développement dans la surcharge — ainsi, l’intégration continue utilise la base et les développeurs bénéficient automatiquement des éléments supplémentaires.

# docker-compose.override.yml (auto-merged, dev only)
services:
  app:
    volumes:
      - ./docker/php/xdebug.ini:/usr/local/etc/php/conf.d/xdebug.ini:ro
    environment:
      APP_ENV: dev
# CI runs: docker compose -f docker-compose.yml up  (no override)

Vérification rapide

Pourquoi un simple depends_on: [db] est-il insuffisant avant d’exécuter les migrations ?

Récapitulatif

Vous avez assemblé un environnement local avec Compose : PHP-FPM derrière nginx, avec FastCGI vers app:9000, MySQL et Redis accessibles par leur nom de service, des volumes nommés pour la persistance, des vérifications de santé qui conditionnent depends_on, une configuration pilotée par l’environnement, Xdebug dans une surcharge réservée au développement et des commandes ponctuelles via run/exec.

À retenir : les noms de service sont des noms d’hôte DNS, les fichiers de surcharge maintiennent les éléments supplémentaires du développement hors de l’intégration continue et les vérifications de santé sont préférables à un ordre de démarrage naïf.

Questions Fréquemment Posées

La leçon « Docker Compose pour les environnements locaux » est-elle gratuite ?

Oui — le texte complet de « Docker Compose pour les environnements locaux » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours PHP Academy, passe à CoddyKit PRO. Le cours PHP Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Docker Compose pour les environnements locaux » ?

Exécutez localement PHP, une base de données et un cache ensemble. Tu pratiques PHP Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer PHP Academy ?

Aucune expérience préalable n'est requise. PHP Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Docker Compose pour les environnements locaux » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon PHP Academy ?

Oui. Chaque leçon PHP Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Conteneuriser une application PHP
  2. Compilations multi-étapes et optimisation
  3. Docker Compose pour les environnements locaux
  4. CI/CD avec GitHub Actions
← Retour à PHP Academy