Créer un environnement de développement PHP

Créé le 15 juin 2024

Au sommaire :

Dans cet article nous allons voir comment créer un environnement de développement local pour faire fonctionner une application Symfony 7 avec Docker.
Nous allons pour cela utiliser différentes techno (docker, docker compose, bash et yaml) mais je ferai mon possible pour en expliquer l'utilisation en espérant que chacun puisse suivre au mieux selon son niveau 🤓

Nous verrons ainsi comment lancer plusieurs conteneur afin de bénéficier d'un serveur Apache, d'une base de données MariaDb, de PhpMyAdmin ainsi que de Mailcatcher (pour tester nos envois de mails en local).

Et pour finir nous installerons Symfony 7 😊

Cet article fait partie du projet : Créer un blog avec Symfony 7
N'hésitez pas à consulter les prérequis de ce projet si vous ne l'avez pas déjà fait fait :)

1. Créer votre répertoire de travail

Vous pouvez créer votre répertoire de travail où vous le souhaitez sur votre système.
En ce qui me concerne je vais créer un répertoire "contribution-blog-symfony-7-docker" dans le répertoire "workstation" (ce dernier permettra d'acceuillir différents projets).

Dans un premier temps rendons nous dans le répertoire "home" de l'utilisateur courant :

cd ~

Puis on crée les répertoires "workstation" et "contribution-blog-symfony-7-docker" afin d'y mettre en place notre environnement :

mkdir -p workstation/contribution-blog-symfony-7-docker

Il ne reste plus qu'à se déplacer dans ce nouveau répertoire :

cd workstation/contribution-blog-symfony-7-docker

Rien de bien compliqué à ce stade mais ne vous inquiétez pas, ça va devenir plus intéressant par la suite 😉

2. Créer le fichier Dockerfile

Le fichier Dockerfile va nous permettre de choisir une image Docker existante et de la surcharger avec tout ce dont nous avons besoin pour faire fonctionner notre application Symfony.

Encore une fois, nous allons utiliser quelques commandes pour créer un répertoire destiné à recevoir le Dockerfile et nous y rendre :

mkdir -p automation/docker && cd automation/docker

Nous pouvons maintenent créer notre fichier Dockerfile :

touch Dockerfile

Cela étant fait, nous allons ouvrir le répertoire "contribution-blog-symfony-7-docker" dans un IDE afin de commencer l'édition du Dockerfile.
Personnellement j'utlise VScode mais vous pouvez bien sur utiliser l'éditeur de votre choix.

3. Définir notre server PHP/Apache dans le Dockerfile

C'est maintenant que les choses vont commencer à devenir intéressantes !

Pour rappel nous souhaitons mettre en place une application Symfony 7 qui employera un serveur Apache et une base de données MariaDb.

Nous allons commencer par choisir une image Docker PHP/Apache.
Pour cela vous pouvez vous rendre sur Docker Hub et rechercher parmis les images PHP disponibles :
https://hub.docker.com/_/php/tags

Choisissez l'image la plus récente ou celle qui correspond à vos besoins.
Ici nous utiliserons l'image la plus récente qui est actuellement "php:8.3.7-apache-bookworm".
Nous allons également définir un répertoire de travail à l'intérieur du conteneur qui sera "/var/www/html".

Voici les premières lignes de notre fichier Dockerfile :

# ./automation/docker/Dockerfile

# Base
FROM php:8.3.7-apache-bookworm

# Define workdir
WORKDIR /var/www/html

FROM php:8.3.7-apache-bookworm: L'instruction FROM permet d'indiquer l'image docker que nous souhaitons utiliser comme base.
Cette image peut être utilisée directement dans le fichier docker-compose.yml dans le cas où vous n'avez pas besoin de la surcharger (comme nous le verrons plus tard avec les images MariaDb, PhpMyAdmin et MailCatcher lors de la rédaction du fichier docker-compose.yml).
WORKDIR /var/www/html: L'instruction WORKDIR permet de définir le répertoire où sera placé notre projet à l'intérieur du conteneur Docker.

4. Installer les librairies Linux

Nous allons avoir besoin de différentes librairies, modules et autres extensions afin de faire fonctionner notre application Symfony.
Commençons par mettre à jour et installer quelques librairies Linux dans le conteneur.
Ajoutez les lignes suivantes à votre Dockerfile :

# ./automation/docker/Dockerfile
            
[...]

# Softwares
RUN apt-get update && apt-get install -y \
    acl \
    libicu-dev \
    nano \
    wget \
    zip

RUN apt-get update && apt-get install -y: L'instruction RUN permet de lancer des commandes sur le système d'exploitation.
Les commandes utilisées ici permettent de mettre à jour le système.
acl: Les ACL permettent de définir des permissions sur les fichiers et les répertoires sous un système Linux.
Ils seront utilisés par le fichier "docker-entrypoint.sh" afin de gérer les droits de certains répertoires de notre application.
Nous verrons cela plus tard dans cet article.
libicu-dev: Cette librairie permet de gérer les composants internationaux pour Unicode.
C'est une dépendance du module PHP intl (internationalisation ou i18n) qui est un prérequis au bon fonctionnement de Symfony.
nano: Nano est un éditeur de fichier dans la console.
Il n'est pas indispensable mais peut être utile si l'on souhaite par example modifier une configuration du fichier php.ini directement dans le conteneur.
Cela permettrait de tester ces modifications sans avoir à reconstruire l'image Docker.
wget: Wget permet de télécharger des fichiers depuis le web.
Cette commande sera utilisée pour télécharger Symfony CLI mais aussi par le script d'installation de Composer que nous créerons plus loin dans cet article.
zip: Zip est un utilitaire permettant de compresser/décrompresser des fichiers et des répertoires.
Il sera utilisé par Composer lors de l'installation ou la mise à jour des bundles.

5. Activer les modules Apache

Ajoutons à cela quelques modules Apache :

# ./automation/docker/Dockerfile
            
[...]

# Apache modules
RUN a2enmod \
    rewrite \
    expires \
    headers

a2enmod: Cette commande signifie "Apache2 enable module" et nous permet donc d'activer des modules Apache.
rewrite: Le module rewrite permet l'utilisation de la réécriture d'url.
expires: Le module expire permet de définir une date d'expiration pour les différents types de fichiers d'un site web.
Cela permet au navigateur web d'utiliser les fichiers en cache tant que la date d'expiration définie n'est pas atteinte.
headers: Le module headers permet de gérer les en-têtes des requêtes et des réponses HTTP.

6. Ajouter les extensions PHP

Passons maintenant aux extensions PHP :

# ./automation/docker/Dockerfile
            
[...]

# Extension PHP
RUN docker-php-ext-install \
    pdo_mysql \
    opcache \
    intl

docker-php-ext-install: Cette commande permet d'installer des extensions PHP afin de lui ajouter de nouveaux comportements.
pdo_mysql: Ce pilote permet de gérer les transactions entre PHP et une base de données MySQL.
opcache: Cette extension permet d'améliorer les performances de PHP en stockant le code pré-compilé en mémoire.
C'est un prérequis au bon fonctionnement de Symfony.
intl: Cette extension permet à PHP de gérer l'internationalisation.
Elle est un prérequis au bon fonctionnement de Symfony qui l'utilise pour les validators.

6. Ajouter les extensions PHP

Ajouter les extensions PHP

7. Redéfinir le fichier php.ini

Le fichier php.ini permet de configurer le comportement de l'interpréteur PHP.

Pour rappel nous souhaitons créer un environnement de dévelopement.
Nous allons donc utiliser comme base le fichier php.ini de développement qui est disponible dans notre conteneur :

# ./automation/docker/Dockerfile
            
[...]

# Copy php.ini
RUN cp /usr/local/etc/php/php.ini-development /usr/local/etc/php/php.ini \
    && echo 'short_open_tag = Off' >> /usr/local/etc/php/php.ini

cp /usr/local/etc/php/php.ini-development /usr/local/etc/php/php.ini: La commande "cp" permet de copier un fichier.
Ici nous copions le fichier php.ini-development présent dans le conteneur afin de créer le fichier php.ini qui sera utilisé par défaut.
echo 'short_open_tag = Off' >> /usr/local/etc/php/php.ini: Cette commande permet d'ajouter la valeur 'short_open_tag = Off' à la fin du fichier php.ini.
Cela aura pour effet d'être la valeur prise en compte par l'interpréteur PHP.
Encore une fois, cela permet de répondre aux prérequis de Symfony.

8. Configurer le vhost Apache

Le fichier vhost permet à Apache de comprendre comment traiter les requêtes http qu'il reçoit.
Nous allons donc créer une fichier "default-vhost.conf" qui contiendra les instructions suivantes :

# ./automation/docker/default-vhost.conf
            
<VirtualHost *:80>
    

    ServerName localhost
    DocumentRoot /var/www/html/public
    

    <Directory "/var/www/html/public">
        Options Indexes FollowSymLinks
        AllowOverride All
        Require all granted
        
        RewriteEngine On
        
        RewriteCond %{HTTP:Authorization} .+
        RewriteRule ^ - [E=HTTP_AUTHORIZATION:%0]
        
        RewriteCond %{REQUEST_FILENAME} -f
        RewriteRule .? - [L]
        RewriteRule .? index.php [L]
    </Directory>
    
    CustomLog /var/log/apache2/default-access.log combined
    ErrorLog /var/log/apache2/default-error.log
    
</VirtualHost>

Certaines de ces directives peuvent être placées dans un fichier .htaccess grace à l'instruction "AllowOverride All" qui permet de surcharger la configuration présente ici.
En effet, la partie concernant la réécriture d'url devrait à mon sens se trouver dans un fichier .htaccess placé dans le répertoire "public" de notre application.
Cela permettrait d'éviter les surprises lors d'une mise en prod sur un serveur où vous n'avez pas accès aux fichiers de configurations vhost d'Apache.

Je n'ai placé ces lignes ici que dans un but pédagogique afin que vous compreniez mieux l'utilisation de ce fichier 😊

Ajoutons le dans notre fichier Dockerfile :

# ./automation/docker/Dockerfile

[...]

# Add vhost
COPY ./automation/docker/default-vhost.conf /etc/apache2/sites-available/
RUN a2dissite 000-default.conf \
    && a2ensite default-vhost.conf

COPY ./automation/docker/default-vhost.conf /etc/apache2/sites-available/: L'instruction COPY permet de copier un fichier depuis notre sytème vers le conteneur.
a2dissite 000-default.conf: "Apache2 disable site" permet de désactiver un vhost (correspondant à un site).
a2ensite default-vhost.conf: "Apache2 enable site" permet donc de faire l'inverse.

9. Installer Symfony CLI

Symfony CLI permet d'utiliser quelques commandes utiles à l'installation de Symfony, la vérification des prérequis ou encore la sécurité (et bien d'autres).

Si vous souhaitez en savoir d'avantage sur les possibilités offertes par symfony CLI, vous pourrez utilser la commande symfony -h dans le conteneur "blog-server".

Voici comment installer Symfony CLI dans notre conteneur :

# ./automation/docker/Dockerfile

[...]

# Symfony CLI
RUN wget https://get.symfony.com/cli/installer -O - | bash \
    && chmod +x /root/.symfony5/bin/symfony \
    && mv /root/.symfony5/bin/symfony /usr/local/bin/symfony

wget https://get.symfony.com/cli/installer -O - | bash: Cette commande nous permet de télécharger et d'installer l'exécutable Symfony CLI.
chmod +x /root/.symfony5/bin/symfonys: La commande chmod permet de modifier les droits d'un fichier ou d'un répertoire.
Ici nous attribuons les droits d'exécution pour le fichier /root/.symfony5/bin/symfony.
mv /root/.symfony5/bin/symfony /usr/local/bin/symfony: La commande mv permet de déplacer un fichier ou un répertoire.
Ici nous déplaçons le fichier symfony du répertoire /root/.symfony5/bin/ (où il a été installé par défaut) vers le répertoire /usr/local/bin/symfony.

10. Installer Composer

Composer est un gestionnaire de dépendances pour applications PHP.
Il nous permettra par la suite d'installer, mettre à jour et supprimer les bundles que nous utiliserons avec Symfony.
N'hésitez pas à consulter le site de Composer : https://getcomposer.org/

Nous allons ici écrire un petit script afin de gérer l'installation d'une version donnée de Composer.
Rendons nous dans le répertoire "automation/scripts/" afin d'y créer le fichier "composer-setup.sh" :

# ./automation/scripts/composer-setup.sh

#!/bin/sh

VERSION="2.7.4"

INSTALL_DIR="/usr/local/bin"
EXPECTED_CHECKSUM="$(wget -q -O - https://composer.github.io/installer.sig)"
php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
ACTUAL_CHECKSUM="$(php -r "echo hash_file('sha384', 'composer-setup.php');")"

if [ "$EXPECTED_CHECKSUM" != "$ACTUAL_CHECKSUM" ]
then
    >&2 echo 'ERROR: Invalid installer checksum'
    rm composer-setup.php
    exit 1
fi

php composer-setup.php --quiet --version=$VERSION --install-dir=$INSTALL_DIR
RESULT=$?
rm composer-setup.php
mv $INSTALL_DIR/composer.phar $INSTALL_DIR/composer
chmod +x $INSTALL_DIR/composer

exit $RESULT

Nous pouvons maintenant copier ce script dans notre conteneur Docker :

# ./automation/docker/Dockerfile

[...]

# Composer
COPY ./automation/scripts/composer-setup.sh /tmp
RUN bash /tmp/composer-setup.sh

COPY ./automation/scripts/composer-setup.sh /tmp: Comme nous l'avons vu plus tôt, cette instruction permet de copier le fichier "composer-setup.sh" vers le répertoire /tmp présent dans le conteneur.
RUN bash /tmp/install-composer.sh: Il ne reste plus qu'à lancer l'éxécution de ce fichier pour installer Composer dans le conteneur.

11. Installer APCu

APCu est un cache stocké en mémoire pour PHP.
N'hésitez pas à consulter cette page du manuel PHP si vous souhaitez en savoir d'avantage :
https://www.php.net/manual/fr/book.apcu.php

Poursuivons l'édition de notre Dockerfile avec l'installation d'APCU :

# ./automation/docker/Dockerfile

[...]

# APCU
RUN pear config-set http_proxy "${http_proxy}" \
    && pecl channel-update pecl.php.net \
    && pecl install apcu
RUN echo "extension=apcu.so\napc.enable_cli=on" > /usr/local/etc/php/conf.d/apcu.ini

RUN pear config-set http_proxy "${http_proxy}": On commence par définir la variable d'environnement "http_proxy" pour le gestionnaire de packages PEAR.
&& pecl channel-update pecl.php.net: Ensuite, on met à jour PECL vers la dernière version.
&& pecl install apcu: Il ne reste plus qu'à installer APCu.
RUN echo "extension=apcu.so\napc.enable_cli=on" > /usr/local/etc/php/conf.d/apcu.ini: Et à l'activer dans la configutation d'Apache.

12. Installer XDebug

XDebug est une extension apportant des outils utiles à l'analyse, à la compréhension et à la correction de code en PHP.
Il nous sera également utile pour utiliser la couverture de tests avec PHPUnit.
Vous pouvez consulter le site https://xdebug.org/ si vous souhaitez en savoir plus.

# ./automation/docker/Dockerfile

[...]

# X-Debug
RUN pecl install xdebug-3.3.2 \
    && echo 'xdebug.mode=develop,debug,coverage' >> /usr/local/etc/php/php.ini \
    && echo 'xdebug.client_host=host.docker.internal' >> /usr/local/etc/php/php.ini \
    && docker-php-ext-enable xdebug

RUN pecl install xdebug-3.3.2: On commence par installer la version 3.3.2 de XDebug via PECL.
echo 'xdebug.mode=develop,debug,coverage' >> /usr/local/etc/php/php.ini: On configure XDebug afin de pouvoir l'utiliser pour le développement, le débugging et la couverture de tests.
echo 'xdebug.client_host=host.docker.internal' >> /usr/local/etc/php/php.ini: On indique ici le host où se trouve le client XDebug.
Dans notre cas "host.docker.internal" qui est un nom de DNS permettant de retrouver l'adresse IP du conteneur Docker.
docker-php-ext-enable xdebug: Et enfin on active l'extension.

13. Nettoyer les répertoires temporaires

L'installation de ces différents programmes à laissé derrière elle beaucoup de fichiers qui ne nous seront plus utiles.
Nous pouvons donc les supprimer à l'aide de l'instruction suivante :

# ./automation/docker/Dockerfile

[...]

# Clean the mess
RUN apt-get clean \
    && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*

14. Ajouter un entrypoint pour lancer Apache au démarrage du conteneur

Lorsque l'on démarrera notre conteneur, ce dernier attendra une instruction.
Si aucune ne lui est fournie il s'éteindra automatiquement.

Nous allons donc utiliser un entrypoint afin de lancer le serveur Apache en tâche de fond.

Nous allons pour cela créer un fichier "docker-entrypoint.sh" dans le répertoire "automation/scripts" et ajouter le contenu suivant :

# ./automation/scripts/docker-entrypoint.sh

#!/bin/bash
set -e

## SET PERMISSIONS ###
# See https://symfony.com/doc/current/setup/file_permissions.html
echo ::: $(date) :::
echo :::::::::::::::: SET PERMISSIONS ::::::::::::::::::::::::
echo :::::::::::::::::::::::::::::::::::::::::::::::::::::::::
mkdir -p var
HTTPDUSER=$(ps axo user,comm | grep -E '[a]pache|[h]ttpd|[_]www|[w]ww-data|[n]ginx' | grep -v root | head -1 | cut -d\  -f1)
setfacl -dR -m u:"$HTTPDUSER":rwX -m u:$(whoami):rwX var
setfacl -R -m u:"$HTTPDUSER":rwX -m u:$(whoami):rwX var

echo "PERMISSIONS SET successfully"

### RUN APACHE ###
echo ::: $(date) :::
echo :::::::::::::::: RUN APACHE :::::::::::::::::::::::::::::
echo :::::::::::::::::::::::::::::::::::::::::::::::::::::::::
bash apache2-foreground

echo :::::::::::::::: FINISHED ::::::::::::::::::::

La partie "SET PERMISSIONS" permet d'appliquer les droits appropriés au répertoire "var" qui sera utilisé par Symfony.
La commande "mkdir -p var" permet de créer le répertoire "var" sans quoi les lignes suivantes déclancheraient une erreur lors du premier lancement de notre environnement.

Il ne nous reste plus qu'à placer ce fichier dans notre conteneur afin qu'il soit exécuté au démarrage de ce dernier :

# ./automation/docker/Dockerfile

[...]

# Add Entrypoint
COPY ./tools/scripts/docker-entrypoint.sh /usr/local/bin/docker-entrypoint.sh
RUN chmod +x /usr/local/bin/docker-entrypoint.sh

# Run
CMD ["/usr/local/bin/docker-entrypoint.sh"]

COPY ./tools/scripts/docker-entrypoint.sh /usr/local/bin/docker-entrypoint.sh: Comme vu précédemment nous copions le fichier "docker-entrypoint.sh" dans le répertoire "/usr/local/bin/" du conteneur.
RUN chmod +x /usr/local/bin/docker-entrypoint.sh: Et ici nous rendons ce fichier exécutable.
CMD ["/usr/local/bin/docker-entrypoint.sh"]: Nous pouvons maintenant indiquer à Docker qu'il devra exécuter ce fichier au lancement du conteneur.

Et voilà, notre Dockerfile est prêt !

15. Utiliser Docker compose

A ce stade, nous avons configuré un serveur PHP/Apache qui correspond à nos besoin (et aux prérequis de Symfony) !
Et c'est suffisant pour faire tourner une application Symfony dans le cas où vous n'avez pas besoin de base de données.

Mais dans notre cas, nous souhaitons utiliser une base de données MariaDb.
Dans cette optique il serait intéressant de pouvoir également disposer d'un SGBD tel que PhpMyAdmin.
Et autant en profiter pour installer de quoi tester nos envois de mails en local !

Pour réaliser tout cela nous allons utiliser docker compose.
Nous allons donc créer un fichier "docker-compose.yml" à la racine du projet.

# ./docker-compose.yml

services:

    server:
        build:
            context: .
            dockerfile: ./automation/docker/Dockerfile
        conteneur_name: blog-server
        volumes:
            - ./:/var/www/html
        links:
            - mysql
        ports:
            - 80:80

services: Cette première ligne permet d'indiquer que nous allons déclarer les différents conteneur que nous souhaitons utiliser dans notre environnement.
server: On indique ici le libellé de notre premier conteneur.
build: Cette partie permet de renseigner les informations dont à besoin docker compose pour construire notre image Docker.
Dans notre cas, le "context" correspond à la racine du projet.
On indique ensuite où se trouve le fichier Dockerfile.
conteneur_name: Cela permet de nommer le conteneur.
Ce sera utile plus tard pour utiliser des commandes docker.
volumes: Ce paramètre contient 2 informations séparées par le caractère ":".
Le paramètre de gauche "./" correspond au répertoire courant où se trouve le fichier "docker-compose.yml" (la racine du projet).
Celui de droite "/var/www/html" correspond au répertoire où seront montés les fichiers à l'intérieur du conteneur.
links: Cette ligne nous permet de lier le service "server" au service "mysql" que nous allons créer juste après.
Cela permettra au server de communiquer avec la base de données MariaDb.
ports: Comme pour la déclaration du volume, il y a ici 2 informations séparées par le caractère ":".
Pour le paramètre cité à gauche, nous indiquons le port d'écoute de notre navigateur.
Celui de droite définit celui à l'intérieur du conteneur.
Cela permet de mapper ces ports afin que lorsque l'on utilise le port 80 sur notre navigateur il interroge le port 80 à l'intérieur du conteneur (comme nous l'avons configuré sur Apache).

# ./docker-compose.yml

[...]

    mysql:
        image: mariadb:${DB_VERSION:-10.4}
        conteneur_name: blog-mysql
        environment:
            MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD:-toor}
            MYSQL_DATABASE: ${DB_DATABASE:-app}
            MYSQL_USER: ${DB_USER:-user}
            MYSQL_PASSWORD: ${DB_PASSWORD:-resu}
        ports:
            - ${DB_PORT:-3306}:${DB_PORT:-3306}

Nous déclarons ici le service "mysql".
Le point notable est l'utilisation de variables d'environnement avec leur valeur par default : "${VARIABLE:-valeur}".
Ces variables d'environnement peuvent être déclarées dans le fichier .env.

# ./docker-compose.yml

[...]

    phpmyadmin:
        image: phpmyadmin:latest
        conteneur_name: blog-phpmyadmin
        environment:
            - PMA_HOST=${DB_HOST:-mysql}
            - PMA_USER=${DB_USER:-user}
            - PMA_PASSWORD=${DB_PASSWORD:-resu}
        links:
            - mysql
        ports:
            - 8090:80

On déclare maintenant un service pour PhpMyAdmin afin d'administrer notre base de données.

# ./docker-compose.yml

[...]

    mailer:
        image: schickling/mailcatcher
        conteneur_name: blog-mailcatcher
        ports: 
            - 1025:1025
            - 1080:1080

Et pour finir, un service "mailer" qui nous permettra de tester la réception de nos emails en local.

16. Contruire le conteneur PHP/Apache

Nous sommes maintenant prêts à construire notre environnement local !
Nous allons donc employer la commande "docker compose" à la racine de notre projet afin de construire le conteneur Apache/PHP :

Retournons sur notre terminal et lançons la commande suivante :

docker compose build

Cela prendra quelques minutes en fonction de la puissance de votre machine et de la vitesse de votre connexion internet.
C'est le moment idéal pour faire une pause et prendre un café ☕

17. Démarrer l'environnement de développement

Il est temps de télécharger les autres images dont nous avons besoin et de démarrer notre environnement de développement !
Encore une fois, "docker compose" permet de réaliser cela très simplement :

docker compose up

Cette fois encore, il faudra attendre quelques minutes afin que les images MariaDb, PhpMyAdmin et MailCatcher soient téléchargées.
Vous verrez ensuite apparaitre les logs des différents conteneurs à l'écran :


dev@DESKTOP-2291OCF:~/workstation/contribution-blog-symfony-7-docker$ docker compose up
[+] Running 4/0
 ✔ conteneur blog-mysql        Created                                                                                                                                                                   0.0s
 ✔ conteneur blog-mailcatcher  Created                                                                                                                                                                   0.0s
 ✔ conteneur blog-server       Created                                                                                                                                                                   0.0s
 ✔ conteneur blog-phpmyadmin   Created                                                                                                                                                                   0.0s
Attaching to blog-mailcatcher, blog-mysql, blog-phpmyadmin, blog-server
blog-mysql        | 2024-06-15 11:41:41+00:00 [Note] [Entrypoint]: Entrypoint script for MariaDB Server 1:10.4.34+maria~ubu2004 started.
blog-mailcatcher  | Starting MailCatcher v0.8.2
blog-mailcatcher  | ==> smtp://0.0.0.0:1025
blog-mailcatcher  | ==> http://0.0.0.0:1080
blog-mysql        | 2024-06-15 11:41:42+00:00 [Note] [Entrypoint]: Switching to dedicated user 'mysql'
blog-mysql        | 2024-06-15 11:41:42+00:00 [Note] [Entrypoint]: Entrypoint script for MariaDB Server 1:10.4.34+maria~ubu2004 started.
blog-phpmyadmin   | AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 172.22.0.4. Set the 'ServerName' directive globally to suppress this message
blog-phpmyadmin   | AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 172.22.0.4. Set the 'ServerName' directive globally to suppress this message
blog-phpmyadmin   | [Sat Jun 15 11:41:42.229132 2024] [mpm_prefork:notice] [pid 1] AH00163: Apache/2.4.59 (Debian) PHP/8.2.19 configured -- resuming normal operations
blog-phpmyadmin   | [Sat Jun 15 11:41:42.229156 2024] [core:notice] [pid 1] AH00094: Command line: 'apache2 -D FOREGROUND'
blog-server       | ::: Sat Jun 15 11:41:42 UTC 2024 :::
blog-server       | :::::::::::::::: SET PERMISSIONS ::::::::::::::::::::::::
blog-server       | :::::::::::::::::::::::::::::::::::::::::::::::::::::::::
blog-server       | PERMISSIONS SET successfully
blog-server       | ::: Sat Jun 15 11:41:42 UTC 2024 :::
blog-server       | :::::::::::::::: RUN APACHE :::::::::::::::::::::::::::::
blog-server       | :::::::::::::::::::::::::::::::::::::::::::::::::::::::::
blog-server       | AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 172.22.0.5. Set the 'ServerName' directive globally to suppress this message
blog-server       | AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 172.22.0.5. Set the 'ServerName' directive globally to suppress this message
blog-server       | [Sat Jun 15 11:41:42.330336 2024] [mpm_prefork:notice] [pid 19] AH00163: Apache/2.4.59 (Debian) PHP/8.3.7 configured -- resuming normal operations
blog-server       | [Sat Jun 15 11:41:42.330366 2024] [core:notice] [pid 19] AH00094: Command line: 'apache2 -D FOREGROUND'
blog-mysql        | 2024-06-15 11:41:42+00:00 [Note] [Entrypoint]: MariaDB upgrade not required
blog-mysql        | 2024-06-15 11:41:42 0 [Note] Starting MariaDB 10.4.34-MariaDB-1:10.4.34+maria~ubu2004 source revision 16394f1aa1b4097f897b8ab01ea2064726cca059 as process 1
blog-mysql        | 2024-06-15 11:41:42 0 [Note] InnoDB: Using Linux native AIO
blog-mysql        | 2024-06-15 11:41:42 0 [Note] InnoDB: Mutexes and rw_locks use GCC atomic builtins
blog-mysql        | 2024-06-15 11:41:42 0 [Note] InnoDB: Uses event mutexes
blog-mysql        | 2024-06-15 11:41:42 0 [Note] InnoDB: Compressed tables use zlib 1.2.11
blog-mysql        | 2024-06-15 11:41:42 0 [Note] InnoDB: Number of pools: 1
blog-mysql        | 2024-06-15 11:41:42 0 [Note] InnoDB: Using SSE2 crc32 instructions
blog-mysql        | 2024-06-15 11:41:42 0 [Note] mysqld: O_TMPFILE is not supported on /tmp (disabling future attempts)
blog-mysql        | 2024-06-15 11:41:42 0 [Note] InnoDB: Initializing buffer pool, total size = 256M, instances = 1, chunk size = 128M
blog-mysql        | 2024-06-15 11:41:42 0 [Note] InnoDB: Completed initialization of buffer pool
blog-mysql        | 2024-06-15 11:41:42 0 [Note] InnoDB: If the mysqld execution user is authorized, page cleaner thread priority can be changed. See the man page of setpriority().
blog-mysql        | 2024-06-15 11:41:42 0 [Note] InnoDB: 128 out of 128 rollback segments are active.
blog-mysql        | 2024-06-15 11:41:42 0 [Note] InnoDB: Creating shared tablespace for temporary tables
blog-mysql        | 2024-06-15 11:41:42 0 [Note] InnoDB: Setting file './ibtmp1' size to 12 MB. Physically writing the file full; Please wait ...
blog-mysql        | 2024-06-15 11:41:42 0 [Note] InnoDB: File './ibtmp1' size is now 12 MB.
blog-mysql        | 2024-06-15 11:41:42 0 [Note] InnoDB: Waiting for purge to start
blog-mysql        | 2024-06-15 11:41:42 0 [Note] InnoDB: 10.4.34 started; log sequence number 60979; transaction id 20
blog-mysql        | 2024-06-15 11:41:42 0 [Note] InnoDB: Loading buffer pool(s) from /var/lib/mysql/ib_buffer_pool
blog-mysql        | 2024-06-15 11:41:42 0 [Note] InnoDB: Buffer pool(s) load completed at 240615 11:41:42
blog-mysql        | 2024-06-15 11:41:42 0 [Note] Plugin 'FEEDBACK' is disabled.
blog-mysql        | 2024-06-15 11:41:42 0 [Note] Server socket created on IP: '::'.
blog-mysql        | 2024-06-15 11:41:42 0 [Note] Reading of all Master_info entries succeeded
blog-mysql        | 2024-06-15 11:41:42 0 [Note] Added new Master_info '' to hash table
blog-mysql        | 2024-06-15 11:41:42 0 [Note] mysqld: ready for connections.
blog-mysql        | Version: '10.4.34-MariaDB-1:10.4.34+maria~ubu2004'  socket: '/var/run/mysqld/mysqld.sock'  port: 3306  mariadb.org binary distribution

Si vous fermez ce terminal, les conteneurs seront automatiquement stoppés.
Si vous souhaitez reprendre la main, vous pouvez utiliser la combinaison de touches Ctrl + c.

18. Entrer dans le conteneur "blog-server"

Il sera souvent utile d'entrer dans le conteneur afin de lancer diverses commandes qui ne pourraient pas fonctionner hors du conteneur.

Par exemple, nous avons installé Symfony CLI à l'intérieur du conteneur.
Il faut donc être dans le conteneur afin de pouvoir l'utiliser.
Si vous n'entrez pas dans le conteneur, l'exécutable Symfony CLI sera recherché sur votre système.

Voici la commande Docker à utiliser pour entrer dans notre conteneur :

docker exec -ti blog-server /bin/bash

Pour plus d'information sur cette commande, n'hésitez pas à consulter la documentation :
https://docs.docker.com/reference/cli/docker/conteneur/exec/

Pour sortir du conteneur, exécutez simplement la commande exit.

19. Vérifier les prérequis de Symfony

Utilisons maintenant Symfony CLI afin de vérifier que notre environnement répond bien au prérequis de Symfony.
Pour cela, voici la commande à entrer dans le conteneur :

symfony check:requirements

Et voici le retour attendu :


dev@DESKTOP-2291OCF:~/workstation/contribution-blog-symfony-7-docker$ docker exec -ti blog-server /bin/bash
root@9afcc3f699a3:/var/www/html# symfony check:requirements

Symfony Requirements Checker
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

> PHP is using the following php.ini file:
/usr/local/etc/php/php.ini

> Checking Symfony requirements:

......................................


 [OK]
 Your system is ready to run Symfony projects


Note  The command console can use a different php.ini file
~~~~  than the one used by your web server.
      Please check that both the console and the web server
      are using the same PHP version and configuration.

root@9afcc3f699a3:/var/www/html#

20. Installer Symfony 7

Il n'est actuellement pas possible d'installer Symfony dans un répertoire qui n'est pas vide.
Comme c'est notre cas, nous allons devoir réaliser quelques manipulations sur nos fichiers.

En d'autres termes nous allons lancer l'installation de Symfony dans un répertoire temporaire puis nous déplacerons ces fichiers dans le répertoire courant (qui est /var/www/html).

Commençons l'installation de Symfony dans le répertoire "temp-symfony" :

symfony new ./temp-symfony --version="7.0.*" --webapp

Une fois l'installation terminée, nous pouvons déplacer l'application Symfony dans notre répertoire de travail :

mv temp-symfony/.* temp-symfony/* ./

Et supprimer le répertoire temporaire :

rmdir temp-symfony

21. Vérifier que tout fonctionne correctement

Dernière étape !

Nous allons relancer notre environnement de développement et vérifier que Symfony, PhpMyAdmin et Mailcatcher s'affichent bien dans notre navigateur web :

docker compose up

Nous pouvons maintenant ouvrir un navigateur web afin de vérifier que la page par défaut de Symfony s'affiche bien.
Pour cela, nous allons utiliser cette url : http://localhost

De même pour PhpMyAdmin : http://localhost:8090

Service de gestion de base de données PhpMyAdmin

Et enfin pour l'interface de Mailcatcher : http://localhost:1080

Service de test d'envoi de mail en local Mailcatcher

22. Conclusion

Nous avons abordé beaucoup de choses dans cet article mais nous n'avons fait qu'effleurer ces sujets.
N'hésitez pas à consulter les documentations sur Docker, Docker compose et le bash afin d'approfondir vos connaissances.
Vous trouverez pour cela plusieurs sources intéressantes un peu plus bas.

Quoi qu'il en soit vous disposez maintenant d'un environnement de développement local pour développer votre application avec Symfony 7.

Nous verrons dans de prochains articles les différentes étapes de création de ce projet 😊

a. Code source du projet

Si vous souhaitez utiliser ce projet dans l'état où il se trouve à la fin de cet article, vous pouvez le récupérer depuis mon repo Github.
Vous devrez pour cela lancer la commande "git clone" dans votre terminal afin de récupérer le tag v1.0.
N'oubliez pas de remplacer "mon_projet" par le nom que vous souhaitez utiliser pour votre répertoire d'installation :

git clone --depth 1 --branch v1.0 https://github.com/cpesin/contribution-blog-symfony-7-docker.git mon_projet

Si vous avez bien suivi cet article vous savez déjà qu'il ne vous reste plus qu'à entrer dans le répertoire de votre projet et lancer la commande suivante pour démarrer votre environnement de développement en local :

docker compose up

b. Sources

Bash : Manuel de référence de Bash
Docker build : Documentation de Docker build
Docker compose : Documentation de Docker compose
Apache 2.4 : Documentation d'Apache 2.4