Création d'un Fichier docker-compose.yml pour PHP, phpMyAdmin et MySQL

Introduction

L'utilisation de Docker Compose permet de définir et d'exécuter des applications multi-conteneurs. Pour une application PHP utilisant une base de données MySQL et phpMyAdmin pour la gestion de la base de données, Docker Compose peut simplifier le processus de configuration et d'orchestration.

Structure du Fichier docker-compose.yml

Voici un exemple de fichier docker-compose.yml pour configurer PHP, phpMyAdmin, et MySQL :

version: '3.8'

services:
  web:
    image: php:7.4-apache
    container_name: php-web
    volumes:
      - ./php:/var/www/html
    ports:
      - "8080:80"
    depends_on:
      - db

  db:
    image: mysql:5.7
    container_name: mysql-db
    volumes:
      - db_data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: exampledb
      MYSQL_USER: exampleuser
      MYSQL_PASSWORD: examplepass
    ports:
      - "3306:3306"

  phpmyadmin:
    image: phpmyadmin/phpmyadmin
    container_name: phpmyadmin
    depends_on:
      - db
    environment:
      PMA_HOST: db
      PMA_PORT: 3306
      PMA_USER: root
      PMA_PASSWORD: rootpassword
    ports:
      - "5000:80"

volumes:
  db_data:

Explication de la Configuration

  • Service Web:

    • Utilise l'image php:7.4-apache qui est une image officielle de PHP avec Apache.
    • Le volume ./php:/var/www/html monte le dossier local ./php dans le répertoire racine du serveur web dans le conteneur, permettant la persistance du code PHP.
    • Expose le port 8080 de l'hôte sur le port 80 du conteneur, rendant l'application accessible via http://localhost:8080.

  • Service MySQL:

    • Utilise l'image mysql:5.7 pour le service de base de données.
    • Les variables d'environnement comme MYSQL_ROOT_PASSWORD définissent le mot de passe de l'utilisateur root, nécessaire pour se connecter à MySQL.
    • Le volume db_data est utilisé pour persister les données de la base de données au-delà de la vie du conteneur.

  • Service phpMyAdmin:

    • Utilise l'image phpmyadmin/phpmyadmin pour fournir une interface web de gestion de la base de données MySQL.
    • PMA_HOST et PMA_PORT indiquent à phpMyAdmin comment se connecter à MySQL.
    • Accessible via http://localhost:5000 grâce au mappage du port 5000 de l'hôte sur le port 80 du conteneur.

Bonnes Pratiques

  • Sécurité: Ne jamais utiliser les mots de passe par défaut ou les configurations par défaut dans les environnements de production. Changez toujours les mots de passe et les configurations pour des options plus sécurisées.
  • Volumes: Assurez-vous que les volumes utilisés pour la persistance des données ne causent pas de conflits de permissions entre le conteneur et le système hôte.
  • Gestion de l'environnement: Utilisez des fichiers .env pour gérer les variables d'environnement plutôt que de les stocker directement dans le fichier docker-compose.yml.

Configuration de Services Multiples et de Leurs Dépendances

Introduction à Docker Compose pour Services Multiples

Docker Compose est un outil puissant qui facilite la définition, l'exécution et la coordination de multiples services conteneurisés. Avec Docker Compose, vous pouvez facilement configurer une application composée de plusieurs services qui interagissent, tels que des bases de données, des serveurs back-end, des serveurs front-end, et des services d'assistance comme des moniteurs de logs ou des agents de surveillance.

Structure de Base d'un Docker Compose

Un fichier docker-compose.yml typique pour une application multi-services inclut plusieurs sections définissant chaque service, les réseaux, et les volumes nécessaires pour l'application.

version: '3.8'
services:
  web:
    image: nginx
    ports:
      - "80:80"
    depends_on:
      - app
  app:
    build:
      context: ./app
    depends_on:
      - db
  db:
    image: postgres
    environment:
      POSTGRES_DB: exampledb
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
networks:
  default:
    driver: bridge
volumes:
  db-data:

Définition et Gestion des Dépendances

  1. Utilisation de depends_on:

    • depends_on est une option dans Docker Compose qui spécifie les dépendances entre services. Par exemple, le service app peut nécessiter que le service db soit en cours d'exécution avant de démarrer.
    • Cela garantit que Docker tente de démarrer les conteneurs dans un ordre spécifique, mais notez que cela ne garantit pas que le service dépendant attendra que le service dont il dépend soit "prêt" (par exemple, que la base de données ait fini de démarrer) à moins que vous implémentiez une logique de santé spécifique dans vos conteneurs.

  2. Gestion des communications inter-services:

    • Les services définis dans un même fichier docker-compose.yml peuvent communiquer entre eux en utilisant le nom du service comme hostname. Par exemple, le service app peut accéder à la base de données db en utilisant le hostname db.

Meilleures Pratiques pour Configurer les Services Multiples

  1. Utilisation de Variables d'Environnement:

    • Stockez les configurations sensibles et spécifiques à l'environnement, comme les mots de passe et les configurations de base de données, dans des variables d'environnement au lieu de les coder en dur dans votre fichier Docker Compose.

  2. Réseaux Personnalisés:

    • Configurez des réseaux personnalisés pour mieux contrôler la communication entre les services. Cela peut aider à isoler les parties de votre application qui n'ont pas besoin de communiquer entre elles ou à appliquer des politiques de sécurité spécifiques.

  3. Gestion des Volumes:

    • Définissez des volumes pour les données qui doivent persister entre les redémarrages des conteneurs, comme les bases de données et les fichiers de configuration qui nécessitent un stockage persistant.

Ajout d'un Serveur Node.js et de PgAdmin dans Docker Compose

Structure de Base

Nous partons d'une configuration de base comprenant Nginx, une application PHP, et PostgreSQL. Voici comment vous pouvez ajouter Node.js et PgAdmin à cette pile :

version: '3.8'
services:
  web:
    image: nginx
    ports:
      - "8080:80"
    depends_on:
      - app
    volumes:
      - ./nginx/default.conf:/etc/nginx/conf.d/default.conf
  app:
    build:
      context: ./app
    depends_on:
      - db
  db:
    image: postgres
    environment:
      POSTGRES_DB: exampledb
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - db_data:/var/lib/postgresql/data
  node:
    build: ./node
    ports:
      - "3000:3000"
    depends_on:
      - db
  pgadmin:
    image: dpage/pgadmin4
    environment:
      PGADMIN_DEFAULT_EMAIL: admin@admin.com
      PGADMIN_DEFAULT_PASSWORD: admin
    ports:
      - "5050:80"
    depends_on:
      - db

volumes:
  db_data:

networks:
  default:
    driver: bridge

Détails de la Configuration

  1. Node.js Service:

    • Build: Pointe vers un répertoire contenant un Dockerfile pour le service Node.js. Ce Dockerfile doit configurer l'environnement Node.js, installer les dépendances, et définir comment l'application est exécutée.
    • Ports: Expose le port 3000 de Node.js au port 3000 de l'hôte, permettant l'accès à l'application Node.js via http://localhost:3000.
    • Dépendances: Dépend de la base de données pour garantir que le service de base de données est prêt avant de démarrer.

  2. PgAdmin:

    • Image: Utilise l'image officielle de PgAdmin pour fournir une interface web de gestion pour les bases de données PostgreSQL.
    • Environnement: Définit les variables d'environnement pour les identifiants par défaut de PgAdmin.
    • Ports: Expose le port 80 de PgAdmin au port 5050 de l'hôte, accessible via http://localhost:5050.
    • Dépendances: Dépend de db pour s'assurer que PgAdmin peut se connecter à PostgreSQL dès son démarrage.

Explication de la Configuration du Service PHP (app)

  • Build Context : Le context pointe vers le répertoire ./app qui contient les fichiers sources de l'application PHP ainsi que le Dockerfile. Ce Dockerfile est responsable de la configuration de l'environnement PHP, y compris l'installation de PHP, des extensions requises, et de toute configuration spécifique au projet.

  • Dockerfile : Le fichier Dockerfile pourrait ressembler à cela :

    • FROM php:7.4-apache COPY . /var/www/html RUN docker-php-ext-install mysqli pdo pdo_mysql

      Ce Dockerfile part de l'image de base php:7.4-apache, copie les fichiers source de l'application dans le répertoire par défaut du serveur web Apache, et installe les extensions PHP nécessaires pour interagir avec des bases de données comme MySQL.

  • Volumes : Le volume ./app:/var/www/html monte le code source de l'application PHP stocké localement dans le conteneur, permettant au serveur web Apache de servir l'application PHP.

  • Dépendances : Le service app dépend du service db (PostgreSQL dans ce cas), assurant que la base de données est disponible avant que l'application PHP ne démarre.

Conseils pour l'Intégration

  • Volumes pour Node.js: Si votre application Node.js utilise des fichiers qui doivent persister ou être partagés avec d'autres services, définissez des volumes appropriés.
  • Configuration de Nginx: Si Nginx doit servir le frontend pour l'application Node.js, configurez le default.conf de Nginx pour rediriger les requêtes vers le service Node.js.
  • Réseau: Tous les services utilisent le réseau par défaut, ce qui assure qu'ils peuvent communiquer entre eux sans configuration supplémentaire.

Résumé

Avec Docker Compose, la configuration et la gestion de votre application PHP avec MySQL et phpMyAdmin devient simple et efficace. Ce fichier docker-compose.yml fournit une base solide pour développer une application robuste, tout en facilitant la maintenance et les déploiements.

La configuration de services multiples dans Docker à l'aide de Docker Compose est un moyen efficace de gérer des applications complexes. En définissant clairement les services, leurs dépendances, et leurs communications dans un fichier docker-compose.yml, vous pouvez assurer que votre application fonctionne de manière coordonnée et fiable. Ce chapitre a couvert les aspects essentiels pour configurer ces services et fournir les meilleures pratiques pour une mise en œuvre réussie.

Cette configuration fournit une approche de base pour intégrer PHP dans une application Docker Compose avec plusieurs services. La présence d'un volume monté assure également que les modifications apportées localement au code PHP sont immédiatement reflétées dans le conteneur, ce qui est idéal pour le développement.

Last modified: Tuesday, 30 April 2024, 5:33 AM