Sylius avec Docker : un environnement de dev pret en 5 minutes

Configurer un environnement de developpement Sylius complet peut prendre des heures : PHP avec les bonnes extensions, MySQL ou PostgreSQL, Node.js, Redis, un serveur web, un outil de capture d'emails... Avec Docker Compose, tout est pret en 5 minutes. Ce guide fournit une configuration Docker production-ready pour Sylius 2.x, testee et optimisee.

Prerequis

Vous avez besoin de :

• Docker Desktop (macOS/Windows) ou Docker Engine + Docker Compose (Linux)
• Git pour cloner le projet
• 4 Go de RAM minimum alloues a Docker

# Verifier l'installation Docker
docker --version
# Docker version 27.x.x

docker compose version
# Docker Compose version v2.x.x

Structure du projet

Voici la structure des fichiers Docker que nous allons creer :

mon-projet-sylius/
  docker/
    nginx/
      default.conf
    php/
      Dockerfile
      php.ini
  docker-compose.yml
  .env.local

Le fichier docker-compose.yml

Ce fichier orchestre tous les services necessaires : PHP-FPM, Nginx, MySQL, Redis et Mailpit (capture d'emails).

# docker-compose.yml
version: '3.8'

services:
  php:
    build:
      context: .
      dockerfile: docker/php/Dockerfile
    volumes:
      - .:/var/www/sylius:cached
      - vendor:/var/www/sylius/vendor
      - node_modules:/var/www/sylius/node_modules
    environment:
      DATABASE_URL: "mysql://sylius:sylius@mysql:3306/sylius_dev?serverVersion=8.0&charset=utf8mb4"
      MAILER_DSN: "smtp://mailpit:1025"
      APP_ENV: dev
      APP_DEBUG: 1
      PHP_IDE_CONFIG: "serverName=sylius-docker"
      XDEBUG_MODE: "off"
    depends_on:
      mysql:
        condition: service_healthy
      redis:
        condition: service_started

  nginx:
    image: nginx:1.27-alpine
    ports:
      - "8080:80"
    volumes:
      - .:/var/www/sylius:cached
      - ./docker/nginx/default.conf:/etc/nginx/conf.d/default.conf:ro
    depends_on:
      - php

  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: sylius_dev
      MYSQL_USER: sylius
      MYSQL_PASSWORD: sylius
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

  mailpit:
    image: axllent/mailpit:latest
    ports:
      - "8025:8025"
      - "1025:1025"

volumes:
  mysql_data:
  vendor:
  node_modules:

Le Dockerfile PHP

Ce Dockerfile installe PHP 8.3 avec toutes les extensions requises par Sylius, plus Composer, Node.js et Xdebug pour le debug.

# docker/php/Dockerfile
FROM php:8.3-fpm-bookworm

# Extensions systeme
RUN apt-get update && apt-get install -y \
    git unzip curl libicu-dev libpng-dev libjpeg-dev \
    libfreetype6-dev libzip-dev libxml2-dev libonig-dev \
    && rm -rf /var/lib/apt/lists/*

# Extensions PHP
RUN docker-php-ext-configure gd --with-freetype --with-jpeg \
    && docker-php-ext-install -j$(nproc) \
    intl gd exif zip pdo pdo_mysql opcache mbstring xml

# Xdebug (desactive par defaut, activer via XDEBUG_MODE)
RUN pecl install xdebug \
    && docker-php-ext-enable xdebug

# Redis
RUN pecl install redis \
    && docker-php-ext-enable redis

# Configuration PHP
COPY docker/php/php.ini /usr/local/etc/php/conf.d/99-sylius.ini

# Composer
COPY --from=composer:2 /usr/bin/composer /usr/bin/composer

# Node.js 20
RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
    && apt-get install -y nodejs \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /var/www/sylius

# Utilisateur non-root
RUN usermod -u 1000 www-data && groupmod -g 1000 www-data
USER www-data

Configuration PHP

# docker/php/php.ini
memory_limit = 512M
upload_max_filesize = 20M
post_max_size = 25M
max_execution_time = 60

opcache.enable = 1
opcache.memory_consumption = 256
opcache.max_accelerated_files = 20000
opcache.validate_timestamps = 1

realpath_cache_size = 4096K
realpath_cache_ttl = 600

[xdebug]
xdebug.client_host = host.docker.internal
xdebug.client_port = 9003
xdebug.start_with_request = yes
xdebug.idekey = PHPSTORM

Configuration Nginx

# docker/nginx/default.conf
server {
    listen 80;
    server_name localhost;
    root /var/www/sylius/public;

    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;
        fastcgi_buffer_size 128k;
        fastcgi_buffers 4 256k;
        fastcgi_busy_buffers_size 256k;
        internal;
    }

    location ~ \.php$ {
        return 404;
    }

    client_max_body_size 25M;

    access_log /var/log/nginx/sylius_access.log;
    error_log /var/log/nginx/sylius_error.log;
}

Lancement en 5 etapes

Une fois les fichiers en place, lancez le projet :

Etape 1 : construire et demarrer les containers

docker compose up -d --build

# Verifier que tous les services sont up
docker compose ps

Etape 2 : installer les dependances

# Composer (dans le container PHP)
docker compose exec php composer install

# Node.js
docker compose exec php npm install

Etape 3 : configurer la base de donnees

# Creer le schema
docker compose exec php php bin/console doctrine:schema:create

# Charger les fixtures
docker compose exec php php bin/console sylius:fixtures:load

Etape 4 : compiler les assets

docker compose exec php npm run dev

Etape 5 : acceder a l'application

• Boutique : http://localhost:8080
• Admin : http://localhost:8080/admin (sylius@example.com / sylius)
• Mailpit : http://localhost:8025 (capture tous les emails)
• API : http://localhost:8080/api/v2/shop

Commandes utiles au quotidien

# Ouvrir un shell dans le container PHP
docker compose exec php bash

# Voir les logs en temps reel
docker compose logs -f php

# Arreter les containers
docker compose down

# Arreter et supprimer les volumes (reset complet)
docker compose down -v

# Recompiler les assets en mode watch
docker compose exec php npm run watch

# Lancer les tests
docker compose exec php php bin/phpunit
docker compose exec php vendor/bin/behat

Activer Xdebug

Xdebug est installe mais desactive par defaut pour ne pas impacter les performances. Pour l'activer :

# Dans docker-compose.yml, changez :
XDEBUG_MODE: "off"
# En :
XDEBUG_MODE: "debug"

# Puis relancez le container PHP
docker compose restart php

Configurez ensuite votre IDE pour ecouter sur le port 9003. Dans PHPStorm : Settings > PHP > Debug > Xdebug port = 9003.

Troubleshooting

Lenteur sur macOS

Le partage de fichiers entre macOS et Docker peut etre lent. Solutions :

• Utilisez le flag :cached sur les volumes (deja inclus dans notre config)
• Excluez les dossiers vendor/ et node_modules/ du montage (utilisation de volumes nommes dans notre config)
• Activez VirtioFS dans Docker Desktop (Settings > General > VirtioFS)

Lenteur sur Windows

Utilisez WSL2 et placez votre projet dans le filesystem WSL (pas dans /mnt/c/). Les performances seront proches du natif Linux.

Erreur "port already in use"

# Trouver le processus qui utilise le port
lsof -i :8080
# ou sur Windows/WSL
netstat -ano | findstr :8080

# Changer le port dans docker-compose.yml
ports:
  - "8081:80"  # au lieu de 8080:80

Pour aller plus loin

• Guide d'installation Sylius complet - si vous preferez une installation sans Docker
• Tester la demo Sylius - pour explorer les fonctionnalites avant d'installer
• Deployer Sylius en production - la configuration Docker de production
• Guide complet de l'ecosysteme Sylius

Besoin d'aide pour configurer votre environnement ? Contactez-nous pour une session de pair programming.