linkedin-ico github-ico

Créer un environnement Docker pour Symfony et Sulu

symfony docker

Un environnement Docker utile à Symfony et Sulu doit fournir les bonnes extensions PHP, une base persistante et un serveur web configuré sur le bon répertoire public. Il doit aussi laisser les fichiers modifiables depuis l’hôte. Voici une base de développement explicite, destinée à être comprise et adaptée au projet.

Article complété et vérifié le . Configuration essayée avec PHP 8.4, Sulu Skeleton 3.0.11 et PostgreSQL 16. Elle sert au développement local ; une image de production demande un travail de packaging supplémentaire.

Organiser les fichiers sans ambiguïté

À la racine d’un projet Sulu existant, créez les emplacements suivants. Pour créer le projet lui-même sans PHP installé sur l’hôte, commencez par le guide de démarrage Sulu avec Docker.

mkdir -p .docker/nginx

Le fichier compose.yaml sera placé à la racine ; le Dockerfile dans .docker/Dockerfile et la configuration Nginx dans .docker/nginx/default.conf. Tous les conteneurs utilisent /app pour le même code source. Un chemin différent entre Nginx et PHP provoque facilement des erreurs FastCGI.

Construire le runtime PHP

FROM php:8.4-fpm
RUN apt-get update \
    && apt-get install -y --no-install-recommends git unzip libicu-dev libpq-dev libzip-dev libpng-dev libjpeg62-turbo-dev libfreetype6-dev \
    && docker-php-ext-configure gd --with-freetype --with-jpeg \
    && docker-php-ext-install -j2 intl pdo_pgsql zip gd opcache \
    && rm -rf /var/lib/apt/lists/*
COPY --from=composer:2 /usr/bin/composer /usr/local/bin/composer
RUN echo 'memory_limit=512M' > /usr/local/etc/php/conf.d/app.ini
WORKDIR /app

Les outils docker-php-ext-configure et docker-php-ext-install viennent de l’image officielle PHP. Nous compilons notamment le pilote PostgreSQL, Intl, GD et ZIP, puis supprimons les index du gestionnaire de paquets. Composer est copié depuis son image officielle ; aucun script téléchargé n’est exécuté directement avec curl | php.

La limite mémoire PHP de 512 Mo évite ici de conserver la valeur de 128 Mo pendant l’initialisation et le chargement des traductions. Ce réglage n’est pas une limite mémoire du conteneur : adaptez aussi les ressources disponibles. Les images utilisent des tags lisibles pour le tutoriel ; pour un build reproductible, verrouillez les versions ou digests retenus et prévoyez leur mise à jour.

Relier PHP, Nginx et PostgreSQL

services:
  database:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: sulu_demo
      POSTGRES_USER: sulu
      POSTGRES_PASSWORD: local_only
    volumes:
      - database_data:/var/lib/postgresql/data
    healthcheck:
      test: [CMD-SHELL, pg_isready -U sulu -d sulu_demo]
      interval: 3s
      timeout: 3s
      retries: 20
  php:
    build:
      context: .
      dockerfile: .docker/Dockerfile
    user: '${LOCAL_UID:-1000}:${LOCAL_GID:-1000}'
    working_dir: /app
    environment:
      APP_ENV: dev
      DATABASE_URL: 'postgresql://sulu:local_only@database:5432/sulu_demo?serverVersion=16&charset=utf8'
      COMPOSER_HOME: /tmp/composer
    volumes:
      - .:/app
    depends_on:
      database:
        condition: service_healthy
  nginx:
    image: nginx:stable-alpine
    ports:
      - '127.0.0.1:8080:80'
    volumes:
      - .:/app:ro
      - ./.docker/nginx/default.conf:/etc/nginx/conf.d/default.conf:ro
    depends_on:
      - php
volumes:
  database_data:

La base n’expose aucun port sur l’hôte et ses données vivent dans un volume nommé. Le mot de passe local_only est une valeur de démonstration réservée à cette installation locale. Le serveur HTTP écoute uniquement sur la boucle locale de l’hôte. Le fichier ne doit pas être repris tel quel sur une machine publique.

La condition service_healthy attend le contrôle de disponibilité PostgreSQL. Un simple depends_on n’attend pas qu’une base accepte les connexions : la documentation Compose sur l’ordre de démarrage distingue les deux comportements. Ce contrôle ne garantit pas que le schéma de l’application est installé.

Sous Linux, transmettez vos identifiants avant de construire et d’exécuter les commandes :

export LOCAL_UID="$(id -u)"
export LOCAL_GID="$(id -g)"
docker compose -f compose.yaml build php

PHP et les commandes de console utilisent ainsi le même utilisateur du conteneur pour les fichiers du projet. Évitez d’alterner une console root et un serveur qui ne peut ensuite plus écrire dans var/. Sur d’autres systèmes hôtes, vérifiez le comportement du partage de fichiers plutôt que de recopier ces identifiants arbitrairement.

Acheminer les requêtes avec Nginx

server {
    listen 80;
    server_name localhost;
    root /app/public;
    index index.php;
    location / {
        try_files $uri /index.php$is_args$args;
    }
    location ~ ^/index\.php(/|$) {
        fastcgi_pass php:9000;
        fastcgi_split_path_info ^(.+\.php)(/.*)$;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
        fastcgi_param DOCUMENT_ROOT $realpath_root;
        internal;
    }
    location ~ \.php$ { return 404; }
}

Le serveur ne peut exécuter que le point d’entrée index.php. Les autres chemins PHP sont refusés. Il sert directement les fichiers publics existants et confie les URL applicatives à Symfony. Cette configuration convient au point d’entrée unifié du Sulu Skeleton 3.0.11 utilisé dans l’exemple ; contrôlez celui de votre projet avant d’adapter un ancien squelette.

Vérifier avant d’ajouter des services

docker compose -f compose.yaml config --quiet
docker compose -f compose.yaml up -d database
docker compose -f compose.yaml run --rm php composer install
docker compose -f compose.yaml run --rm php composer check-platform-reqs
docker compose -f compose.yaml up -d php nginx

Ces commandes ne créent pas les contenus Sulu : l’initialisation est détaillée dans le guide de démarrage. En cas d’erreur, contrôlez les journaux du service concerné et le chemin des fichiers avant de modifier la configuration au hasard. Un serveur lancé ne signifie pas encore que les dépendances, les migrations et les assets sont prêts.

Préparer ensuite le packaging de production

Le montage du dépôt et les outils de compilation sont pratiques en développement. Pour livrer une application, préparez des étapes dédiées aux dépendances PHP, au build de l’administration et aux assets, puis copiez les résultats nécessaires dans les images d’exécution. Les builds multi-stage Docker permettent cette séparation.

Conservez hors image les secrets et les données persistantes, notamment les médias. Une image applicative doit pouvoir être remplacée sans supprimer les uploads. Les caches et les migrations nécessitent également une stratégie de déploiement ; changer APP_ENV ne transforme pas automatiquement cet environnement local en installation de production.