Configurer un site WEB (PHP-Apache-Mysql) en 5 minutes avec Docker

Table des matières

Introduction

Si vous êtes un développeur PHP, vous développez peut-être encore vos applications web avec Apache installé sur votre ordinateur. Si un jour votre production change de version de PHP, ou même de MySQL, vous êtes donc obligé de suivre en vous mettant à jour, rencontrant potentiellement des problèmes de compatibilité etc. Imaginons maintenant que vous décidiez d’ajouter à votre application une mise en cache Redis, ou même une deuxième API devant être hébergée sur un autre serveur, ou encore un serveur de mail à part entière…Vous allez être obligé à chaque itération d’installer un nouveau serveur, de le connecter à Apache et de vous farcir des fichiers de configuration à la pelle. Un exemple qui est également très courant, est « Comment faire pour que des développeurs étant sur MAC, Linux et Windows puissent travailler sur une même version, sans avoir des configurations différentes » ?

Rien que d’y penser, vous allez vous triturer les méninges. Mais heureusement, Docker et Docker-compose sont là pour vous aider. Ils vont vous permettre, à l’aide de leur système de conteneurs, de réaliser tout cela en un temps record. (Si vous n’en connaissez pas le principe, je vous autorise à quitter temporairement cet article pour vous y renseigner, et les installer par la même occasion).

On peut néanmoins penser que la configuration de Docker nécessite un bon niveau de compréhension des systèmes d’informations, et de savoir fouiller parmi une énorme documentation pour réussir à avoir quelque chose de fonctionnel, donc y passer du temps. Il n’en est rien. Nous allons voir que pour configurer un simple site web (PHP-Apache-Mysql), il nous faut en tout 5 minutes (oui c’est promis !)

Architecture de l’application

Pour ce tutoriel, nous allons réaliser une seule page web, qui ira interroger une base de données, et en affichera les données d’une table. Le site est volontairement très succinct, afin de nous concentrer sur la simplicité d’action de Docker.

Pour cela, je vous propose l’arborescence et les fichiers suivants :

Arborescence d’une simple application web sous Docker

Avec uniquement ces 4 fichiers, nous allons être capable de construire un serveur apache contenant PHP, un serveur MySQL, et de faire communiquer les deux pour utiliser notre site web.

Ces 5 fichiers auront le rôle suivant :

app/index.php : Le point d’entrée de notre site web, on y écrira notre code PHP
build/mysql/Dockerfile : Fichier de configuration de Docker qui décrit comment installer MySQL
build/php/Dockerfile : Fichier de configuration de Docker qui décrit comment installer Apache et PHP
docker-compose.yml : Fichier de configuration de Docker-compose, qui, une fois exécuté, lancera les containers et fera tourner notre architecture.

Écriture de la configuration Docker

Vous l’aurez compris, toute la configuration va s’effectuer au sein des 3 fichiers concernant Docker. Nous aurons deux containers : Un pour PHP et Apache, et un autre pour MySQL. Voyons tout de suite comment procéder :

docker-compose.yml

version: "3.9"
services:
  php-apache:
    ports:
      - "80:80"
    build: './build/php'
    volumes:
      - ./app:/var/www/html
  mysql:
    ports:
      - "3306:3306"
    build: './build/mysql'
    environment:
      MYSQL_ROOT_PASSWORD: "super-secret-password"
      MYSQL_DATABASE: "my-wonderful-website"
    volumes:
      - dbData:/var/lib/mysql
volumes:
  app:
  dbData:

Voilà à quoi va ressembler notre docker-compose.yml, et il ne bougera pas. Il n’y a pas grand chose n’est-ce pas ? Décortiquons tout de même son contenu :

Nous retrouvons deux services, qui représentent nos deux containers :

php-apache, sera accessible depuis le port 80 de notre machine qui est le port par défaut de HTTP. Le site sera donc directement accessible depuis localhost. On y déclare que le code source, disponible dans le dossier « app », sera alors mappé vers la racine du serveur apache, soit « /var/www/html ». Enfin, la partie build va définir le process d’installation d’Apache et PHP, qui se trouvera dans le Dockerfile du répertoire « build/php », que nous détaillerons juste après.
mysql, sera accessible depuis le port 3306 de notre machine qui est le port par défaut de MySQL. Le site sera donc directement accessible depuis localhost. La partie build va définir le process d’installation de MySQL, qui se trouvera dans le Dockerfile du répertoire build/mysql. Deux variables sont déclarées et seront initialisées lors de l’installation de MySQL. MYSQL_ROOT_PASSWORD définit le mot de passe du compte root, MYSQL_DATABASE la database par défaut. Elle sera créée si elle n’existe pas au lancement du container. Un volume est également créé afin de rendre les données persistantes, et ainsi ne pas perdre les données de la base une fois le container éteint.

Écriture des Dockerfile

Ceci établi, il nous faut maintenant écrire les deux Dockerfile, qui vont détailler les procédures d’installation des deux serveurs. Vous êtes prêts ? Attention ça va être rapide :

Dockerfile Apache-PHP

FROM php:8.1-apache

RUN apt-get update && \
    docker-php-ext-install mysqli pdo pdo_mysql

Que fait-on ici ?

Nous allons tout simplement dire à Docker d’aller chercher l’image existante php-apache, qui contient donc apache et PHP à la version 8.1.

Enfin, on installe les extensions MySqli, PDO et PDO_MySQL dans PHP, qui nous seront bien utiles pour nous connecter à notre base de données.

Dockerfile Mysql

FROM mysql:latest
USER root
RUN chmod 755 /var/lib/mysql

Ici même fonctionnement, on demande à Docker d’aller récupérer la dernière version de MySQL depuis l’image existante. Ensuite, on effectue un changement de droits sur le répertoire « /var/lib/mysql » du conteneur qui sera créé, afin de permettre à PHP de s’y connecter.

La configuration est maintenant finie (et oui, déjà !). On peut tout de même, avant de lancer le build, ajouter un simple fichier index.php dans le dossier « app », histoire de vérifier que tout fonctionne bien. Sans originalité je vous propose celui-ci :

echo 'Hello world!';

Build et test du site

Maintenant que tous nos fichiers sont présents, il ne nous reste plus qu’à lancer les conteneurs, et à tester le résultat. Pour se faire, allez à la racine du site, et lancez simplement la commande :

$ docker-compose up

Le build va alors se lancer, télécharger les images voulues, et exécuter les commandes spécifiées :

Attendez quelques minutes que les images soient téléchargées, et une fois fait, vous devriez voir apparaître les logs de configuration d’Apache et de MySQL :

C’est signe que l’installation des containers est finalisée. Si vous ouvrez votre navigateur et que vous vous rendez sur http://localhost, vous verrez alors le contenu de votre index.php s’afficher :

Serveur Apache-PHP par Docker sur localhost

Test de la connection PHP-MySQL

Nous avons donc la confirmation qu’Apache ainsi que PHP sont bien actifs. Le premier container fait donc bien le job. Nous allons maintenant, pour faire le tour du sujet, vérifier que le container MySQL est bien actif, et que le premier peut bien s’y connecter.

Nous allons pour cela, nous connecter à MySQL depuis notre terminal, pour y insérer quelques données dans une table que nous allons créer, puis tenter d’afficher ces mêmes données depuis notre index.php.

Il vous faut le nom de votre container MySQL pour commencer. Rien de plus simple : Éxecutez la commande

$ docker ps --format '{{.Names}}'

dans un terminal. Copiez la sortie qui mentionne le mot « mysql ». Puis, nous allons effectuer cette suite de commande pour initialiser notre jeu de données :

# Connection au container MySQL
docker exec -ti test-php-mysql-docker-mysql-1 bash

# Connection au serveur MySQL
mysql -uroot -psuper-secret-password

# On se place sur la base de données créée au lancement du container
use my-wonderful-website;

# Création d'une Table "Persons", avec quelques colonnes
CREATE TABLE Persons (PersonID int, LastName varchar(255), FirstName varchar(255), Address varchar(255), City varchar(255));

# Insertion de quelques données dans cette table
INSERT INTO Persons VALUES (1, 'John', 'Doe', '51 Birchpond St.', 'New York');
INSERT INTO Persons VALUES (2, 'Jack', 'Smith', '24 Stuck St.', 'Los Angeles');
INSERT INTO Persons VALUES (3, 'Michele', 'Sparrow', '23 Lawyer St.', 'San Diego');

Ces quelques données maintenant enregistrées dans la base, il ne nous reste plus qu’à tenter de les afficher depuis notre serveur Apache. Modifions donc le contenu de notre index.php en conséquence afin d’y procéder :

<?php

$host = "mysql"; // Le host est le nom du service, présent dans le docker-compose.yml
$dbname = "my-wonderful-website";
$charset = "utf8";
$port = "3306";

try {
    $pdo = new PDO(
        dsn: "mysql:host=$host;dbname=$dbname;charset=$charset;port=$port",
        username: "root",
        password: "super-secret-password",
    );

    $persons = $pdo->query("SELECT * FROM Persons");

    echo '<pre>';
    foreach ($persons->fetchAll(PDO::FETCH_ASSOC) as $person) {
        print_r($person);
    }
    echo '</pre>';

} catch (PDOException $e) {
    throw new PDOException(
        message: $e->getMessage(),
        code: (int)$e->getCode()
    );
}

Direction notre navigateur…. et BINGO !

Accès à la base de données MySQL depuis le serveur Apache / Docker

Conclusion

Nous avons donc vu que paramétrer un serveur WEB, ainsi qu’un serveur MySQL avec Docker est d’une simplicité étonnante. Il est à noter que vous pouvez declarer autant de services que ce soit dans votre docker-compose, la limite n’étant que votre imagination. Alors j’espère vous avoir convaincu de désinstaller votre configuration locale et migrer sans plus attendre vers Docker !

Si vous souhaitez télécharger ce petit projet au complet, il est disponible ici au format ZIP. Extrayez-le, ouvrez un dossier dans ce terminal, et votre serveur est prêt !

Envie d’aller plus loin ? Apprends à débugguer comme un chef en lisant l’article dédié !