Introduction
Dans l’alternative de vous faciliter la gestion de votre site Drupal et de vous offrir une expérience de développement agréable . Nous vous souhaitons la bienvenue dans cette présentation de la version 1.0 du projet Docker Drupal FrankenPHP. La documentation officielle sera disponible sur GitHub. Ce projet vise à fournir une solution complète et optimisée pour le déploiement et la gestion de sites Drupal en utilisant Docker et FrankenPHP. Notre objectif est de créer un environnement de développement fiable et performant, qui simplifie la gestion des dépendances et des configurations tout en assurant une intégration fluide avec les outils modernes. Cette documentation décrit les outils utilisés, la configuration des conteneurs, et les commandes disponibles pour gérer l’environnement de développement.
Prérequis
Assurez-vous que les éléments suivants sont installés sur votre ordinateur :
- Docker Desktop : Assurez-vous que Docker Desktop est installé et à jour
- Docker Compose : Inclus avec Docker Desktop, mais assurez-vous que la version est compatible avec votre projet.
Use case
L’objectif de ce projet est de simplifier le déploiement d’un environnement de développement Drupal, dans sa dernière version, en utilisant Docker. En général, l’installation d’un site Drupal sur un ordinateur sans Docker peut être fastidieuse et complexe. En effet, il est nécessaire d’installer plusieurs composants, comme Composer, PHP, PostgreSQL ou MySQL, ainsi que diverses extensions PHP. Même en utilisant Docker, il peut encore être nécessaire d’installer certains composants localement pour générer le projet.
Ce projet vise à réduire au maximum ces complications. L’idée est que Docker soit le seul prérequis pour l’utilisateur, ce qui permettra de tirer parti des conteneurs pour initialiser le projet Drupal. Grâce à cette approche, toutes les dépendances et configurations complexes seront gérées au sein du conteneur Docker, rendant le processus d’installation de Drupal beaucoup plus simple et rapide pour les développeurs.
Configuration de FrankenPHP
Pour plonger dans un développement web puissant et fluide avec Drupal FrankenPHP, où chaque fichier de configuration est conçu pour simplifier votre flux de travail et maximiser les performances. Voici quelques parties pour la configuration:
.env
Le fichier .env stocke les configurations critiques, comme les paramètres de base de données, de manière centralisée et sécurisée. Il facilite la gestion des configurations pour différents environnements (développement, test, production) sans modifier le code source. De plus, il protège les informations sensibles en les excluant du contrôle de version.
PROJECT_NAME=drupal.localhost PHP_TAG=1-php8.3 PROJECT_BASE_URL=drupal.docker.localhost PROJECT_PORT=8000 DB_NAME=drupal DB_USER=drupal DB_PASSWORD=drupal DB_ROOT_PASSWORD=password DB_HOST=postgres DB_PORT=5432 DB_DRIVER=pgsql DRUPAL_HASH_SALT='hash salt'
Settings
Le fichier settings à la racine du projet contient des paramètres définis à partir des valeurs du fichier .env, telles que les informations de connexion à la base de données. Lors de la création du projet Drupal, le contenu de ce fichier settings est automatiquement injecté dans web/sites/default/settings.php.
Cette automatisation présente plusieurs avantages. D’une part, elle simplifie la gestion des configurations en centralisant les informations sensibles, comme les identifiants de base de données, dans le fichier .env. Ce fichier est généralement mieux sécurisé, n’est pas versionné, et peut être facilement adapté aux différents environnements (développement, production, etc.), évitant ainsi de compromettre des informations critiques dans le contrôle de version.
Ainsi, chaque modification des variables dans le fichier .env entraîne automatiquement une mise à jour des paramètres de connexion dans settings.php. Cela évite de devoir éditer manuellement le fichier settings.php à chaque changement, réduisant ainsi les risques d’erreurs de configuration et améliorant la maintenabilité du projet. De plus, lors de déploiements sur divers environnements, cette approche garantit que les informations de connexion appropriées sont toujours utilisées.
$databases['default']['default'] = array (
'database' => getenv('DB_NAME'),
'username' => getenv('DB_USER'),
'password' => getenv('DB_PASSWORD'),
'host' => getenv('DB_HOST'),
'driver' => getenv('DB_DRIVER'),
'port' => getenv('DB_PORT'),
'prefix' => '',
);
$settings['config_sync_directory'] = 'config';
$settings['hash_salt'] = getenv('DRUPAL_HASH_SALT');
$config['system.logging']['error_level'] = 'verbose';
Caddyfile
Le Caddyfile permet de Maîtriser l’orchestration du serveur ajusté pour Drupal, offrant une gestion efficace des requêtes et optimisant la performance de notre site grâce à des règles de redirection et de cache judicieusement configurées.
# Adapted from https://caddy.community/t/caddyfile-for-drupal-10/21607/5
{
{$CADDY_GLOBAL_OPTIONS}
frankenphp {
{$FRANKENPHP_CONFIG}
}
# https://caddyserver.com/docs/caddyfile/directives#sorting-algorithm
order php_server before file_server
order php before file_server
}
{$CADDY_EXTRA_CONFIG}
:80 {
tls ./config/docker/certs/localhost.crt ./config/docker/certs/localhost.key
root * web/
encode zstd br gzip
@hiddenPhpFilesRegexp path_regexp \..*/.*\.php$
error @hiddenPhpFilesRegexp 403
@notFoundPhpFiles path_regexp /vendor/.*\.php$
error @notFoundPhpFiles 404
@notFoundPhpFilesRegexp path_regexp ^/sites/[^/]+/files/.*\.php$
error @notFoundPhpFilesRegexp 404
@privateDirRegexp path_regexp ^/sites/.*/private/
error @privateDirRegexp 403
@protectedFilesRegexp {
not path /.well-known*
path_regexp \.(engine|inc|install|make|module|profile|po|sh|.*sql|theme|twig|tpl(\.php)?|xtmpl|yml)(~|\.sw[op]|\.bak|\.orig|\.save)?$|^/(\..*|Entries.*|Repository|Root|Tag|Template|composer\.(json|lock)|web\.config|yarn\.lock|package\.json)$|^\/#.*#$|\.php(~|\.sw[op]|\.bak|\.orig|\.save)$
}
error @protectedFilesRegexp 403
@static {
file
path *.avif *.css *.eot *.gif *.gz *.ico *.jpg *.jpeg *.js *.otf *.pdf *.png *.svg *.ttf *.webp *.woff *.woff2
}
header @static Cache-Control "max-age=31536000,public,immutable"
{$CADDY_SERVER_EXTRA_DIRECTIVES}
php_server
}
Dockerfile
Le Dockerfile automatise la configuration de l’environnement de développement en définissant les instructions nécessaires pour construire notre image Docker. Il spécifie le système d’exploitation, les dépendances, et les configurations requises pour exécuter Drupal. Cela garantit des environnements reproductibles et facilite le développement.
ARG PHP_TAG
FROM dunglas/frankenphp:${PHP_TAG}
RUN install-php-extensions \
apcu \
gd \
opcache \
pdo_pgsql \
zip
ENV COMPOSER_ALLOW_SUPERUSER=1
ENV PATH="${PATH}:/opt/drupal/vendor/bin"
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer
WORKDIR /opt/drupal10
COPY Caddyfile /etc/caddy/Caddyfile
COPY . ./
RUN mkdir -p /opt/drupal_temp
RUN cd /opt/drupal_temp && composer create-project drupal/recommended-project .
RUN set -eux; \
rm -rf /app/public; \
ln -sf /opt/drupal10/web /app/public
RUN cp /opt/drupal_temp/web/example.gitignore /opt/drupal_temp/.gitignore
RUN cp /opt/drupal_temp/web/sites/default/default.settings.php /opt/drupal_temp/web/sites/default/settings.php
COPY settings /tmp/settings
RUN cat /tmp/settings >> /opt/drupal_temp/web/sites/default/settings.php
docker-compose
Le fichier docker-compose.yml permet de définir et de gérer des applications multi-conteneurs Docker. Il facilite la configuration des services et des volumes nécessaires pour exécuter notre application. En centralisant la configuration, il simplifie le démarrage, l’arrêt et la gestion des services, ainsi que la gestion des environnements.
services:
drupal:
env_file: .env
build:
context: .
dockerfile: Dockerfile
image: "${PROJECT_NAME}_frankenphp"
container_name: "${PROJECT_NAME}_frankenphp"
ports:
- "8000:80"
- "443:443"
volumes:
- ./:/opt/drupal:cached
depends_on:
- postgres
environment:
DB_HOST: $DB_HOST
DB_PORT: $DB_PORT
DB_USER: $DB_USER
DB_PASSWORD: $DB_PASSWORD
DB_NAME: $DB_NAME
DB_DRIVER: $DB_DRIVER
DRUPAL_HASH_SALT: ${DRUPAL_HASH_SALT}
PROJECT_BASE_URL: ${PROJECT_BASE_URL}
PROJECT_PORT: ${PROJECT_PORT}
PHP_TAG: ${PHP_TAG}
restart: always
postgres:
image: postgres:16
container_name: "${PROJECT_NAME}_postgres"
env_file: .env
environment:
POSTGRES_USER: $DB_USER
POSTGRES_PASSWORD: $DB_PASSWORD
restart: always
adminer:
image: adminer
container_name: "${PROJECT_NAME}_adminer"
restart: always
ports:
- 1400:8080
Makefile
Le Makefile est l’outil qui vous permet d’automatiser les tâches fréquentes et de simplifier le flux de travail. Grâce à des commandes simples comme make up et make project, vous pouvez gérer votre environnement Docker sans avoir à exécuter manuellement des commandes complexes. Cela vous aide à vous concentrer sur le développement de votre site Drupal, tout en vous assurant que toutes les configurations et étapes nécessaires sont exécutées de manière cohérente et efficace.
include .env
default: up
COMPOSER_ROOT ?= /opt/drupal
DRUPAL_ROOT ?= /opt/drupal/web
.PHONY: up
up:
@echo "Starting containers for $(PROJECT_NAME)..."
docker build -t $(PROJECT_NAME)_frankenphp .
docker-compose up --remove-orphans
.PHONY: project
project:
@echo "Copying files from drupal.localhost_frankenphp:/opt/drupal_temp/ to ./drupal..."
docker cp drupal.localhost_frankenphp:/opt/drupal_temp/. ./drupal
.PHONY: stop
stop:
@echo "Stopping containers for $(PROJECT_NAME)..."
docker-compose stop
.PHONY: start
start:
@echo "Restarting containers for $(PROJECT_NAME)..."
docker-compose start
.PHONY: prune
prune:
@echo "Removing containers for $(PROJECT_NAME)..."
docker-compose down -v $(filter-out $@,$(MAKECMDGOALS))
.PHONY: ps
ps:
@docker ps --filter name='$(PROJECT_NAME)*'
.PHONY: drush
drush:
docker exec $(shell docker ps --filter name='^/$(PROJECT_NAME)_frankenphp' --format "{{ .ID }}") drush -r $(DRUPAL_ROOT) $(filter-out $@,$(MAKECMDGOALS))
.PHONY: logs
logs:
@docker-compose logs -f $(filter-out $@,$(MAKECMDGOALS))
%:
@:
Lancement et vérification du projet
Voici un aperçu des fichiers et dossiers essentiels qui composent notre projet :
drupal_frankenphp
├── .env
├── Caddyfile
├── Dockerfile
├── docker-compose.yml
├── drupal/
├── Makefile
├── README.md
└── settings Pour démarrer le projet, vous pouvez exécuter la commande suivante :
make upLa commande make up génère l’image Docker de votre projet en utilisant le nom défini par la variable PROJECT_NAME, puis lance les conteneurs Docker tout en supprimant les éventuels conteneurs orphelins. Une fois cette commande exécutée, vous pouvez vérifier le bon fonctionnement du projet en accédant à http://localhost ou http://drupal.ldocker.localhost depuis votre navigateur. Le résultat attendu est le suivant :
Cette erreur survient car le projet Drupal n’a pas encore été initialisé. Pour remédier à cela, nous allons l’initialiser dans la dernière version de drupal avec cette commande :
make project
Après avoir exécuté cette commande, vous devriez obtenir le résultat suivant, confirmant que tout fonctionne correctement :
Le projet est maintenant entièrement initialisé et prêt à l’emploi.
Pour accéder à la base de données, ouvrez http://localhost:1400 ou http://drupal.docker.localhost:1400 dans votre navigateur. Voici les paramètres et les valeurs correspondantes pour se connecter à la base de données :
- Système : postgreSQL
- Serveur : postgres
- Utilisateur : drupal
- Mot de passe : drupal
- Base de données : drupal
Maintenant, vous pouvez vous référer à l’image gif ci-dessus pour voir la configuration complète.
Autre commande
Pour arrêter et redémarrer tous les conteneurs Docker associés au projet, utilisez les commandes suivantes :
make stop
make startPour supprimer tous les conteneurs Docker ainsi que les volumes associés à votre projet, libérant ainsi de l’espace, exécutez :
make prunePour afficher la liste des conteneurs Docker actuellement en cours d’exécution pour votre projet, utilisez :
make psPour exécuter une commande Drush dans le conteneur FrankenPHP avec les arguments souhaités, utilisez :
make drush <commande_drush>Pour afficher les logs des conteneurs Docker, et filtrer par services spécifiques si des arguments supplémentaires sont fournis, utilisez la commande suivante :
make logs <nom_du_service>Conclusion
Le projet Docker Drupal FrankenPHP que nous avons mis en place n’est pas seulement une solution technique, mais un exemple d’efficacité et de simplicité pour le développement moderne. En combinant la puissance de Docker, la flexibilité de Drupal, et les performances de FrankenPHP, nous avons créé un environnement robuste qui facilite le développement et la gestion de notre application.
Ce projet vous permettrez de naviguer sans effort entre les différentes étapes du développement, tout en assurant la sécurité, la cohérence, et la modularité du code. Grâce à une configuration soignée et à des outils automatisés.
En suivant cette documentation, vous avez entre les mains tous les éléments nécessaires pour tirer le meilleur parti de cette stack technologique, qu’il s’agisse de lancer rapidement un nouveau projet ou de gérer efficacement un site Drupal existant. Le potentiel est illimité, et vous êtes désormais bien équipé pour le réaliser.
Architecte logiciel et Développeur d'applications, j'ai acquis une solide expertise en développement au cours de mes deux années à l'ESP (École Supérieure Polytechnique) et de ma formation à l'UPF (Université privée de Fès). Maîtrisant Docker et les pratiques d'intégration continue, je me passionne pour l'optimisation des workflows et la conception de systèmes performants. Mon parcours diversifié et mon approche méthodique me permettent de contribuer efficacement à des projets technologiques innovants et ambitieux.
Passionnée par l'innovation technologique, je suis actuellement en troisième année de Licence Informatique à l' université iba der thiam de thies , avec une spécialisation en Génie Logiciel. En tant que future Architecte logiciel et Développeuse d'application, je me consacre à la création de solutions numériques qui transforment les idées en réalité. Mon parcours académique et mes projets me permettent de maîtriser les concepts clés du développement logiciel tout en cultivant une vision créative pour résoudre les défis complexes du monde numérique.