Utiliser le fichier hosts pour le développement Docker sur Mac

Docker a révolutionné le développement local en permettant de créer des environnements isolés et reproductibles. Sur Mac, combiner Docker avec le fichier hosts vous permet de développer avec des domaines personnalisés, exactement comme en production. Ce guide vous montre comment configurer efficacement Docker avec le fichier hosts pour un workflow de développement optimal.

Pourquoi utiliser Docker avec le fichier hosts ?

Avantages de cette approche

L'utilisation de Docker avec le fichier hosts offre plusieurs avantages majeurs :

• Environnements isolés : Chaque projet fonctionne dans son propre conteneur, sans conflits
• Reproductibilité : La même configuration fonctionne pour toute l'équipe
• Domaines personnalisés : Utilisez des noms de domaine réalistes au lieu de localhost:8080
• Proximité avec la production : Votre environnement local ressemble à la production
• Multi-services : Gérez facilement plusieurs services (web, base de données, cache) ensemble

Cas d'usage typiques

Cette configuration est idéale pour :

• Développement d'applications web multi-services
• Tests d'API avec des domaines personnalisés
• Développement de microservices
• Projets nécessitant plusieurs bases de données
• Applications nécessitant des services externes (Redis, Elasticsearch, etc.)

Installation de Docker sur Mac

Docker Desktop pour Mac

Docker Desktop est la méthode recommandée pour utiliser Docker sur macOS.

# Télécharger Docker Desktop depuis docker.com
# Ou installer via Homebrew
brew install --cask docker

Après l'installation, lancez Docker Desktop depuis Applications. L'icône Docker apparaîtra dans la barre de menu.

Vérifier l'installation

# Vérifier la version
docker --version
docker-compose --version

# Tester avec un conteneur simple
docker run hello-world

Configuration de base avec docker-compose

Structure d'un projet Docker typique

Voici la structure recommandée pour un projet utilisant Docker :

mon-projet/
├── docker-compose.yml
├── Dockerfile
├── .env
├── src/
│   └── index.php
└── docker/
    └── nginx.conf

Exemple docker-compose.yml basique

version: '3.8'

services:
  web:
    build: .
    ports:
      - "8080:80"
    volumes:
      - ./src:/var/www/html
    depends_on:
      - db
  
  db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: myapp
    ports:
      - "3306:3306"
    volumes:
      - db_data:/var/lib/mysql

volumes:
  db_data:

Configuration du fichier hosts pour Docker

Ajouter des entrées dans /etc/hosts

Pour utiliser des domaines personnalisés avec Docker, vous devez ajouter des entrées dans le fichier hosts :

# Éditer le fichier hosts
sudo nano /etc/hosts

# Ajouter vos domaines
127.0.0.1    monprojet.test
127.0.0.1    api.monprojet.test
127.0.0.1    admin.monprojet.test

Configuration docker-compose avec ports personnalisés

Une fois les entrées ajoutées dans le fichier hosts, configurez docker-compose pour mapper les ports :

version: '3.8'

services:
  web:
    build: .
    ports:
      - "80:80"      # Port standard HTTP
      - "443:443"    # Port HTTPS si nécessaire
    volumes:
      - ./src:/var/www/html
    networks:
      - app-network

networks:
  app-network:
    driver: bridge

Utiliser le port 80 sur Mac

Sur macOS, utiliser le port 80 nécessite des privilèges administrateur. Deux options :

Option 1 : Utiliser un port élevé (recommandé pour le développement)

services:
  web:
    ports:
      - "8080:80"  # Accès via monprojet.test:8080

Option 2 : Utiliser le port 80 directement

# Rediriger le port 80 vers 8080
sudo pfctl -f /etc/pf.conf
# Ajouter une règle de redirection dans pf.conf

Pour la plupart des cas, l'option 1 est plus simple et suffisante.

Gestion de plusieurs projets Docker

Configuration multi-projets

Quand vous travaillez sur plusieurs projets Docker simultanément, organisez votre fichier hosts :

# /etc/hosts

# ===================
# PROJET 1 : E-commerce
# ===================
127.0.0.1    shop.test
127.0.0.1    api.shop.test
127.0.0.1    admin.shop.test

# ===================
# PROJET 2 : Blog
# ===================
127.0.0.1    blog.test
127.0.0.1    cms.blog.test

# ===================
# PROJET 3 : API Backend
# ===================
127.0.0.1    api.test
127.0.0.1    api-v2.test

Docker Compose avec ports différents

Chaque projet doit utiliser des ports différents :

# Projet 1 : docker-compose.yml
services:
  web:
    ports:
      - "8080:80"

# Projet 2 : docker-compose.yml  
services:
  web:
    ports:
      - "8081:80"

# Projet 3 : docker-compose.yml
services:
  web:
    ports:
      - "8082:80"

Cependant, si vous utilisez le fichier hosts avec le port 80, vous pouvez utiliser le même port pour tous :

# Tous les projets peuvent utiliser 80:80
# car ils sont différenciés par le domaine dans hosts
services:
  web:
    ports:
      - "80:80"

Réseaux Docker et communication entre conteneurs

Créer un réseau Docker personnalisé

Les réseaux Docker permettent aux conteneurs de communiquer entre eux :

version: '3.8'

services:
  web:
    build: .
    ports:
      - "80:80"
    networks:
      - app-network
    depends_on:
      - db
      - redis

  db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: root
    networks:
      - app-network

  redis:
    image: redis:7-alpine
    networks:
      - app-network

networks:
  app-network:
    driver: bridge

Communication entre conteneurs

Les conteneurs peuvent communiquer via leurs noms de service :

// Dans votre application PHP
$dbHost = 'db';  // Nom du service, pas 'localhost'
$redisHost = 'redis';

// Dans Node.js
const dbHost = 'db';
const redisHost = 'redis';

Configuration avancée : Nginx reverse proxy

Utiliser Nginx comme reverse proxy

Pour gérer plusieurs projets avec le même port, utilisez Nginx comme reverse proxy :

version: '3.8'

services:
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./ssl:/etc/nginx/ssl
    depends_on:
      - web1
      - web2

  web1:
    build: ./projet1
    expose:
      - "80"
    networks:
      - app-network

  web2:
    build: ./projet2
    expose:
      - "80"
    networks:
      - app-network

networks:
  app-network:
    driver: bridge

Configuration Nginx

# nginx.conf
server {
    listen 80;
    server_name projet1.test;
    
    location / {
        proxy_pass http://web1:80;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

server {
    listen 80;
    server_name projet2.test;
    
    location / {
        proxy_pass http://web2:80;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Variables d'environnement et configuration

Utiliser un fichier .env

Créez un fichier .env pour vos variables d'environnement :

# .env
DB_HOST=db
DB_NAME=myapp
DB_USER=root
DB_PASSWORD=root
REDIS_HOST=redis
APP_ENV=local
APP_URL=http://monprojet.test

Référencer dans docker-compose.yml

services:
  web:
    build: .
    environment:
      - DB_HOST=\${DB_HOST}
      - DB_NAME=\${DB_NAME}
      - APP_URL=\${APP_URL}
    env_file:
      - .env

Volumes et persistance des données

Volumes nommés pour les bases de données

services:
  db:
    image: mysql:8.0
    volumes:
      - db_data:/var/lib/mysql
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql

volumes:
  db_data:

Volumes bind pour le code source

services:
  web:
    volumes:
      - ./src:/var/www/html  # Synchronisation bidirectionnelle
      - ./config:/var/www/config:ro  # Lecture seule

Gestion des logs Docker

Visualiser les logs

# Logs d'un service spécifique
docker-compose logs web

# Suivre les logs en temps réel
docker-compose logs -f web

# Logs des 100 dernières lignes
docker-compose logs --tail=100 web

Configuration de logging dans docker-compose

services:
  web:
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

Commandes Docker essentielles

Gestion des conteneurs

# Démarrer tous les services
docker-compose up -d

# Arrêter tous les services
docker-compose down

# Redémarrer un service spécifique
docker-compose restart web

# Voir les conteneurs en cours d'exécution
docker-compose ps

# Exécuter une commande dans un conteneur
docker-compose exec web bash
docker-compose exec db mysql -u root -p

Nettoyage

# Arrêter et supprimer les conteneurs
docker-compose down

# Supprimer aussi les volumes
docker-compose down -v

# Nettoyer les images non utilisées
docker system prune -a

Débogage et résolution de problèmes

Problème : Le conteneur ne démarre pas

# Vérifier les logs
docker-compose logs web

# Vérifier la configuration
docker-compose config

# Tester la connexion réseau
docker-compose exec web ping db

Problème : Le domaine ne résout pas

1. Vérifiez que l'entrée existe dans /etc/hosts 2. Flush le cache DNS : sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder 3. Vérifiez que le conteneur écoute sur le bon port : docker-compose ps

Problème : Port déjà utilisé

# Trouver quel processus utilise le port
lsof -i :80

# Arrêter le processus ou changer le port dans docker-compose.yml

Bonnes pratiques

Organisation des projets

• Un docker-compose.yml par projet
• Utilisez des noms de domaines cohérents (.test pour tous)
• Documentez les ports utilisés dans un README
• Versionnez vos fichiers docker-compose.yml

Performance

• Utilisez des images officielles optimisées (alpine pour Linux)
• Limitez les volumes bind aux fichiers nécessaires
• Utilisez .dockerignore pour exclure les fichiers inutiles

Sécurité

• Ne commitez jamais les fichiers .env avec des mots de passe
• Utilisez des secrets Docker pour les données sensibles
• Limitez l'exposition des ports aux besoins réels

Workflow de développement recommandé

Démarrage d'un nouveau projet

1. Créer le dossier du projet 2. Initialiser docker-compose.yml 3. Ajouter les entrées dans /etc/hosts 4. Créer le Dockerfile si nécessaire 5. Configurer les variables d'environnement 6. Lancer docker-compose up -d 7. Vérifier l'accès via le domaine personnalisé

Gestion quotidienne

# Matin : Démarrer les projets nécessaires
docker-compose up -d

# Pendant le développement : Voir les logs
docker-compose logs -f web

# Fin de journée : Arrêter les projets
docker-compose down

Intégration avec des outils de développement

Hot reload avec volumes

services:
  web:
    volumes:
      - ./src:/var/www/html
    # Le code change automatiquement dans le conteneur

Debugging avec Xdebug

services:
  web:
    environment:
      - XDEBUG_MODE=debug
      - XDEBUG_CONFIG=client_host=host.docker.internal
    extra_hosts:
      - "host.docker.internal:host-gateway"

Conclusion

Combiner Docker avec le fichier hosts sur Mac vous permet de créer des environnements de développement professionnels et reproductibles. Cette approche offre :

• Isolation : Chaque projet dans son propre environnement
• Simplicité : Domaines personnalisés au lieu de ports
• Reproductibilité : La même configuration pour toute l'équipe
• Flexibilité : Facile d'ajouter ou retirer des services

Pour gérer efficacement vos configurations de fichier hosts avec Docker, utilisez Locahl à 9,99€. Cette application macOS native vous permet de basculer rapidement entre différentes configurations, gérer plusieurs projets Docker, et éviter les erreurs de configuration. Avec le flush DNS automatique et les sauvegardes automatiques, Locahl simplifie considérablement votre workflow de développement avec Docker.

Que vous développiez des applications simples ou des architectures microservices complexes, Docker avec le fichier hosts est une combinaison puissante pour le développement moderne sur Mac.