Sylius en production : la checklist complete de mise en ligne

Le passage en production est l'etape la plus critique d'un projet Sylius. Un oubli peut couter cher : faille de securite, performances degradees, donnees perdues. Cette checklist couvre chaque aspect du deploiement, du serveur au monitoring. Imprimez-la, cochez chaque point, et lancez-vous sereinement.

1. Prerequis serveur

Systeme et infrastructure

• Serveur Linux (Ubuntu 22.04 LTS ou Debian 12 recommande)
• Minimum 2 vCPU, 4 Go RAM, 40 Go SSD NVMe
• Acces SSH securise (cle RSA, port non standard, fail2ban)
• Firewall configure (ufw ou iptables) - seuls les ports 80, 443 et SSH ouverts
• Utilisateur non-root dedie pour l'application

PHP

# Extensions PHP requises par Sylius
sudo apt install php8.3-fpm php8.3-intl php8.3-gd php8.3-mbstring     php8.3-xml php8.3-curl php8.3-zip php8.3-mysql php8.3-opcache     php8.3-redis php8.3-apcu

• PHP 8.2+ installe (8.3 recommande)
• Extensions : intl, gd, mbstring, xml, curl, zip, opcache, redis, apcu
• OPcache active et configure
• memory_limit = 256M minimum
• upload_max_filesize et post_max_size adaptes (ex: 20M)
• realpath_cache_size = 4096k
• realpath_cache_ttl = 600

# php.ini production optimise
[opcache]
opcache.enable=1
opcache.memory_consumption=256
opcache.interned_strings_buffer=16
opcache.max_accelerated_files=20000
opcache.validate_timestamps=0
opcache.save_comments=1
opcache.preload=/var/www/sylius/config/preload.php
opcache.preload_user=www-data

[apcu]
apc.enabled=1
apc.shm_size=64M

Base de donnees

• MySQL 8.0+ ou PostgreSQL 14+ installe
• Utilisateur dedie avec droits limites (pas de GRANT ALL)
• Charset utf8mb4 et collation utf8mb4_unicode_ci
• innodb_buffer_pool_size = 50-70% de la RAM disponible
• Connexion via socket Unix (pas TCP si meme serveur)
• Slow query log active pour le monitoring

Serveur web

• Nginx recommande (ou Apache avec mod_rewrite)
• Configuration Symfony officielle appliquee
• Gzip active pour les reponses texte
• Cache des assets statiques (expires headers)

# Bloc Nginx optimise pour Sylius
server {
    listen 443 ssl http2;
    server_name maboutique.fr;
    root /var/www/sylius/public;

    ssl_certificate /etc/letsencrypt/live/maboutique.fr/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/maboutique.fr/privkey.pem;

    # Assets statiques
    location ~* \.(js|css|png|jpg|jpeg|gif|webp|svg|ico|woff2)$ {
        expires 1y;
        add_header Cache-Control "public, immutable";
        access_log off;
    }

    location / {
        try_files $uri /index.php$is_args$args;
    }

    location ~ ^/index\.php(/|$) {
        fastcgi_pass unix:/run/php/php8.3-fpm.sock;
        fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
        include fastcgi_params;
        fastcgi_buffer_size 128k;
        fastcgi_buffers 4 256k;
        internal;
    }

    # Interdire l'acces aux fichiers sensibles
    location ~ /\.(ht|git|env) {
        deny all;
    }
}

2. Configuration Symfony/Sylius

• APP_ENV=prod dans le .env.local
• APP_DEBUG=0
• APP_SECRET genere aleatoirement (32+ caracteres)
• DATABASE_URL configuree correctement
• Cache Symfony precalcule : php bin/console cache:warmup --env=prod
• Assets compiles : php bin/console assets:install --env=prod
• Composer optimise : composer install --no-dev --optimize-autoloader
• Migrations Doctrine executees : php bin/console doctrine:migrations:migrate

3. Cache applicatif

• Redis installe et configure pour le cache Symfony
• Sessions stockees dans Redis (pas en fichier)
• Doctrine metadata et query cache dans Redis

# config/packages/prod/cache.yaml
framework:
    cache:
        app: cache.adapter.redis
        default_redis_provider: 'redis://localhost:6379/0'

# config/packages/prod/doctrine.yaml
doctrine:
    orm:
        metadata_cache_driver:
            type: pool
            pool: doctrine.system_cache_pool
        query_cache_driver:
            type: pool
            pool: doctrine.system_cache_pool
        result_cache_driver:
            type: pool
            pool: doctrine.result_cache_pool

# config/packages/prod/framework.yaml
framework:
    session:
        handler_id: 'redis://localhost:6379/1'

4. Queue workers (Messenger)

• Transport Messenger configure (Redis, RabbitMQ ou Doctrine)
• Workers supervises par systemd ou Supervisor
• Retry strategy configuree pour les messages echoues
• Dead letter queue pour les messages irrecuperables

# /etc/supervisor/conf.d/sylius-messenger.conf
[program:sylius-messenger]
command=php /var/www/sylius/bin/console messenger:consume async --time-limit=3600 --memory-limit=256M
user=www-data
numprocs=2
process_name=%(program_name)s_%(process_num)02d
autostart=true
autorestart=true
stdout_logfile=/var/log/sylius/messenger.log
stderr_logfile=/var/log/sylius/messenger-error.log

5. SSL et securite

• Certificat SSL via Let's Encrypt (certbot)
• Redirection HTTP vers HTTPS automatique
• HSTS active (Strict-Transport-Security)
• Headers de securite configures :

# Headers de securite Nginx
add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-Content-Type-Options "nosniff" always;
add_header X-XSS-Protection "1; mode=block" always;
add_header Referrer-Policy "strict-origin-when-cross-origin" always;
add_header Content-Security-Policy "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:;" always;
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

• Acces admin restreint par IP ou VPN
• composer audit sans vulnerabilite connue
• Fichier .env.local non versionne dans Git
• Repertoires var/, vendor/ non accessibles depuis le web

6. Backups

• Backup base de donnees quotidien automatise
• Backup des fichiers uploades (images produits)
• Backups stockees sur un serveur distant (pas seulement en local)
• Retention : 7 quotidiennes + 4 hebdomadaires + 3 mensuelles
• Restauration testee au moins une fois

# Script de backup quotidien
#!/bin/bash
DATE=$(date +%Y-%m-%d)
BACKUP_DIR="/var/backups/sylius"

# Backup MySQL
mysqldump --single-transaction sylius_prod | gzip > "$BACKUP_DIR/db-$DATE.sql.gz"

# Backup des uploads
tar czf "$BACKUP_DIR/uploads-$DATE.tar.gz" /var/www/sylius/public/media/

# Envoyer vers un stockage distant
rclone copy "$BACKUP_DIR/db-$DATE.sql.gz" remote:backups/sylius/
rclone copy "$BACKUP_DIR/uploads-$DATE.tar.gz" remote:backups/sylius/

# Nettoyer les vieux backups locaux (> 7 jours)
find "$BACKUP_DIR" -name "*.gz" -mtime +7 -delete

7. Monitoring

• Uptime monitoring (UptimeRobot, Better Stack, Pingdom)
• Error tracking (Sentry recommande)
• Metriques serveur (Prometheus + Grafana, ou Netdata)
• Alertes sur : CPU > 90%, RAM > 90%, disque > 85%, 5xx errors
• Logs centralises et rotatifs (logrotate)

# Installation Sentry pour Symfony
composer require sentry/sentry-symfony

# config/packages/sentry.yaml
sentry:
    dsn: '%env(SENTRY_DSN)%'
    options:
        environment: '%kernel.environment%'
        traces_sample_rate: 0.2

8. Deploiement automatise

• Script de deploiement automatise (Deployer, Ansible ou GitHub Actions)
• Zero-downtime deployment configure
• Rollback possible en cas de probleme

# deploy.php (Deployer)
namespace Deployer;

require 'recipe/symfony.php';

host('production')
    ->set('hostname', 'maboutique.fr')
    ->set('remote_user', 'deploy')
    ->set('deploy_path', '/var/www/sylius');

task('deploy', [
    'deploy:prepare',
    'deploy:vendors',
    'deploy:cache:warmup',
    'database:migrate',
    'deploy:publish',
]);

after('deploy:failed', 'deploy:unlock');

9. Optimisation PHP-FPM

PHP-FPM est le moteur qui execute votre code Sylius. Sa configuration a un impact direct sur la capacite de votre serveur a gerer les requetes concurrentes.

# /etc/php/8.3/fpm/pool.d/sylius.conf
[sylius]
user = www-data
group = www-data
listen = /run/php/php8.3-fpm-sylius.sock

; Mode statique pour des performances previsibles en production
pm = static
pm.max_children = 20

; Recycler les workers regulierement pour eviter les fuites memoire
pm.max_requests = 500

; Logs de performance
slowlog = /var/log/php-fpm/sylius-slow.log
request_slowlog_timeout = 5s
request_terminate_timeout = 60s

; Variables d'environnement
env[APP_ENV] = prod
env[APP_DEBUG] = 0

Le nombre de pm.max_children depend de la RAM disponible. Chaque worker PHP-FPM consomme environ 50-80 Mo pour Sylius. Sur un serveur 8 Go avec MySQL et Redis, 20 workers est un bon point de depart. Surveillez la memoire et ajustez.

• Pool PHP-FPM dedie pour Sylius (pas de pool partagee)
• pm.max_children calibre selon la RAM
• pm.max_requests configure (eviter les fuites memoire)
• slowlog active pour detecter les requetes lentes
• OPcache preloading configure pour Symfony

10. Tests de charge avant la mise en ligne

Ne mettez jamais en production sans avoir teste les limites de votre serveur. Utilisez un outil de charge pour simuler le trafic reel :

# Test basique avec Apache Bench
ab -n 1000 -c 50 https://maboutique.fr/

# Test plus realiste avec k6
# k6-script.js
import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
    stages: [
        { duration: '2m', target: 50 },   // montee progressive
        { duration: '5m', target: 50 },   // charge soutenue
        { duration: '2m', target: 100 },  // pic de charge
        { duration: '1m', target: 0 },    // descente
    ],
};

export default function () {
    // Simuler un parcours utilisateur realiste
    let res = http.get('https://maboutique.fr/');
    check(res, { 'homepage 200': (r) => r.status === 200 });
    sleep(1);

    res = http.get('https://maboutique.fr/taxons/vetements');
    check(res, { 'category 200': (r) => r.status === 200 });
    sleep(2);

    res = http.get('https://maboutique.fr/products/t-shirt-premium');
    check(res, { 'product 200': (r) => r.status === 200 });
    sleep(1);
}

Les metriques a surveiller pendant le test :

• TTFB p95 : le temps de reponse au 95e percentile doit rester sous 500ms
• Taux d'erreur : aucune erreur 5xx ne doit apparaitre sous charge normale
• CPU et RAM : ni l'un ni l'autre ne doivent plafonner a 100%
• Requetes par seconde : votre serveur doit supporter au moins 2x votre pic de trafic prevu

Si les resultats sont insuffisants, les premiers leviers sont : activer Varnish, augmenter le nombre de workers PHP-FPM, et optimiser les requetes Doctrine les plus lentes.

11. Verifications finales

• Pages de paiement testees (commande complete de bout en bout)
• Emails transactionnels fonctionnels (confirmation commande, mot de passe oublie)
• Robots.txt correct et sitemap.xml genere
• Google Search Console configuree
• Google Analytics ou Matomo installe
• Pages legales presentes (CGV, mentions legales, politique de confidentialite)
• Bandeau cookies RGPD fonctionnel
• Test Lighthouse > 80 sur mobile
• Test de charge basique effectue (ab, k6 ou locust)

Conclusion

Cette checklist couvre les fondamentaux d'un deploiement Sylius reussi. Chaque point a ete eprouve sur des projets reels en production. Ne negligez aucune etape, surtout la securite et les backups - ce sont les deux aspects qu'on regrette le plus quand ils manquent.

Besoin d'un accompagnement pour la mise en production de votre Sylius ? Contactez-moi. Je prends en charge le deploiement complet, de la configuration serveur au monitoring. Voir aussi nos articles sur Varnish pour les performances et le SEO Sylius. Consultez nos tarifs pour un chiffrage precis.