Docker pour Développeurs Web : Guide Pratique 2026

En 2026, Docker est devenu l’outil standard de développement web. Plus de 70 % des développeurs web utilisent des conteneurs dans leur workflow selon le Stack Overflow Developer Survey 2025. WAMP, MAMP et XAMPP ont quasiment disparu des nouveaux projets professionnels. Pourquoi ? Parce que Docker résout le problème fondamental du développement en équipe : “ça marche sur ma machine”. Avec Docker, l’environnement de développement est défini dans un fichier texte (docker-compose.yml), versionné avec le code, et identique sur Mac, Windows, Linux et en production. Un nouveau développeur qui rejoint l’équipe lance docker-compose up et dispose d’un environnement complet en 5 minutes, sans installer PHP, MySQL ou Apache localement. Sur des projets WordPress ou Laravel avec des dizaines de dépendances, ce gain de temps est considérable.

Concepts Fondamentaux

Image vs Container : une image Docker est un template immuable (comme un ISO de Linux avec Apache et PHP déjà installés). Un container est une instance en cours d’exécution de cette image, comme un OS démarré depuis un ISO. Vous pouvez lancer 10 containers depuis la même image simultanément.

Dockerfile : fichier texte qui décrit comment construire une image custom. Chaque instruction (FROM, RUN, COPY, CMD) crée un layer qui est mis en cache pour accélérer les builds suivants.

Volumes : mécanisme de persistance des données. Sans volume, les données d’un container (base de données MySQL) disparaissent quand le container s’arrête. Deux types : les volumes nommés (gérés par Docker, persistants) et les bind mounts (lien direct vers un dossier de votre machine, idéal pour le développement).

Réseaux Docker : par défaut, docker-compose crée un réseau bridge isolé pour vos services. Les containers se contactent par leur nom de service (db, wordpress) comme si c’était des hostnames DNS.

Docker Hub : registre public d’images officielles. Vous y trouverez des images pour WordPress, MySQL, Nginx, PHP, Redis, etc. Chaque image a des tags de version (mysql:8.0, php:8.3-fpm).

Installation

Mac et Windows : installez Docker Desktop depuis docker.com. Docker Desktop inclut Docker Engine, Docker Compose, et une interface graphique. Sur Mac Apple Silicon (M1/M2/M3), Docker Desktop est optimisé nativement pour ARM.

Linux Ubuntu (méthode officielle) :

# Désinstaller d'éventuelles anciennes versions
sudo apt remove docker docker-engine docker.io containerd runc

# Installer les dépendances
sudo apt update
sudo apt install ca-certificates curl gnupg

# Ajouter la clé GPG officielle Docker
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Ajouter le dépôt Docker
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo $VERSION_CODENAME) stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Installer Docker Engine et Compose
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Utiliser Docker sans sudo
sudo usermod -aG docker $USER
newgrp docker

# Vérifier l'installation
docker --version
docker compose version

Premier Environnement WordPress

Voici un docker-compose.yml complet et commenté pour un environnement WordPress + MySQL + phpMyAdmin :

version: '3.8'

services:
  # Base de données MySQL
  db:
    image: mysql:8.0
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wpuser
      MYSQL_PASSWORD: wppassword
    volumes:
      # Volume nommé pour persister les données MySQL
      - db_data:/var/lib/mysql
    networks:
      - wp_network

  # WordPress
  wordpress:
    image: wordpress:6.4-php8.2-apache
    restart: unless-stopped
    depends_on:
      - db          # WordPress attend que MySQL soit prêt
    ports:
      - "8080:80"   # Accessible sur http://localhost:8080
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_NAME: wordpress
      WORDPRESS_DB_USER: wpuser
      WORDPRESS_DB_PASSWORD: wppassword
      WORDPRESS_DEBUG: 1
    volumes:
      # Bind mount : vos fichiers locaux sont synchronisés dans le container
      - ./wp-content:/var/www/html/wp-content
      - ./uploads.ini:/usr/local/etc/php/conf.d/uploads.ini
    networks:
      - wp_network

  # Interface graphique pour MySQL
  phpmyadmin:
    image: phpmyadmin:5.2
    restart: unless-stopped
    depends_on:
      - db
    ports:
      - "8081:80"   # Accessible sur http://localhost:8081
    environment:
      PMA_HOST: db
      PMA_PORT: 3306
    networks:
      - wp_network

# Volumes persistants
volumes:
  db_data:

# Réseau isolé pour les services
networks:
  wp_network:
    driver: bridge

Lancez avec docker compose up -d. WordPress sera accessible sur http://localhost:8080, phpMyAdmin sur http://localhost:8081.

Commandes Docker Essentielles

# === CONTAINERS ===
docker ps                          # Lister les containers actifs
docker ps -a                       # Tous les containers (actifs + arrêtés)
docker start nom_container         # Démarrer un container arrêté
docker stop nom_container          # Arrêter proprement un container
docker restart nom_container       # Redémarrer
docker rm nom_container            # Supprimer un container arrêté
docker rm -f nom_container         # Forcer la suppression

# Exécuter une commande dans un container
docker exec -it nom_container bash
docker exec -it wordpress wp --info  # WP-CLI dans le container

# Voir les logs
docker logs nom_container
docker logs -f nom_container       # Suivre les logs en temps réel
docker logs --tail 50 nom_container # 50 dernières lignes

# === IMAGES ===
docker images                      # Lister les images locales
docker pull wordpress:latest       # Télécharger une image
docker build -t mon-image:1.0 .    # Construire depuis un Dockerfile
docker push mon-image:1.0          # Pousser sur Docker Hub
docker rmi nom_image               # Supprimer une image

# === VOLUMES ===
docker volume ls                   # Lister les volumes
docker volume inspect nom_volume   # Détails d'un volume
docker volume rm nom_volume        # Supprimer un volume
docker volume prune                # Supprimer les volumes non utilisés

# === RÉSEAUX ===
docker network ls                  # Lister les réseaux
docker network inspect nom_reseau  # Détails

# === DOCKER COMPOSE ===
docker compose up -d               # Démarrer en arrière-plan
docker compose down                # Arrêter et supprimer les containers
docker compose down -v             # Idem + supprimer les volumes
docker compose ps                  # Statut des services
docker compose logs -f             # Logs de tous les services
docker compose exec wordpress bash # Shell dans le service wordpress
docker compose build               # Rebuilder les images

# === NETTOYAGE ===
docker system prune                # Nettoyer tout ce qui n'est pas utilisé
docker system prune -a             # Idem + images non utilisées

Workflow de Développement

Bind mounts pour l’édition en temps réel : la ligne - ./wp-content:/var/www/html/wp-content dans le docker-compose.yml crée un lien bidirectionnel entre votre dossier local et le container. Modifiez un fichier PHP dans votre éditeur → la modification est immédiatement visible dans le container sans redémarrage.

Variables d’environnement avec .env : créez un fichier .env à la racine de votre projet et référencez-le dans docker-compose.yml :

# .env
DB_PASSWORD=monmotdepasse
WP_DEBUG=1
SITE_URL=http://localhost:8080

# docker-compose.yml
environment:
  WORDPRESS_DB_PASSWORD: ${DB_PASSWORD}
  WORDPRESS_DEBUG: ${WP_DEBUG}

Ajoutez .env à votre .gitignore et commitez un .env.example comme référence.

Multi-stage builds pour optimiser les images de production :

FROM php:8.3-fpm AS builder
WORKDIR /app
COPY composer.json composer.lock ./
RUN composer install --no-dev --optimize-autoloader

FROM php:8.3-fpm AS production
WORKDIR /app
COPY --from=builder /app/vendor ./vendor
COPY . .
RUN rm -rf tests/ docker/ *.md

Docker en Production

Différences dev vs prod : en production, désactivez les bind mounts (les fichiers sont dans l’image), activez les variables d’environnement via un secret manager (AWS Secrets Manager, HashiCorp Vault), et configurez la journalisation vers un système centralisé (ELK Stack, Datadog).

Docker Swarm vs Kubernetes : Docker Swarm est l’orchestrateur intégré à Docker — simple à configurer, idéal pour les petites équipes. Kubernetes est le standard enterprise pour les clusters de grande taille, avec une courbe d’apprentissage importante mais une flexibilité maximale. Pour la majorité des projets WordPress et web (moins de 50 containers), Docker Swarm ou même un simple docker-compose en production suffisent.

GitHub Actions CI/CD avec Docker :

name: Deploy
on:
  push:
    branches: [main]
jobs:
  build-and-push:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}
      - uses: docker/build-push-action@v5
        with:
          push: true
          tags: monuser/monimage:${{ github.sha }}

Besoin d’un expert ? Développeur Full-Stack Paris →

Questions Fréquentes

Docker ralentit-il le développement WordPress ?

Sur Mac et Windows, Docker peut être légèrement plus lent que MAMP pour les opérations de fichiers en raison de la couche de virtualisation (WSL2 sur Windows, HyperKit sur Mac). Cependant, la différence est imperceptible sur un développement WordPress standard. Pour optimiser, utilisez les volumes nommés pour node_modules et vendor plutôt que des bind mounts, et activez les “File sharing” dans Docker Desktop uniquement pour les dossiers nécessaires. Docker Desktop sur Mac Apple Silicon a significativement amélioré ses performances avec les versions 4.x. Sur Linux natif, Docker ne présente pratiquement aucun overhead.

Peut-on utiliser Docker sur un hébergement mutualisé OVH ?

Non. Les hébergements mutualisés ne permettent pas d’exécuter Docker car cela nécessite des privilèges système (root, kernel namespaces, cgroups) que les hébergeurs mutualisés n’accordent pas pour des raisons de sécurité. Docker est réservé aux VPS, serveurs dédiés, et plateformes cloud. OVH propose ses solutions VPS à partir de 3,50 €/mois et des instances Public Cloud compatibles Docker/Kubernetes. Alternativement, des plateformes comme Railway, Render, ou Fly.io offrent le déploiement de containers Docker sans gestion de serveur, avec des tarifs adaptés aux petits projets.

Quelle est la différence entre docker-compose et Docker Swarm ?

Docker Compose est un outil de développement local : il orchestre plusieurs containers sur une seule machine depuis un fichier docker-compose.yml. Docker Swarm est un orchestrateur de cluster : il gère plusieurs containers répartis sur plusieurs machines (nœuds), avec load balancing, haute disponibilité et rolling updates. La syntaxe est similaire (les fichiers Compose v3 sont compatibles Swarm avec quelques ajustements), mais Swarm ajoute des fonctionnalités comme les secrets, les configs, et la réplication de services. Pour passer de Compose à Swarm, initialisez avec docker swarm init et déployez avec docker stack deploy au lieu de docker compose up.

Comment déboguer un container Docker qui ne démarre pas ?

Suivez cette procédure : d’abord, docker compose ps pour voir l’état des services. Ensuite, docker compose logs nom_service pour lire les logs d’erreur — c’est souvent suffisant pour identifier le problème (port déjà utilisé, variable d’environnement manquante, erreur de permission). Si le container démarre puis s’arrête immédiatement, tentez docker run -it --entrypoint bash image:tag pour démarrer une instance interactive et déboguer manuellement. Vérifiez aussi docker inspect nom_container pour voir la configuration complète et l’état des health checks. Les erreurs les plus courantes sont : port déjà utilisé sur l’hôte (changez le port dans docker-compose.yml), variable d’environnement manquante, ou permission refusée sur un fichier monté en volume.