Formation PHP MySQL - Sites Web Dynamiques et BDD

- L'écosystème PHP en 2025-2026 : pourquoi PHP propulse encore près de 75% du web côté serveur (WordPress, Wikipedia, Slack, Etsy, Vimeo) et reste un choix stratégique

- Roadmap des versions : PHP 8.3 (LTS jusqu'en décembre 2027), PHP 8.4 (stable, nouveautés majeures), fin de support de 8.1 — comment choisir et migrer

- Installation locale : comparaison Laragon vs XAMPP vs WAMP vs Docker (PHP-FPM + Nginx) — recommandations selon le profil

- Configuration de php.ini : extensions essentielles (pdo_mysql, mbstring, curl, intl, opcache, gd), directives critiques (display_errors, error_reporting, memory_limit, opcache.enable)

- Premier script : balises PHP, syntaxe de base, variables, débogage avec var_dump(), print_r(), get_debug_type() (PHP 8.0)

- IDE moderne : VS Code + PHP Intelephense + DevSense PHP Debug, ou PhpStorm — configurations productives, snippets, formatters PSR-12

- Atelier pratique : installer un environnement Laragon ou Docker avec PHP 8.4 + MySQL 8, créer un premier script connecté à la base et afficher une liste de produits

- Variables, types scalaires (int, float, string, bool) et types composés (array indexé, array associatif, object) — différences avec d'autres langages

- Type declarations : declare(strict_types=1), arguments typés, return types, union types (int|string), intersection types (Countable&Stringable), never, void, nullable (?Type)

- Constantes (const, define) et enums (PHP 8.1) : enums purs vs enums backés (string, int), méthodes sur enums, cas pratiques (statut commande, rôle utilisateur)

- Structures de contrôle modernes : match expression vs switch (exhaustivité, retour de valeur, comparaison stricte), null coalescing (??), null safe operator (?->) pour chaînes d'appels sécurisées

- Fonctions : arguments nommés (named arguments) pour la lisibilité, arguments par défaut, variadic (...$args), first-class callable syntax (strlen(...))

- Atelier pratique : refactoriser un script PHP 7 mal typé en PHP 8.4 avec strict_types, enums backés, match et arguments nommés — observer la réduction de bugs et l'amélioration de la lisibilité

- Classes, propriétés, méthodes, visibilité (public, protected, private) — rappels essentiels

- Constructor property promotion (PHP 8.0) : la syntaxe qui supprime jusqu'à 80% du boilerplate des constructeurs

- Readonly properties (PHP 8.1) et readonly classes (PHP 8.2) : objets immuables, value objects, DTO

- Asymmetric visibility (PHP 8.4) : public(set), protected(set), private(set) — propriétés lisibles publiquement mais modifiables uniquement en interne

- Property hooks (PHP 8.4) : remplacer get/set verbeux par des hooks intégrés à la déclaration de propriété, validation et calcul à la volée

- Héritage, interfaces, traits, classes abstraites — quand utiliser quoi (composition vs héritage)

- Méthodes magiques : __construct, __destruct, __toString, __invoke, __get, __set — bonnes pratiques et pièges

- Clonage et égalité d'objets : __clone, ==, ===, equals personnalisé

- Atelier pratique : modéliser un domaine e-commerce (Utilisateur, Adresse, Produit, Commande, LigneCommande) en PHP 8.4 avec readonly classes, asymmetric visibility et property hooks pour calcul de totaux

- Espaces de noms (namespaces) : déclaration, use, alias (as), résolution des noms

- Autoloading PSR-4 : convention de mapping namespace vers répertoire, fin de l'ère require_once

- Composer : composer.json, composer.lock, vendor/, autoload.php — pourquoi c'est l'outil incontournable

- Standards PSR (PHP-FIG) : PSR-1 (style basique), PSR-12 (style étendu, remplace PSR-2), PSR-4 (autoload), PSR-7 (HTTP messages), PSR-11 (conteneur DI), PSR-15 (middlewares)

- Gestion des erreurs et exceptions : try/catch/finally, throw expression (PHP 8.0), hiérarchie d'exceptions, exceptions personnalisées avec contexte

- Fibers (PHP 8.1) : programmation asynchrone légère, cas d'usage (HTTP concurrent avec ReactPHP/AMPHP, I/O non bloquantes), différence avec coroutines

- Atelier pratique : structurer un mini-projet en composer.json avec namespace App\, autoload PSR-4, exception custom DomainException et premier script lancé via vendor/bin

- Concepts SGBDR : tables, colonnes, lignes, clés primaires, clés étrangères, contraintes (NOT NULL, UNIQUE, CHECK, DEFAULT)

- MySQL 8 vs MariaDB 11 : différences (CTE récursives, window functions, JSON, roles), critères de choix, écosystème cloud (AWS RDS, OVH MySQL managé, PlanetScale)

- Outils d'administration : phpMyAdmin (intégré à Laragon/XAMPP), MySQL Workbench, DBeaver, TablePlus, ligne de commande mysql

- Conception relationnelle : du modèle conceptuel (MCD) au modèle logique (MLD), formes normales (1FN, 2FN, 3FN, BCNF) — pourquoi normaliser, quand dénormaliser

- Types de données MySQL 8 : entiers (TINYINT à BIGINT), chaînes (CHAR, VARCHAR, TEXT, ENUM), dates (DATE, DATETIME, TIMESTAMP), JSON natif, GEOMETRY — choisir le bon type pour la performance

- Moteurs de stockage : InnoDB (par défaut, ACID, transactions, verrouillage row-level, crash recovery, foreign keys) vs MyISAM (legacy, plus de transactions) — toujours InnoDB en 2026

- Encodages : utf8mb4 + utf8mb4_unicode_ci (jamais utf8 simple qui ne supporte pas les emojis)

- Atelier pratique : modéliser une base e-commerce complète (utilisateurs, adresses, catégories, produits, stocks, commandes, lignes de commande, paiements) avec MySQL Workbench, générer le DDL et l'importer dans MySQL 8

- CRUD complet : SELECT (avec DISTINCT, alias), INSERT (multi-rows, INSERT IGNORE, ON DUPLICATE KEY UPDATE), UPDATE (avec JOIN), DELETE (avec LIMIT)

- Filtres et opérateurs : WHERE, IN, NOT IN, BETWEEN, LIKE (avec wildcards %, _), REGEXP, IS NULL

- Agrégats et regroupements : COUNT, SUM, AVG, MIN, MAX, GROUP BY, HAVING (filtre post-agrégation)

- Tri et pagination : ORDER BY (asc, desc, multi-colonnes), LIMIT et OFFSET — pièges de la pagination sur gros volumes (keyset pagination)

- Jointures : INNER JOIN, LEFT JOIN, RIGHT JOIN, CROSS JOIN — visualisation et cas d'usage

- Sous-requêtes corrélées et non corrélées, CTE (WITH ... AS) et CTE récursives (arborescences, hiérarchies)

- Window functions MySQL 8 : ROW_NUMBER(), RANK(), DENSE_RANK(), LAG(), LEAD(), SUM() OVER — analytics sans GROUP BY

- Indexation : index simples vs composites, covering index (incluant toutes les colonnes), index sur expressions (PHP 8 functional indexes)

- EXPLAIN et EXPLAIN ANALYZE : lire un plan d'exécution, identifier les full scans, comprendre le coût

- Atelier pratique : écrire 15 requêtes SQL sur la base e-commerce (top 10 clients, panier moyen mensuel, produits jamais commandés, classement des ventes par catégorie avec window function), analyser avec EXPLAIN et créer les index manquants

- PDO vs MySQLi vs ext/mysql (déprécié depuis PHP 5.5, supprimé depuis PHP 7) : pourquoi PDO est le standard universel en 2026 (multi-SGBD, API cohérente)

- Connexion à la base : DSN (mysql:host=...;dbname=...;charset=utf8mb4), options de connexion (PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, PDO::ATTR_EMULATE_PREPARES => false)

- Requêtes préparées : prepare() + execute() — la défense ultime et obligatoire contre l'injection SQL, fonctionnement côté serveur MySQL

- bindParam() vs bindValue() : différence subtile (référence vs copie), types explicites (PDO::PARAM_INT, PDO::PARAM_STR, PDO::PARAM_BOOL, PDO::PARAM_NULL)

- Récupérer des données : fetch() (une ligne), fetchAll() (toutes les lignes), fetchColumn() (une valeur), fetchObject() (objet) — modes FETCH_ASSOC, FETCH_OBJ, FETCH_CLASS, FETCH_KEY_PAIR

- Insertion, mise à jour, suppression : lastInsertId(), rowCount(), bonnes pratiques

- Transactions ACID : beginTransaction(), commit(), rollback() — gestion d'exceptions, niveaux d'isolation (REPEATABLE READ par défaut en InnoDB)

- Pattern Repository : encapsuler les requêtes SQL dans des classes dédiées (UserRepository, ProductRepository) pour la testabilité

- Atelier pratique : refactoriser un script de gestion de panier utilisant des concaténations SQL dangereuses en classes Repository PDO avec requêtes préparées, transactions atomiques (commande + lignes + débit stock) et rollback en cas d'erreur

- Superglobales : $_GET, $_POST, $_SESSION, $_COOKIE, $_SERVER, $_FILES, $_ENV — usages, pièges et risques

- Validation et filtrage côté serveur (côté client n'est qu'une commodité UX) : filter_var() (FILTER_VALIDATE_EMAIL, FILTER_VALIDATE_URL, FILTER_SANITIZE_*), filter_input(), validation custom avec Symfony Validator ou Respect\Validation

- Échappement des sorties : htmlspecialchars($var, ENT_QUOTES | ENT_HTML5, 'UTF-8') systématique, contextes HTML/attribut/JS/URL/CSS, attribut nonce pour CSP

- Protection CSRF : génération de tokens (random_bytes(32), base64), vérification côté serveur, attribut SameSite=Strict ou Lax sur les cookies de session, SameSite=None nécessite Secure

- Authentification sécurisée : password_hash($pwd, PASSWORD_ARGON2ID) avec coût adapté, password_verify(), password_needs_rehash() pour migration progressive, jamais MD5/SHA1

- Sessions durcies : session_regenerate_id(true) après login, session.cookie_secure=1, session.cookie_httponly=1, session.use_strict_mode=1, session.cookie_samesite=Strict

- Headers de sécurité HTTP : Content-Security-Policy (default-src 'self'), Strict-Transport-Security, X-Content-Type-Options: nosniff, Referrer-Policy: strict-origin-when-cross-origin

- OWASP Top 10 PHP : tour d'horizon des vulnérabilités courantes (broken access control, cryptographic failures, injection, insecure design, SSRF, log injection)

- Atelier pratique : construire un système d'inscription/connexion sécurisé complet (validation, hash argon2id, token CSRF, headers de sécurité, messages flash, redirection post-login, protection contre brute force avec délai exponentiel)

JOUR 3 — Architecture MVC, ORM et templating professionnel

- Pourquoi le MVC : séparation des responsabilités (modèle = données, vue = présentation, contrôleur = orchestration), testabilité, maintenabilité, travail en équipe

- Front controller pattern : un seul point d'entrée index.php, réécriture d'URL avec .htaccess (Apache) ou try_files (Nginx), suppression du .php des URLs

- Routing maison : parsing de l'URL, mapping vers contrôleur/action, paramètres dynamiques ({id}, {slug}), méthodes HTTP (GET, POST, PUT, PATCH, DELETE)

- Routers existants : nikic/fast-route, symfony/routing, league/route — performances comparées

- Modèles : pattern Active Record (Eloquent) vs pattern Data Mapper (Doctrine) vs pattern Repository — avantages et limites

- Contrôleurs : single action invokables (__invoke) vs multi-action, retour de Response (PSR-7), injection des dépendances par constructeur

- Vues : moteurs de templates (Twig, Blade, Plates, PHP natif), héritage de templates, échappement automatique

- Atelier pratique : construire un mini-framework MVC complet en partant d'index.php — implémenter Router, Request, Response, abstract Controller, abstract Model, View — exécuter une première page produit dynamique

- Inversion de contrôle (IoC) et injection de dépendances : pourquoi (testabilité, découplage), constructor injection vs setter injection vs property injection

- Conteneur DI : implémentation manuelle simple, puis migration vers PHP-DI ou Symfony DependencyInjection — autowiring par type-hint, autoconfiguration, bindings

- Service Locator anti-pattern : pourquoi l'éviter

- Twig en profondeur : syntaxe ({{ var }} pour échapper, {% logique %}, {# commentaire #}), filtres (date, escape, raw, length), fonctions (path, asset, dump), tests (defined, empty)

- Héritage de templates Twig : extends, blocks, parent(), inclusion (include, embed), macros, components Twig (Symfony UX)

- Sécurité Twig : auto-escaping activé par défaut, raw uniquement sur contenu de confiance, sandboxing pour user-generated content

- Architecture en couches : Controller → Service → Repository → Database — séparer la logique métier des contrôleurs ("thin controller, fat service")

- Atelier pratique : ajouter Symfony DI au mini-framework, refactoriser les vues PHP natives en templates Twig avec layout maître (header, sidebar, footer), composants réutilisables (carte produit, pagination)

- ORM : avantages (productivité, lisibilité, agnostique du SGBD) vs inconvénients (complexité, performances, magie) — quand utiliser un ORM

- Doctrine ORM 3.x : entités avec attributs PHP 8 (#[Entity], #[Id], #[Column], #[OneToMany], #[ManyToOne]), repositories, EntityManager

- Relations : OneToOne, OneToMany, ManyToOne, ManyToMany — owning side vs inverse side, cascade, orphanRemoval

- Lazy loading vs eager loading : N+1 problem, fetch=EAGER, JOIN FETCH en DQL, Criteria pour le filtrage

- DQL (Doctrine Query Language) vs QueryBuilder : SQL-like orienté objet, requêtes complexes, pagination Doctrine Pager

- Migrations de base de données : doctrine/migrations — versioning du schéma, génération automatique (diff), exécution en CI/CD

- Validation Symfony Validator : contraintes sur entités (#[Assert\NotBlank], #[Assert\Email], #[Assert\Length])

- Atelier pratique : remplacer la couche PDO du mini-framework par Doctrine ORM, modéliser les entités Produit/Catégorie/Commande, générer les migrations et les exécuter

- Upload de fichiers : $_FILES, multipart/form-data, configurations PHP (upload_max_filesize, post_max_size, max_file_uploads), erreurs UPLOAD_ERR_*

- Validation rigoureuse : type MIME réel via finfo_file() (jamais $_FILES['type'] manipulable), extension whitelist, taille, nom sécurisé (basename + uniqid + slug)

- Stockage : système de fichiers local (move_uploaded_file), stockage cloud (AWS S3, OVH Object Storage, Backblaze B2) via league/flysystem v3

- Manipulation d'images : GD vs Imagick, redimensionnement, compression, conversion WebP/AVIF, génération de thumbnails (intervention/image, spatie/image)

- Envoi d'e-mails transactionnels : symfony/mailer ou phpmailer, templates Twig pour les e-mails, providers (SendGrid, Mailgun, Brevo, Postmark, Resend)

- Tâches asynchrones et files de messages : symfony/messenger, queues (Redis, RabbitMQ, Doctrine), workers, retry et dead letter queue

- Atelier pratique : ajouter au mini-framework un système d'upload d'avatar (validation MIME, redimensionnement WebP), envoi d'e-mail de bienvenue via Symfony Mailer + Brevo et traitement asynchrone via Messenger + Redis

JOUR 4 — APIs REST, écosystème Composer et frameworks majeurs

- Principes REST : ressources (noms, pas verbes), verbes HTTP (GET, POST, PUT, PATCH, DELETE), statelessness, cacheabilité, HATEOAS (niveau 3 maturité Richardson)

- Codes HTTP corrects : 200 OK, 201 Created (avec Location), 204 No Content, 400 Bad Request, 401 Unauthorized vs 403 Forbidden, 404 Not Found, 409 Conflict, 422 Unprocessable Entity, 429 Too Many Requests, 500 Internal Server Error

- Format JSON : json_encode() avec JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES, json_decode($s, true, 512, JSON_THROW_ON_ERROR)

- Architecture API : versioning (/api/v1/, header Accept: application/vnd.app.v1+json), pagination (cursor-based, page-based, Link header), filtres (?filter[status]=active), tri (?sort=-createdAt), recherche

- Sérialisation : symfony/serializer (groupes, normalizers), api-platform (génération auto), JMS Serializer

- Validation des payloads : Symfony Validator avec DTO d'entrée, gestion d'erreurs structurée (problem+json RFC 7807)

- Documentation OpenAPI 3.1 : zircote/swagger-php (attributs PHP 8 #[OA\Get]), Swagger UI, Redoc, Stoplight Elements

- Atelier pratique : exposer le CRUD du mini-framework en API REST JSON avec routes versionnées, pagination, filtres, validation par DTO et documentation OpenAPI auto-générée + UI Swagger

- Mécanismes d'auth API : Basic Auth (HTTPS obligatoire), API Key (header X-API-Key), OAuth 2.0 (authorization code, client credentials), JWT, Sanctum/Passport

- JWT (JSON Web Token, RFC 7519) : structure (header.payload.signature), algorithmes (HS256 vs RS256/ES256), claims standards (iss, sub, aud, exp, nbf, iat, jti)

- Sécurité JWT : ne jamais stocker de données sensibles dans le payload (lisible), expiration courte (15 min) + refresh token long, rotation des refresh tokens, blacklist en cas de logout

- Implémentation : firebase/php-jwt v6, lcobucci/jwt v5 — génération, vérification, gestion d'expiration, refresh token endpoint

- CORS (Cross-Origin Resource Sharing) : preflight OPTIONS, headers Access-Control-Allow-Origin/Methods/Headers/Credentials, configuration sécurisée (jamais Allow-Origin: * avec credentials)

- Rate limiting : protection contre l'abus et le brute force, implémentation avec Redis (sliding window, token bucket), header Retry-After, package symfony/rate-limiter

- Sécurité globale API : HTTPS obligatoire, HSTS, audit des dépendances (composer audit), monitoring des erreurs 4xx/5xx

- Atelier pratique : ajouter une authentification JWT au mini-framework (login, refresh, logout), protéger les routes sensibles avec middleware, configurer CORS pour un frontend SPA et rate limiting de 60 requêtes/minute par utilisateur

- Composer 2.x : composer.json (require, require-dev, scripts, autoload, autoload-dev, repositories), composer.lock, semver et contraintes (^, ~, *, >=, <=)

- Commandes essentielles : install, update, require, remove, dump-autoload (-o), outdated, why, why-not, audit (intégré 2.4+)

- Packages incontournables 2026 : symfony/console (CLI), monolog/monolog (logs), guzzlehttp/guzzle (HTTP client), ramsey/uuid, vlucas/phpdotenv ou symfony/dotenv, nesbot/carbon (dates), league/csv, league/flysystem

- Création et publication d'un package : structure du dépôt, composer.json bien typé (name, description, type, license, autoload PSR-4, require), publication sur Packagist, gestion des versions et tags Git

- Optimisation production : composer install --no-dev --optimize-autoloader --classmap-authoritative, preload PHP 8 (opcache.preload)

- Sécurité des dépendances : composer audit (CVE Advisory Database), Roave/SecurityAdvisories (refus de packages vulnérables), Dependabot, Snyk, Renovate

- Atelier pratique : créer un petit package PHP réutilisable (ex : validateur SIRET français), publier sur GitHub avec composer.json conforme, tagger une release, l'installer dans le mini-framework via Packagist

- Symfony 7 : philosophie (composants réutilisables, kernel, configuration), bundles, Symfony Flex, Twig, Doctrine, Messenger, API Platform — adopté par les grands groupes (BlaBlaCar, Doctolib, Dailymotion)

- Laravel 11 : DX exceptionnelle, écosystème (Eloquent, Blade, Livewire, Filament, Nova, Forge, Vapor, Octane), philosophie de la convention sur la configuration

- Slim 4, Mezzio (PSR-15) : micro-frameworks, idéal pour les API légères et les projets contraints

- Hyperf, Swoole, OpenSwoole, RoadRunner, FrankenPHP : frameworks et runtimes haute performance, PHP-as-a-service, persistance d'application en mémoire

- API Platform : génération automatique d'API REST + GraphQL à partir d'entités Doctrine, état de l'art en 2026

- Critères de choix en 2026 : taille du projet, équipe (juniors vs seniors), écosystème, marché de l'emploi (en France : Symfony dominant en grands comptes, Laravel en agences/startups), maintenance long terme, courbe d'apprentissage

- Migration et coexistence : Strangler Fig pattern pour moderniser un legacy, partage de DB entre Symfony et Laravel, scénarios d'hybridation

- Atelier pratique : implémenter une même fonctionnalité "liste paginée de produits avec filtre catégorie" en Symfony (controller + Twig + Doctrine) et en Laravel (controller + Blade + Eloquent) — comparer DX, performance et code, choisir le framework adapté à 3 cas clients fournis

JOUR 5 — Qualité, tests automatisés, déploiement et projet final

- PHP_CodeSniffer (phpcs et phpcbf) : vérifier le respect de PSR-12 et PER-CS 2.0, sniffs personnalisés, intégration éditeur

- PHP-CS-Fixer : formatage automatique, ruleset @PSR12, @PER-CS2.0, @Symfony, @PhpCsFixer, configuration .php-cs-fixer.dist.php

- PHPStan : analyse statique sans exécution, niveaux 0 à 9 (max), règles Bleeding Edge, extensions (phpstan-symfony, phpstan-doctrine, phpstan-strict-rules), baselines pour projets legacy

- Psalm : alternative à PHPStan, taint analysis pour la sécurité (XSS, SQL injection détectés statiquement), psalm.xml

- Rector : refactoring automatisé, sets de rules (UP_TO_PHP_84, CODE_QUALITY, DEAD_CODE, EARLY_RETURN, TYPE_DECLARATION) — moderniser un projet legacy en heures plutôt qu'en semaines

- PHPMD (Mess Detector) : détecter le code smell (longueur de méthodes, complexité cyclomatique, classes God)

- Atelier pratique : configurer PHPStan niveau 8 + PHP-CS-Fixer + Rector sur le mini-framework, corriger les warnings, automatiser avec un Makefile (make lint, make fix, make analyse)

- Pyramide des tests : tests unitaires (rapides, isolés, nombreux), tests d'intégration (couvrent plusieurs composants), tests fonctionnels/end-to-end (lents, peu nombreux)

- PHPUnit 11 : structure (TestCase, méthodes test*), assertions (assertSame vs assertEquals, assertCount, assertInstanceOf, expectException), data providers (#[DataProvider]), mocks (createMock, willReturn)

- Pest 3 : alternative moderne à PHPUnit (syntaxe expressive avec it/expect/describe), plugins (Pest Stressless, Pest Type Coverage, Pest Mutation Testing), exécution parallèle

- Mutation testing avec Infection : ne pas se contenter de la coverage de lignes, vérifier que les tests détectent réellement les bugs (Mutation Score Indicator)

- Tests d'intégration MySQL : base de test dédiée, transactions roll-back automatique entre tests, fixtures (alice/nelmio, doctrine/data-fixtures)

- Tests d'API HTTP : symfony/http-client + assertions JSON, snapshot testing avec spatie/phpunit-snapshot-assertions

- TDD (Test Driven Development) : cycle Red/Green/Refactor démontré en direct sur un kata (FizzBuzz, Roman Numerals)

- Coverage : générer un rapport HTML avec PHPUnit + Xdebug ou PCOV, viser 80% de coverage sur la logique métier (pas 100%, ROI décroissant)

- Atelier pratique : écrire 10 tests unitaires (services métier), 5 tests d'intégration (Repository + MySQL), 3 tests d'API (endpoints REST avec JWT) sur le mini-framework, atteindre 80% de coverage et 70% de Mutation Score

- Environnements : développement, staging, production — variables d'environnement (.env, .env.local, .env.prod) avec symfony/dotenv ou vlucas/phpdotenv

- Hébergement PHP en 2026 : VPS (OVH, Hetzner, Scaleway), PaaS (Platform.sh, Fortrabbit, Laravel Forge, Cloudways), serverless (Bref + AWS Lambda), edge (Cloudflare Workers via FrankenPHP expérimental)

- Stack serveur moderne : Nginx + PHP-FPM 8.4 + OPcache + JIT activé, ou alternative PHP-as-a-service (FrankenPHP avec Caddy intégré, RoadRunner, Swoole)

- Configurations production : opcache.enable=1, opcache.validate_timestamps=0, opcache.preload, JIT (opcache.jit=tracing), realpath_cache_size, fpm pm=dynamic

- Docker pour PHP : Dockerfile multi-stage (build vendors, runtime minimal), docker-compose pour développement (php-fpm, nginx, mysql, redis, mailhog), images officielles vs Alpine

- CI/CD avec GitHub Actions : workflow PHP type (matrix PHP 8.3/8.4, composer install, phpstan, php-cs-fixer dry-run, phpunit avec coverage), déploiement automatique

- Déploiement zero-downtime : Deployer (deployer.org), stratégie symlinks (current → release-N), atomic deploy, rollback en 1 commande

- Monitoring : Sentry pour la capture d'erreurs en production, Blackfire/Tideways pour le profiling APM, logs structurés avec Monolog + Loki/Grafana ou ELK

- Atelier pratique : containeriser le mini-framework (Dockerfile + docker-compose), écrire un workflow GitHub Actions complet (lint, test, build, deploy), déployer sur un VPS via Deployer et configurer Sentry pour la capture d'erreurs

- Brief du projet final : application complète "Mini-CMS de blog" avec authentification utilisateurs/admin, CRUD articles avec catégories et tags, commentaires modérés, API REST publique JSON, espace admin protégé, tests automatisés et déploiement

- Cahier des charges et user stories : du besoin métier aux specs (format Gherkin Given/When/Then), priorisation MoSCoW

- Stack imposée : PHP 8.4 strict_types, MySQL 8 utf8mb4, Symfony 7 ou Laravel 11, Twig ou Blade, Doctrine ou Eloquent, PHPStan niveau 8, Pest ou PHPUnit ≥80% coverage, déploiement Docker + GitHub Actions

- Restitution : démo en direct (15 min par binôme), code review collective, feedback structuré (technique + UX + sécurité)

- Roadmap personnelle de progression : ressources avancées (Laracasts par Jeffrey Way, SymfonyCasts par Ryan Weaver, ThePhpFoundation, php[architect]), communauté (AFUP France, conférences ForumPHP Paris, SymfonyCon, Laracon EU), newsletters (PHP Annotated, Laravel News, Symfony Insight)

- Préparation à la certification Zend Certified PHP Engineer (PHP 8) : programme officiel, ressources d'entraînement, modalités pratiques (Pearson VUE, 70 questions, 90 minutes)

- Préparation à la certification Symfony 7 Certified Developer (sensiolabs) ou Laravel Certified Developer

- Évaluation finale : QCM 30 questions sur l'ensemble de la formation + restitution du projet final, attestation de fin de formation