Déployer Docker pour développer avec Symfony en 6 étapes :
🤝 On vous présente Docker :
Docker est une plateforme de conteneurisation qui vous permet d’emballer vos applications et leurs dépendances dans des conteneurs légers et portables. Si vous souhaitez maîtriser tous les aspects de cette technologie, découvrez notre Formation Docker en 4 jours.
Si vous voulez faire plus ample connaissance et découvrir ses nombreux avantages, on vous conseille également de lire notre article : « emboîter le pas de la conteneurisation avec Docker« .
Vous l’avez déjà lu ? Vous êtes là pour découvrir comment déployer Docker pour développer avec Symfony ? Très bien ! On va vous guider étape par étape.
👷♂️ Étape 1 : installer Docker
Rendez-vous sur le site officiel pour télécharger la version appropriée pour votre système d’exploitation et suivez les instructions d’installation.
🏗️ Étape 2 : créer un fichier de configuration
Une fois Docker installé, vous devez créer un fichier de configuration pour votre environnement de développement Symfony. Ce fichier, généralement appelé “docker-compose.yml”, contient les informations nécessaires pour exécuter votre application Symfony dans un conteneur Docker.
Un exemple, s’il vous plaît !
On commence par définir un réseau sur lequel se retrouveront les différents conteneurs permettant à Symfony de fonctionner :
networks:
symfony:
driver: bridge
Ensuite, on définit les services eux-mêmes. Commençons par MySQL :
mysql:
image: mysql:8.0
ports:
- 3306:3306
environment:
MYSQL_USER: symfony
MYSQL_PASSWORD: secret
MYSQL_DATABASE: symfony
MYSQL_ROOT_PASSWORD: secret
volumes:
- ./mysql:/var/lib/mysql
networks:
- symfony
Dans cet exemple, nous avons configuré un service :“mysql”. Le service “mysql” est responsable des données de votre application Symfony.
La clé environnement, elle, permet de créer un utilisateur et une base de données grâce aux informations mentionnées.
La clé volume, quant à elle, permet de pouvoir faire persister les données. Si l’on redémarrait le service sans cette clé, on serait obligé de repartir d’une base de données vide à chaque fois.
Et la clé “ports” dit à Docker de faire communiquer le port 3306 du conteneur avec le port 3307 de l’hôte. Ainsi, on ne rencontre pas de conflits si l’on a déjà une instance de MySQL qui tourne sur notre hôte, sachant que le port 3306 est le port sur lequel MySQL écoute par défaut.
Enfin, on ‘branche’ le service MySQL sur le réseau que l’on a créé en premier, il sera bientôt rejoint par d’autres services, et ils pourront tous communiquer joyeusement !
⚠️ Chaque clé commençant par “MYSQL” est personnalisable.
On a pu mettre en place un service directement dans un fichier “docker-compose” car on n’a pas besoin de personnaliser ce service. Les conteneurs suivants seront différents, on devra les personnaliser pour permettre à Symfony de fonctionner correctement.
C’est bon ? Allez, on est lancé : on poursuit avec le service Apache !
🚧 Étape 3 : créer un fichier Dockerfile
En plus du fichier de configuration Docker, vous devez également créer un fichier “apache.dockerfile”. Ce fichier décrit les étapes nécessaires pour créer une image du serveur http Apache.
Un exemple, s’il vous plaît !
On customise l’image du serveur Apache sous Ubuntu :
# On customize cette image; l'image officielle du serveur apache sous ubuntu
FROM ubuntu/apache2:latest
# Variables d'environnement
ENV APACHE_RUN_USER=symfony
ENV APACHE_RUN_GROUP=symfony
# Créer notre dossier de code pour le serveur
RUN mkdir -p /var/www/html/public
# On ajoute un fichier de configuration pour qu'apache nous serve les bons fichiers
COPY apache/default.conf /etc/apache2/sites-available/000-symfony.conf
# On active le "Virtual Host" : notre application symfony sera accessible grâce à ces lignes
RUN a2ensite 000-symfony.conf
# On active divers modules d'apache, nécessaire pour que symfony fonctionne
RUN a2enmod rewrite actions alias proxy_fcgi setenvif
# Modifier le USER de APACHE; sur ubuntu c'est dans le fichier envvars
RUN cat /etc/apache2/envvars
RUN sed -i "s/www-data/${APACHE_RUN_USER}/g" /etc/apache2/envvars
RUN cat /etc/apache2/envvars
RUN groupadd ${APACHE_RUN_GROUP}
RUN useradd -g ${APACHE_RUN_GROUP} ${APACHE_RUN_USER}
Ce “Dockerfile” utilise une image Docker officielle Apache sous Ubuntu comme point de départ. Il met en place la configuration nécessaire au serveur Apache afin de servir une application PHP Symfony. Le serveur Apache démarre automatiquement et écoute sur le port 8080. Comme indiqué dans le fichier docker-compose.yml, il faut en effet ajouter un service Apache prenant en compte ce Dockerfile de configuration :
apache:
build:
context: .
dockerfile: apache.dockerfile
ports:
- 8080:80 # Le 1er port est celui de l'hôte
volumes:
- ./src:/var/www/html
depends_on:
- mysql
- php
networks:
- symfony
Ici, le volume permet de copier dans le conteneur l’application Symfony située dans le répertoire src de l’hôte, ainsi, on peut développer notre application et voir les modifications apportées en temps réel dans le conteneur sur l’URL http://localhost:8080.
🚢 Étape 4 : configurer le service PHP
Comme pour le service Apache, deux étapes sont nécessaires :
- Un fichier Dockerfile pour personnaliser le service PHP, afin qu’il fonctionne avec apache et Symfony.
- L’ajout de ce service dans le fichier docker-compose.yml
FROM php:8.2-fpm-alpine
ENV PHPUSER=symfony
ENV PHPGROUP=symfony
ENV UID=1000
ENV GID=1000
RUN addgroup -g 1006 --system symfony
RUN adduser -G www-data --system -D -s /bin/sh -u 1006 symfony
# RUN ls /usr/local/etc/php-fpm.d/
# RUN sed -i "s/user = www-data/user = ${PHPUSER}/g" /usr/local/etc/php-fpm.d/www.conf
# RUN sed -i "s/group = www-data/group = ${PHPGROUP}/g" /usr/local/etc/php-fpm.d/www.conf
RUN mkdir -p /var/www/html/public
# Add packages for symfony
RUN docker-php-ext-install pdo pdo_mysql
CMD ["php-fpm"]
Ce fichier configure ‘php’ avec les extensions nécessaires à Doctrine pour travailler avec MySQL (N.B. Doctrine est un outil de mappage objet-relationnel pour PHP qui nécessite certaines extensions PHP pour fonctionner avec des bases de données comme MySQL).
CMD [« php-fpm »] : cette instruction définit la commande par défaut à exécuter lorsque le conteneur démarre. Dans ce cas, la commande “php-fpm” est utilisée pour lancer le serveur PHP-FPM, qui est nécessaire pour exécuter l’application Symfony.
Ces instructions peuvent être modifiées en fonction des besoins spécifiques de votre projet Symfony.
Par exemple, vous pouvez :
- ajuster les versions PHP,
- ajouter d’autres extensions,
- configurer des variables d’environnement supplémentaires.
Il ne nous reste qu’à ajouter le service ‘php’ au fichier ‘docker-compose’ :
php:
build:
context: .
dockerfile: php.dockerfile
args:
- UID=${UID:-1000}
- GID=${UID:-1000}
volumes:
- ./src:/var/www/html
networks:
- symfony
🚢 Étape 5 : configurer le service composer
On fait la même chose pour ‘composer‘, un dockerfile de base ainsi que l’ajout du service au ‘docker-compose’ :
FROM composer:2
RUN adduser -g www-data -s /bin/sh -D symfony
composer:
build:
context: .
dockerfile: composer.dockerfile
args:
- UID=${UID:-1000}
- GID=${UID:-1000}
volumes:
- ./src:/var/www/html
working_dir: /var/www/html
networks:
- symfony
🚢 Étape 6 : lancer les conteneurs Docker
Maintenant que vous avez créé votre fichier de configuration Docker et votre fichier Dockerfile, il est temps de lancer les conteneurs Docker pour exécuter votre application Symfony.
Ouvrez une fenêtre de terminal, placez-vous dans le répertoire de votre projet et exécutez les commandes suivantes :
mkdir src && cd src && docker compose run --rm --user $(id -u):$(id -g) composer create-project symfony/skeleton:"6.3.*" ./ && cd ..
Cette liste de commandes créera une application Symfony dans un répertoire src, la commande suivante construira les images Docker nécessaires et démarrera les conteneurs.
docker compose up -- build
Une fois les conteneurs lancés, vous pouvez accéder à votre application Symfony en ouvrant votre navigateur web, et en vous rendant sur l’adresse : http://localhost:8080 (ou l’adresse correspondante à votre configuration de ports dans le fichier “docker-compose.yml”).
