Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

🐘 Livrez avec PHP

Une personne et un petit éléphant posent la derniÚre brique, la seule bleue, sur le toit d'une petite maison faite de grosses briques de construction. Une remorque de livraison attend à cÎté, rampe baissée

Un guide par fonctionnalitĂ© pour livrer avec Laravel, Symfony, WordPress, TYPO3, API Platform, Nextcloud et le reste de l’écosystĂšme PHP moderne

On vient de vous confier une fonctionnalitĂ©, une date de livraison et un terminal vide. Vous savez coder. Vous n’avez aucune envie d’apprendre un nouveau langage pour le prouver. Ce livre vous dit quelle commande taper en premier, fonctionnalitĂ© par fonctionnalitĂ©, et ce que chaque choix vous coĂ»tera plus tard.

Avant-propos : on peut conduire sans aimer le moteur

Personne ne demande Ă  un livreur de dĂ©monter le moteur du camion avant sa premiĂšre tournĂ©e. On lui donne les clĂ©s, un itinĂ©raire et une heure limite. Si le camion tombe en panne, quelqu’un d’autre s’en occupe. La plupart du travail logiciel ressemble Ă  cela, bien plus que les livres de programmation ne l’admettent.

On vous a confiĂ© une fonctionnalitĂ©. Un site client qui a besoin d’un blog et d’un formulaire de contact pour vendredi, peut-ĂȘtre. Ou un outil interne avec un Ă©cran de connexion et un tableau que personne n’a envie de construire Ă  la main. Ou une preuve de concept qui doit avoir l’air assez vraie pour ĂȘtre financĂ©e. Vous n’avez pas ouvert ce livre pour tomber amoureux d’un langage. Vous l’avez ouvert parce que quelque chose doit exister, et que ce quelque chose tourne sur un langage dont vous prĂ©fĂ©reriez peut-ĂȘtre ne pas prononcer le nom.

Aucun problĂšme. Ce livre le prononcera Ă  peine, lui aussi. Il vous montre, fonctionnalitĂ© par fonctionnalitĂ©, le chemin le plus court et le plus honnĂȘte entre « rien n’existe encore » et « ça marche, je peux le remettre au client ». Ce chemin passe parfois par un framework complet comme Laravel ou Symfony. Parfois par un CMS comme WordPress ou TYPO3, qui a rĂ©solu votre problĂšme il y a dix ans. Parfois la bonne rĂ©ponse tient dans une petite bibliothĂšque qui fait une seule chose et se fait oublier. Et parfois, quand le budget le permet, la bonne rĂ©ponse consiste Ă  payer quelqu’un d’autre pour faire tourner la partie difficile.

Rien de tout cela n’est un compromis. Le savoir-faire, ici, c’est de choisir l’outil qui livre le plus vite, qui tient face Ă  un vrai client, et qui ne vous laisse pas dĂ©boguer l’astuce de quelqu’un d’autre Ă  deux heures du matin. Ce livre enseigne ce savoir-faire aussi honnĂȘtement qu’il le peut : ce que chaque option fait bien, ce qu’elle vous coĂ»te discrĂštement plus tard, et comment distinguer les deux avant de vous engager.

Un petit apartĂ© ferme la plupart des sections, sous le titre « Sous le capot ». Il est lĂ  pour le moment, et ce moment viendra, oĂč une chose que ces frameworks font gratuitement cessera de ressembler Ă  de la magie pour ressembler Ă  une question. Vous pouvez tous les sauter et livrer malgrĂ© tout chaque fonctionnalitĂ© de ce livre. Ou en lire un, devenir curieux, et finir lĂ  oĂč vous ne vous attendiez pas : Ă  vous soucier, un peu, du moteur.

Ce qu’on vous a demandĂ© de construire attend. Tournez la page.

Comment lire ce livre

« Ajoutez un Ă©cran de connexion. » « Il nous faut un blog. » « La recherche doit rĂ©pondre instantanĂ©ment. » Chaque chapitre aprĂšs le premier est une demande de ce genre, une phrase qu’un client ou un product manager pourrait prononcer, jamais un morceau de syntaxe. Ouvrez le chapitre qu’on vous a commandĂ© et sautez le reste. Personne n’attend de vous que vous lisiez ce livre d’une traite.

Une personne attablĂ©e Ă  un cafĂ© lit un menu dont les lignes sont des icĂŽnes plutĂŽt que des mots : un cadenas, un panier, une loupe, une enveloppe. Un petit Ă©lĂ©phant en tablier de serveur attend, carnet Ă  la main. Le doigt de la personne s'arrĂȘte sur la ligne du cadenas

La forme d’un chapitre

Un chapitre s’ouvre sur une courte page qui pose la dĂ©cision : ce que la fonctionnalitĂ© implique vraiment, et les deux Ă  quatre Ă©cosystĂšmes capables de la livrer proprement. Chaque Ă©cosystĂšme a ensuite sa propre page, toujours en trois parties :

  • Ce que l’outil ou la plateforme fait pour vous, en un paragraphe.
  • Un exemple minimal qui fonctionne : la commande Ă  lancer ou le code Ă  Ă©crire.
  • Quand choisir cette option, et quand ce n’est pas le bon outil.

Les Ă©cosystĂšmes viennent Ă  peu prĂšs dans l’ordre, du « plus rapide vers une dĂ©mo » au « meilleur choix pour quelque chose qui doit durer ». Prenez cet ordre comme un repĂšre, pas comme un classement. Le bon choix dĂ©pend du budget de votre client, de la stack que votre Ă©quipe fait dĂ©jĂ  tourner, et du temps que la chose devra survivre une fois livrĂ©e.

Le marqueur $

L’essentiel de ce livre est du logiciel libre et gratuit. Quelques noms portent un $ dans leur titre : des produits payants ou des services en ligne, pas de l’open source. Ils sont lĂ  parce qu’ils sont souvent le chemin le plus rapide ou le plus fiable vers une fonctionnalitĂ© prĂ©cise, pas parce que quelqu’un a payĂ© pour figurer dans ces pages. Chaque option $ cĂŽtoie au moins une alternative libre dans le mĂȘme chapitre, pour que vous puissiez peser un abonnement contre votre propre temps.

Les encadrés « Sous le capot »

La plupart des pages se terminent par un court aparté de cette forme :

Sous le capot : une note d’un ou deux paragraphes sur la fonctionnalitĂ© du langage ou le comportement du moteur qui rend possible la facilitĂ© dĂ©crite juste au-dessus. Toujours facultative. Toujours sautable.

Vous livrerez tout ce que contient ce livre sans en ouvrir un seul. Ils existent pour le moment oĂč la curiositĂ© prendra le dessus, et pour ce moment-lĂ , l’annexe C les indexe tous, chapitre par chapitre.

Si le vocabulaire vous bloque

L’annexe B dĂ©finit les termes rĂ©currents de l’écosystĂšme (ORM, conteneur de services, hook, bundle, ressource) par ce qu’ils font pour vous, pas par leur dĂ©finition de manuel. Un terme inconnu est une raison d’y jeter un Ɠil, pas d’arrĂȘter de lire.

La premiÚre décision vient avant toute fonctionnalité : que construisez-vous, au juste ?

Choisir sa stack en cinq minutes

Avant de livrer la moindre fonctionnalitĂ©, une dĂ©cision conditionne tout le reste : quel genre de chose vous construisez, et ce qui existe dĂ©jĂ  pour faire l’essentiel du chemin. Prenez-la correctement et chaque chapitre suivant devient un menu dans lequel vous commandez. Ratez-la et vous passez six mois Ă  vous battre contre un outil qui n’a jamais Ă©tĂ© conçu pour ce que vous fabriquez.

Trois portes fermées, chacune marquée d'une icÎne : des engrenages, un crayon sur une page, une prise et sa fiche. Une personne lit une feuille de papier devant elles pendant qu'un petit éléphant désigne la porte du milieu

Ce chapitre est court, et c’est voulu. Il vous donne un guide de dĂ©cision, pas une religion, et un moyen d’avoir quelque chose qui tourne en moins d’une minute, pour sentir si le choix Ă©tait le bon avant d’y avoir passĂ© un aprĂšs-midi.

Framework, CMS ou headless : que construisez-vous, au juste ?

La plupart des cahiers des charges dĂ©crivent l’une de trois formes, que la personne qui les a rĂ©digĂ©s le sache ou non.

Il nous faut une application

Un systĂšme de rĂ©servation, un tableau de bord interne, une place de marchĂ© : quelque chose avec une logique propre, oĂč le comportement est le produit. C’est le territoire du framework. Laravel ou Symfony vous fournit le routage, une couche d’accĂšs aux donnĂ©es et un endroit oĂč poser votre logique, sans aucun avis sur ce que fait votre application. Cette partie-lĂ , vous l’écrivez.

Choisissez un framework quand la valeur du produit est le comportement sur mesure lui-mĂȘme, et qu’aucun outil sur Ă©tagĂšre ne fait dĂ©jĂ  ce que dĂ©crit le cahier des charges.

Il nous faut un site que les gens peuvent modifier

Un site vitrine, un blog, un portail de documentation, la plupart des sites de petites entreprises : la valeur, c’est le contenu, et des personnes non techniques vont l’ajouter, le corriger et le rĂ©organiser aprĂšs la mise en ligne. C’est le territoire du CMS. WordPress ou TYPO3 vous donne dĂšs le premier jour une interface d’édition, une structure de contenu et un Ă©cosystĂšme d’extensions, et vous n’écrivez jamais un panneau d’administration Ă  partir de zĂ©ro.

Choisissez un CMS quand la vraie demande du client est « et ensuite, l’équipe marketing doit pouvoir mettre ça Ă  jour toute seule ». C’est le cas de la plupart des briefs de contenu, qu’ils le disent ou non.

Il nous faut une API pour autre chose

Une application mobile, un front sĂ©parĂ©, le service d’une autre Ă©quipe : quelque chose qui alimente un consommateur, sans aucune page rendue cĂŽtĂ© serveur. C’est le territoire du headless. Un outil comme API Platform existe pour transformer un modĂšle de donnĂ©es en API documentĂ©e et versionnĂ©e, sans Ă©crire chaque endpoint Ă  la main.

Choisissez le headless quand vous savez déjà que le consommateur est un front JavaScript, une application mobile ou une autre équipe backend, et que toute page que vous rendriez finirait à la poubelle.

Quand le brief est les deux Ă  la fois

Beaucoup de projets rĂ©els cumulent deux formes : un site vitrine qui a aussi besoin d’un systĂšme de rĂ©servation, une application qui a aussi besoin d’une section de contenu Ă©ditable. Partez de la forme la plus proche de la valeur principale du projet, et greffez l’autre capacitĂ© ensuite. Un site WordPress avec une extension maison pour la logique de rĂ©servation se livre plus vite qu’une application Laravel qui rĂ©implĂ©mente un Ă©diteur de contenu. Une application Laravel avec une table posts et un Ă©cran d’administration simple se livre plus vite qu’une logique de rĂ©servation coincĂ©e dans des hooks WordPress.

Sous le capot : rien de tout cela ne concerne PHP lui-mĂȘme. Frameworks, CMS et outils d’API sont bĂątis sur les mĂȘmes briques du langage (un routeur qui fait correspondre une URL Ă  du code, un ORM qui transforme des lignes en objets), emballĂ©es autour d’une hypothĂšse diffĂ©rente sur qui utilisera le rĂ©sultat et sur la frĂ©quence Ă  laquelle le contenu change sans dĂ©ploiement.

Un premier projet en moins d’une minute

Lire la documentation d’une stack vous dit ce qu’elle promet. Lancer sa commande de crĂ©ation pendant soixante secondes vous dit ce qu’elle donne entre les mains. Voici le chemin le plus court vers chacune des options majeures de ce livre.

Laravel

composer create-project laravel/laravel my-app
cd my-app
php artisan serve

Une application qui tourne sur http://localhost:8000, avec le routage, une connexion à la base de données et un ORM déjà cùblés ensemble.

Symfony

composer create-project symfony/skeleton my-app
cd my-app
composer require webapp
symfony server:start

Le squelette démarre presque nu. composer require webapp ajoute Twig, le routage et le composant de formulaires, dont la plupart des sites finissent par avoir besoin de toute façon.

WordPress

wp core download --path=my-site
cd my-site
wp config create --dbname=my_site --dbuser=root --dbpass=
wp core install --url=localhost:8080 --title="My Site" --admin_user=admin --admin_password=admin [email protected]
php -S localhost:8080

Ou laissez la ligne de commande de cĂŽtĂ© et utilisez Local, qui enchaĂźne les mĂȘmes quatre Ă©tapes derriĂšre une interface graphique, en Ă  peu prĂšs le mĂȘme temps.

API Platform

composer create-project api-platform/api-platform my-api
cd my-api
docker compose up -d

Un squelette d’API qui tourne, avec une page de documentation OpenAPI interactive, prĂȘt pour le moment oĂč une seule classe PHP deviendra une API CRUD complĂšte.

Ce qu’il faut comparer

Pas le temps d’installation : toutes tiennent sous la minute. Comparez ce qui est dĂ©jĂ  dĂ©cidĂ© pour vous quand l’installation se termine. Laravel et Symfony vous tendent une application vide et beaucoup de libertĂ©. WordPress vous tend un site qui fonctionne et se modifie, sans rien de sur mesure dedans. API Platform vous tend une API vide et entiĂšrement documentĂ©e. Celle qui semble la plus proche de « terminĂ© » pour votre brief est en gĂ©nĂ©ral celle sur laquelle continuer.

Sous le capot : les quatre sont des projets Composer : le gestionnaire de paquets de PHP rĂ©sout un arbre de dĂ©pendances et gĂ©nĂšre un autoloader. WordPress fait exception. Il est antĂ©rieur Ă  la popularitĂ© de Composer et peut tourner sans lui, mĂȘme si le dĂ©veloppement WordPress d’aujourd’hui passe presque toujours par Composer pour les extensions et les dĂ©pendances.

Livrer sans framework : les composants autonomes

Un script d’import ponctuel n’a pas besoin de Laravel. Une tĂąche cron qui interroge trois API et rĂ©dige un rapport n’a pas besoin de Symfony. Parfois, le moyen le plus rapide de livrer, c’est un seul composer require pour la bibliothĂšque faite pour ce travail, et quarante lignes autour.

Un atelier oĂč une grosse machine dort sous une housse. Un petit Ă©lĂ©phant dĂ©croche une seule clĂ© Ă  molette d'un panneau d'outils et la tend Ă  une personne installĂ©e Ă  un petit Ă©tabli oĂč attend une piĂšce unique

Chaque paquet de ce chapitre tient debout tout seul : aucun framework dessous, rien Ă  configurer au-delĂ  de la seule chose qu’il fait. Plusieurs sont aussi les moteurs qui tournent Ă  l’intĂ©rieur des frameworks des chapitres suivants. Une fois que vous les avez utilisĂ©s seuls, les encadrĂ©s « Sous le capot » de la suite du livre n’ont plus grand-chose Ă  vous apprendre.

Outils en ligne de commande : Symfony/Console

La prochaine fois que vous lancerez composer require ou php artisan migrate, vous utiliserez le composant Console de Symfony. Composer et l’Artisan de Laravel sont tous deux construits dessus. Rien de tout cela n’exige le reste de Symfony. Console est un paquet autonome qui transforme une classe PHP en vĂ©ritable outil en ligne de commande, avec arguments, options, sortie en couleur et barres de progression, et rien d’autre attachĂ©.

composer require symfony/console
<?php
// bin/console
require __DIR__.'/../vendor/autoload.php';

use Symfony\Component\Console\Application;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

#[AsCommand(name: 'app:import-users', description: 'Import users from a CSV file')]
class ImportUsersCommand extends Command
{
    protected function configure(): void
    {
        $this->addArgument('file', InputArgument::REQUIRED, 'Path to the CSV file');
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $rows = array_map('str_getcsv', file($input->getArgument('file')));
        $output->writeln(sprintf('<info>Imported %d rows.</info>', count($rows)));

        return Command::SUCCESS;
    }
}

$app = new Application('My Tool', '1.0.0');
$app->add(new ImportUsersCommand());
$app->run();
php bin/console app:import-users users.csv

Quand le choisir

Tout travail que quelqu’un lance Ă  la main ou depuis une entrĂ©e cron : un import de donnĂ©es, un nettoyage, une Ă©tape de dĂ©ploiement. Il bat un script PHP brut dĂšs qu’il vous faut des arguments, des options, ou une sortie qu’un humain doit lire et Ă  laquelle il doit pouvoir se fier.

Quand ce n’est pas le bon outil

Si le « script » est le dĂ©but d’une application web, ou si vous ĂȘtes dĂ©jĂ  dans un projet Laravel ou Symfony, utilisez artisan ou le bin/console de l’application. Un second point d’entrĂ©e en ligne de commande Ă  cĂŽtĂ© du premier n’aide personne.

Sous le capot : une commande Console est une classe PHP ordinaire avec une mĂ©thode configure() et une mĂ©thode execute(). Pas de runtime spĂ©cial, pas de binaire compilĂ©, juste l’interprĂ©teur PHP que vous avez dĂ©jĂ , pointĂ© vers un script au lieu d’une requĂȘte de navigateur.

Parler à d’autres API : Guzzle

Presque toute fonctionnalitĂ© qui « parle Ă  un autre service » revient Ă  envoyer des requĂȘtes HTTP et Ă  traiter les rĂ©ponses. Guzzle est la façon par dĂ©faut de le faire en PHP depuis plus de dix ans, et il se comporte de la mĂȘme maniĂšre dans un framework et dans un script de quarante lignes.

composer require guzzlehttp/guzzle
<?php
require 'vendor/autoload.php';

use GuzzleHttp\Client;

$client = new Client(['base_uri' => 'https://api.example.com']);

$response = $client->get('/users/42', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('API_TOKEN')],
]);

$user = json_decode($response->getBody()->getContents(), true);
echo $user['name'];

Guzzle prend aussi en charge ce qui devient fastidieux Ă  Ă©crire soi-mĂȘme : les nouvelles tentatives, les dĂ©lais d’expiration, le streaming des grosses rĂ©ponses, et les requĂȘtes concurrentes qui ne s’attendent pas les unes les autres.

use GuzzleHttp\Promise\Utils;

$promises = [
    'users' => $client->getAsync('/users'),
    'orders' => $client->getAsync('/orders'),
];

$results = Utils::unwrap($promises);

Quand le choisir

Tout script ou service qui appelle une API tierce sans ĂȘtre dĂ©jĂ  dans un framework dotĂ© de son propre client HTTP. La façade Http de Laravel et le composant HttpClient de Symfony emballent les mĂȘmes idĂ©es, et l’un comme l’autre est un bon choix si vous y ĂȘtes dĂ©jĂ . Guzzle est la valeur sĂ»re quand vous ne savez pas encore Ă  quoi ressemblera le reste du projet.

Quand ce n’est pas le bon outil

Au fond d’un projet Laravel, Http::get(...) est Guzzle sous une syntaxe plus aimable. Il y a rarement une raison de le contourner pour appeler Guzzle directement.

Sous le capot : Guzzle et la plupart des clients HTTP en PHP parlent PSR-7 et PSR-18, des interfaces standard pour les messages et les clients HTTP. C’est pour cela que la façade Http de Laravel, le HttpClient de Symfony et Guzzle peuvent se passer des requĂȘtes et des rĂ©ponses sans qu’aucun ne sache que les autres existent.

Des templates sans framework : League/Plates

DĂšs qu’un script doit produire du HTML plutĂŽt qu’un bloc JSON ou une ligne de log, les echo mĂ©langĂ©s Ă  la logique deviennent illisibles Ă  toute vitesse. Plates est un moteur de templates Ă©crit en PHP pur : aucune syntaxe nouvelle, seulement des fichiers PHP avec des layouts, des sections et un Ă©chappement automatique, utilisables depuis n’importe quel script.

composer require league/plates
<?php
require 'vendor/autoload.php';

use League\Plates\Engine;

$templates = new Engine(__DIR__ . '/templates');

echo $templates->render('profile', ['name' => 'Ada']);
<?php // templates/layout.php ?>
<!doctype html>
<html>
<head><title><?= $this->e($title ?? 'My Site') ?></title></head>
<body>
    <?= $this->section('content') ?>
</body>
</html>
<?php // templates/profile.php ?>
<?php $this->layout('layout', ['title' => 'Profile']) ?>

<?php $this->start('content') ?>
    <h1>Hello, <?= $this->e($name) ?></h1>
<?php $this->stop() ?>

$this->e() Ă©chappe la sortie. C’est la mĂȘme protection que vous offrent Twig ou Blade, Ă©crite en toutes lettres au lieu d’ĂȘtre cachĂ©e derriĂšre une autre syntaxe.

Quand le choisir

Un petit outil interne, un gĂ©nĂ©rateur de rapports, ou un script qui rend une poignĂ©e de pages HTML et ne justifie pas toute la couche de templates d’un framework.

Quand ce n’est pas le bon outil

DĂšs qu’un projet accumule des composants, des inclusions et plus d’une poignĂ©e de pages. Le moteur du framework (Blade chez Laravel, Twig chez Symfony) gagne alors sa place avec la rĂ©utilisation de composants et la compilation des assets, des fonctionnalitĂ©s que Plates laisse volontairement de cĂŽtĂ© pour rester petit.

Sous le capot : les templates Plates sont des fichiers PHP, donc pas d’étape de compilation ni de cache de templates Ă  comprendre. Cette simplicitĂ© est toute la raison d’ĂȘtre de la bibliothĂšque, et c’est prĂ©cisĂ©ment ce que le moteur de templates d’un framework abandonne en Ă©change de fonctionnalitĂ©s supplĂ©mentaires.

Des logs qui marchent tout de suite : Monolog

Quand un script Ă©choue hors du navigateur, sans personne pour le regarder, une ligne de log est la seule trace qu’il laisse. Monolog est le logger que presque tous les frameworks PHP enveloppent : la façade Log de Laravel et le service logger de Symfony sont l’un comme l’autre Monolog avec une façade plus aimable. Utilisez-le directement et chaque projet, avec ou sans framework, se retrouve avec des logs de la mĂȘme forme.

composer require monolog/monolog
<?php
require 'vendor/autoload.php';

use Monolog\Level;
use Monolog\Logger;
use Monolog\Handler\StreamHandler;
use Monolog\Handler\RotatingFileHandler;

$log = new Logger('import-job');
$log->pushHandler(new StreamHandler('php://stdout', Level::Info));
$log->pushHandler(new RotatingFileHandler(__DIR__ . '/logs/import.log', 14, Level::Debug));

$log->info('Import started', ['file' => 'users.csv']);

try {
    // ... do the work ...
} catch (\Throwable $e) {
    $log->error('Import failed', ['exception' => $e]);
}

Un seul logger Ă©crit Ă  plusieurs endroits Ă  la fois : la console, un fichier avec rotation, un service comme Sentry (voir Attraper l’erreur en production). Chaque destination est un handler de plus.

Quand le choisir

Tout script ou service qui tourne hors d’un cycle requĂȘte-rĂ©ponse : un worker de file d’attente, une tĂąche cron, un import en ligne de commande. Si personne ne fixe le terminal quand il Ă©choue, il lui faut un log.

Quand ce n’est pas le bon outil

Dans Laravel ou Symfony, utilisez la façade Log ou le service logger du framework. C’est Monolog dessous, dĂ©jĂ  configurĂ© avec des handlers raisonnables, et cohĂ©rent avec la façon dont le reste de l’application journalise.

Sous le capot : Monolog implĂ©mente PSR-3, l’interface de journalisation standard qu’attendent la plupart des frameworks et bibliothĂšques PHP. C’est pour cela qu’une bibliothĂšque installĂ©e par composer require peut accepter « un logger » dans son constructeur sans se soucier de recevoir Monolog lui-mĂȘme ou l’enveloppe d’un framework autour.

Valider les entrées : Respect/Validation

Chaque formulaire, chaque charge utile d’API, chaque envoi de CSV pose la mĂȘme question : ces donnĂ©es sont-elles utilisables ? Respect/Validation y rĂ©pond avec des rĂšgles lisibles et chaĂźnables, sans avoir besoin du cycle de requĂȘte d’un framework autour.

composer require respect/validation
<?php
require 'vendor/autoload.php';

use Respect\Validation\Validator as v;

$validator = v::key('email', v::email())
    ->key('age', v::intVal()->between(18, 120))
    ->key('username', v::alnum()->length(3, 20));

try {
    $validator->assert([
        'email' => '[email protected]',
        'age' => 34,
        'username' => 'ada_l',
    ]);
    echo "Valid.\n";
} catch (\Respect\Validation\Exceptions\NestedValidationException $e) {
    foreach ($e->getMessages() as $message) {
        echo "- {$message}\n";
    }
}

Les rùgles se lisent presque comme de l’anglais et se combinent librement. v::stringType()->notEmpty()->length(1, 255) ou v::arrayType()->each(v::stringType()) couvrent l’essentiel des besoins d’un formulaire ou d’une API, sans rùgle sur mesure.

Quand le choisir

Un script ou un petit service qui reçoit des donnĂ©es de l’extĂ©rieur : un import CSV, un rĂ©cepteur de webhooks, une API lĂ©gĂšre. Tout un framework pour sa seule couche de validation serait disproportionnĂ©.

Quand ce n’est pas le bon outil

DĂšs que vous ĂȘtes dans Laravel ou Symfony. $request->validate() et le composant Validator de Symfony sont cĂąblĂ©s aux formulaires et Ă  l’affichage des erreurs de leur framework, et sont lĂ  le meilleur choix par dĂ©faut.

Sous le capot : les bibliothĂšques de validation s’appuient sur le systĂšme de types de PHP bien plus qu’autrefois. Sous les appels fluides comme v::intVal(), les versions rĂ©centes dĂ©crivent « valide » avec les types union et les enums de PHP plutĂŽt qu’en rĂ©inventant les vĂ©rifications de type.

Stocker des fichiers sans adopter un framework : League/Flysystem

Lire et Ă©crire des fichiers paraĂźt simple jusqu’à ce que « fichiers » signifie le disque local en dĂ©veloppement, S3 en production et du FTP pour un client entĂȘtĂ©. Flysystem est une abstraction de systĂšme de fichiers : vous codez contre une seule interface et vous choisissez dans la configuration oĂč vivent les fichiers. C’est aussi la bibliothĂšque derriĂšre la façade Storage de Laravel (voir Laravel : abstraction de systĂšme de fichiers et stockage compatible S3), disponible ici sans aucun framework attachĂ©.

composer require league/flysystem-aws-s3-v3
<?php
require 'vendor/autoload.php';

use League\Flysystem\Filesystem;
use League\Flysystem\AwsS3V3\AwsS3V3Adapter;
use Aws\S3\S3Client;

$client = new S3Client([
    'region' => 'us-east-1',
    'version' => 'latest',
]);

$adapter = new AwsS3V3Adapter($client, 'my-bucket');
$filesystem = new Filesystem($adapter);

$filesystem->write('reports/2026-09.csv', $csvContents);
$exists = $filesystem->fileExists('reports/2026-09.csv');
$filesystem->delete('reports/2025-01.csv');

Passer Ă  un disque local en dĂ©veloppement se fait en changeant l’adaptateur, une ligne :

use League\Flysystem\Local\LocalFilesystemAdapter;

$adapter = new LocalFilesystemAdapter(__DIR__ . '/storage');
$filesystem = new Filesystem($adapter);

Le reste du code, write(), fileExists(), delete(), ne bouge pas.

Quand le choisir

Un script, un worker ou un petit service qui lit ou Ă©crit des fichiers et doit se comporter de la mĂȘme façon en local et en production, sans « disque local » ni « S3 » codĂ©s en dur dans la logique mĂ©tier.

Quand ce n’est pas le bon outil

Dans Laravel, utilisez la façade Storage au lieu d’installer Flysystem Ă  part. Elle est dĂ©jĂ  lĂ , dĂ©jĂ  configurĂ©e par environnement, et c’est la mĂȘme bibliothĂšque avec une API plus aimable par-dessus.

Sous le capot : Flysystem dĂ©finit une petite interface (write, read, delete, fileExists et quelques autres) et laisse chaque adaptateur l’implĂ©menter comme le stockage sous-jacent le permet. C’est du polymorphisme par interface tout ce qu’il y a de plus ordinaire, la mĂȘme idĂ©e que derriĂšre les interfaces natives de PHP, appliquĂ©e Ă  un problĂšme que les dĂ©veloppeurs rencontrent assez souvent pour mĂ©riter une bibliothĂšque.

Livrer un site de contenu

Pages marketing, blogs, documentation, portfolios : la valeur, c’est le contenu, et quelqu’un de non technique le mettra Ă  jour aprĂšs la mise en ligne. Écrire une application sur mesure pour cela est presque toujours une erreur. Chaque option de ce chapitre existe pour que vous n’ayez jamais Ă  construire un Ă©diteur, un modĂšle de contenu ou un circuit de publication Ă  partir de zĂ©ro.

Une grande page épinglée au mur, découpée en blocs. Une personne déplace un bloc à deux mains vers un nouvel emplacement pendant qu'un petit éléphant tient une palette de peintre qui ne porte que trois couleurs

Les quatre options arbitrent différemment entre « une premiÚre page au plus vite » et « un site vaste, structuré ou fait pour durer ».

WordPress : thÚmes de blocs et éditeur de site

WordPress fait toujours tourner une large part du web de contenu, et le WordPress d’aujourd’hui n’est plus l’outil sur lequel sa rĂ©putation est restĂ©e figĂ©e. Avec les thĂšmes de blocs et l’éditeur de site, un client construit et rĂ©organise visuellement des mises en page entiĂšres, en-tĂȘtes et pieds de page compris, dans le mĂȘme Ă©diteur de blocs qu’il utilise dĂ©jĂ  pour ses articles. Les modifications de mise en page courantes ne demandent plus aucun fichier de template PHP.

wp core download --path=my-site
cd my-site
wp config create --dbname=my_site --dbuser=root --dbpass=
wp core install --url=localhost:8080 --title="My Site" --admin_user=admin --admin_password=admin [email protected]
wp theme install twentytwentyfive --activate

Votre travail, dans un thĂšme de blocs, tient surtout dans theme.json : la palette de couleurs, l’échelle d’espacements et la typographie parmi lesquelles le client peut choisir. Quoi qu’il rĂ©organise, le site reste dans la charte.

{
  "version": 2,
  "settings": {
    "color": {
      "palette": [
        { "slug": "brand-primary", "color": "#1d4ed8", "name": "Brand Primary" },
        { "slug": "brand-ink", "color": "#111827", "name": "Ink" }
      ]
    },
    "typography": {
      "fontSizes": [
        { "slug": "small", "size": "0.875rem", "name": "Small" },
        { "slug": "large", "size": "1.5rem", "name": "Large" }
      ]
    }
  }
}

Quand un client a besoin d’une chose que les blocs par dĂ©faut ne couvrent pas, un bloc sur mesure s’enregistre en PHP et peut tenir dans une seule fonction.

Quand le choisir

Sites vitrines, blogs et sites de petites entreprises, quand le client veut modifier le site lui-mĂȘme aprĂšs la mise en ligne, et quand l’écosystĂšme d’extensions (formulaires, SEO, cache) rĂ©sout les problĂšmes plus vite que vous ne les coderiez.

Quand ce n’est pas le bon outil

Un site qui est surtout de la logique applicative sur mesure, habillĂ©e d’une mince couche de contenu. Forcer cela dans le modĂšle de contenu de WordPress coĂ»te en gĂ©nĂ©ral plus de temps qu’il n’en fait gagner.

Sous le capot : un thĂšme de blocs stocke sa mise en page sous forme de HTML structurĂ© avec des commentaires de bloc (<!-- wp:heading -->), pas de balises de template PHP. Le PHP de WordPress rend ces blocs Ă  chaque requĂȘte, mais le format d’écriture reste volontairement proche du balisage brut, et c’est ce qui permet Ă  l’éditeur visuel de le relire sans se tromper.

TYPO3 : du contenu structurĂ© Ă  l’échelle d’une institution

Certains sites de contenu ne sont pas un blog et quelques pages. Ce sont quelques milliers de pages, une douzaine de services, six langues, et un circuit de validation avant que quoi que ce soit ne soit publié. TYPO3 est un CMS conçu pour cette échelle : un arbre de contenu, des permissions fines et une prise en charge du multilingue (voir Livrer du multilingue et du multisite) pensés dÚs le départ, pas greffés aprÚs coup.

composer create-project typo3/cms-base-distribution my-site
cd my-site
./vendor/bin/typo3 setup

Le contenu vit dans un arbre de pages. Chaque page se compose d’« Ă©lĂ©ments de contenu », des blocs structurĂ©s (texte, images, formulaire, plugin) que les rĂ©dacteurs agencent sans toucher au code. Quand le jeu fourni ne suffit pas, vous ajoutez un Ă©lĂ©ment sur mesure :

<?php
// Configuration/TCA/Overrides/tt_content.php
use TYPO3\CMS\Core\Utility\ExtensionManagementUtility;

ExtensionManagementUtility::addTcaSelectItem(
    'tt_content',
    'CType',
    ['label' => 'Team Member Card', 'value' => 'teammember_card'],
);

Les permissions se rĂšglent par page et par groupe d’utilisateurs. Un rĂ©dacteur rĂ©gional gĂšre la branche de son service dans l’arbre et ne peut toucher Ă  celle de personne d’autre.

Quand le choisir

Les grands sites institutionnels ou d’entreprise : universitĂ©s, administrations, multinationales. Le contenu appartient Ă  plusieurs Ă©quipes, et le circuit Ă©ditorial est une exigence, pas un confort.

Quand ce n’est pas le bon outil

Un site de petite entreprise ou un blog Ă  un seul rĂ©dacteur. La structure de TYPO3 fait toute sa valeur Ă  grande Ă©chelle et n’est que du poids mort en dessous. WordPress livre le mĂȘme rĂ©sultat plus vite pour un brief plus simple.

Sous le capot : le TCA de TYPO3 (Table Configuration Array) est un grand tableau PHP qui dĂ©crit le comportement de chaque type de contenu : ses champs, leur validation, leur rendu dans le backend. C’est de l’interface gĂ©nĂ©rĂ©e depuis des mĂ©tadonnĂ©es, le mĂȘme motif que l’administration d’API Platform, appliquĂ© Ă  du contenu Ă©ditorial plutĂŽt qu’à des ressources d’API.

Statamic ($ en usage commercial) : un CMS Ă  fichiers plats bĂąti sur Laravel

Statamic, c’est un Ă©diteur de contenu construit par un dĂ©veloppeur Laravel. Le contenu vit dans des fichiers Markdown et YAML plats, pas dans une base de donnĂ©es, et Git vous en donne l’historique pour rien. Dessous, c’est toujours une application Laravel : tout ce que vous savez de Laravel (voir Livrer des comptes utilisateurs, Livrer du travail en arriĂšre-plan) reste valable.

composer create-project statamic/statamic my-site
cd my-site
php please make:user
php artisan serve

Les types de contenu (« collections » et « blueprints » chez Statamic) se dĂ©finissent en YAML, et l’interface d’administration des rĂ©dacteurs en est gĂ©nĂ©rĂ©e :

# resources/blueprints/collections/posts/post.yaml
title: Post
sections:
  main:
    fields:
      - handle: title
        field: { type: text, required: true }
      - handle: content
        field: { type: markdown }
      - handle: featured_image
        field: { type: assets, container: images }

Les templates s’écrivent dans la syntaxe Antlers propre Ă  Statamic, ou en Blade standard. À vous de voir.

Licence

Gratuit pour un projet personnel, Statamic exige une licence payante par site dĂšs qu’il est commercial. L’évaluation ne coĂ»te rien ; la livraison Ă  un client est une ligne dans le budget.

Quand le choisir

Une Ă©quipe Ă  l’aise avec Laravel qui construit un site riche en contenu, veut son historique dans Git et se passerait bien d’une base de donnĂ©es pour ses pages.

Quand ce n’est pas le bon outil

Un client qui a prĂ©cisĂ©ment besoin de l’écosystĂšme d’extensions de WordPress, ou un projet trop petit pour que le coĂ»t de la licence ait un sens.

Sous le capot : avec du contenu en fichiers plats, Statamic tire sa performance des fonctions de systĂšme de fichiers de PHP et de sa couche de cache, pas de requĂȘtes SQL. Pour la plupart des sites de contenu, lire un fichier prĂ©-analysĂ© en cache vaut au moins un aller-retour vers la base, et git diff sert de journal d’audit en prime.

Craft CMS ($) : un CMS sous licence, pensé pour les rédactions

Craft part d’une hypothĂšse diffĂ©rente de celle de WordPress : il n’y a aucun modĂšle de contenu par dĂ©faut. Chaque projet dĂ©finit ses propres champs, types d’entrĂ©es et structure Ă  partir de zĂ©ro, avec l’éditeur de Craft comme couche visuelle. La premiĂšre heure est plus lente qu’avec WordPress. L’annĂ©e qui suit est plus rapide, pour les clients dont le contenu ne rentre pas dans un « article » gĂ©nĂ©rique.

composer create-project craftcms/craft my-site
cd my-site
php craft setup
php craft serve

Vous dĂ©finissez la structure du contenu dans l’interface d’administration de Craft (champs, sections, types d’entrĂ©es), puis vous l’interrogez dans des templates Twig :

{% for entry in craft.entries()
    .section('caseStudies')
    .client(currentClient)
    .all() %}
    <article>
        <h2>{{ entry.title }}</h2>
        {{ entry.summary }}
    </article>
{% endfor %}

Licence

Le cƓur de Craft est Ă  sources ouvertes : vous pouvez lire et modifier le code. L’exploiter commercialement exige une licence payante par projet. Un palier gratuit existe pour l’évaluer sur un site mono-utilisateur et non commercial.

Quand le choisir

Les agences qui construisent des sites éditoriaux sur mesure pour des clients aux besoins précis et au budget prévu pour la licence, qui préfÚrent un modÚle de contenu taillé pour eux à un modÚle générique étiré.

Quand ce n’est pas le bon outil

Un budget serrĂ©, un brief en forme de blog gĂ©nĂ©rique, ou un client qui veut la place de marchĂ© d’extensions de WordPress. L’écosystĂšme d’extensions de Craft existe, mais il est bien plus petit.

Sous le capot : le systĂšme de champs souple de Craft repose sur un schĂ©ma relationnel classique. L’accĂšs dynamique aux propriĂ©tĂ©s de PHP et le constructeur de requĂȘtes de Craft font que des structures de contenu trĂšs diffĂ©rentes se manipulent dans Twig comme des donnĂ©es typĂ©es, pas comme des tableaux.

Livrer des comptes utilisateurs

Inscription, connexion, « mot de passe oubliĂ© », et savoir qui regarde l’écran en ce moment : presque toute application en a besoin, et presque aucune ne devrait l’écrire Ă  partir de zĂ©ro. Le hachage des mots de passe, les sessions et la douzaine de petits dĂ©tails de sĂ©curitĂ© qui les entourent sont du code que vous voulez hĂ©riter d’un paquet bien entretenu, pas rĂ©inventer sous pression. Attaques temporelles, fixation de session, limitation de dĂ©bit : tout cela a Ă©tĂ© rĂ©solu avant que vous ne commenciez.

Un comptoir d'accueil oĂč un petit Ă©lĂ©phant coiffĂ© d'une casquette contrĂŽle le badge de la premiĂšre personne d'une courte file. DerriĂšre le comptoir, un tableau de clĂ©s et une porte marquĂ©e d'un cadenas

Laravel : Breeze, Fortify et Jetstream

Laravel apporte trois réponses officielles à « ajoutez une connexion », étagées selon ce que vous voulez recevoir tout fait.

Breeze installe des fichiers de vues et des contrĂŽleurs dans votre projet. Vous obtenez l’inscription, la connexion, la rĂ©initialisation du mot de passe et la vĂ©rification de l’e-mail, sous forme de code qui vous appartient et que vous pouvez modifier tout de suite.

composer require laravel/breeze --dev
php artisan breeze:install blade
npm install && npm run dev
php artisan migrate

Fortify implĂ©mente la mĂȘme logique d’authentification en paquet purement backend, sans aucune vue. Il est fait pour un front sur mesure ou pour une API.

composer require laravel/fortify
php artisan vendor:publish --provider="Laravel\Fortify\FortifyServiceProvider"
php artisan migrate

Jetstream s’appuie sur Fortify et ajoute une coquille d’application complĂšte : gestion d’équipes, jetons d’API, authentification Ă  deux facteurs, et un front au choix en Livewire ou en Inertia. Il vise les produits SaaS qui ont besoin de comptes et d’équipes dĂšs le premier jour.

composer require laravel/jetstream
php artisan jetstream:install livewire
npm install && npm run build
php artisan migrate

Lequel choisir

Breeze pour une application classique oĂč vous voulez voir et adapter le code d’authentification tout de suite. Fortify quand le front est Inertia, une application mobile ou du sur mesure qui n’a que faire des vues de Breeze. Jetstream quand le produit est multi-tenant ou organisĂ© par Ă©quipes et que vous bĂątiriez cette structure de toute façon.

Quand ce n’est pas le bon outil

Un site vitrine d’une page sans comptes utilisateurs, ou un projet oĂč les rĂŽles intĂ©grĂ©s de WordPress (voir WordPress : rĂŽles, capacitĂ©s et mots de passe d’application) couvrent dĂ©jĂ  le besoin sans ajouter de framework.

Sous le capot : les trois paquets s’appuient sur la façade Hash de Laravel, qui utilise par dĂ©faut bcrypt ou argon2id. Les deux algorithmes sont lents Ă  dessein, pour que la force brute sur des empreintes volĂ©es reste hors de portĂ©e. Vous n’appelez jamais de fonction de hachage ; le garde d’authentification le fait Ă  chaque connexion.

Symfony : le Security Bundle

Chez Symfony, l’authentification commence par la configuration. Vous dĂ©crivez en YAML comment les utilisateurs sont chargĂ©s, comment les mots de passe sont vĂ©rifiĂ©s et quelles routes exigent quel rĂŽle, et le framework l’applique Ă  chaque requĂȘte. La logique de contrĂŽle, vous ne l’écrivez jamais.

composer require symfony/security-bundle
# config/packages/security.yaml
security:
  password_hashers:
    App\Entity\User: 'auto'

  providers:
    app_user_provider:
      entity:
        class: App\Entity\User
        property: email

  firewalls:
    main:
      lazy: true
      provider: app_user_provider
      form_login:
        login_path: app_login
        check_path: app_login
      logout:
        path: app_logout

  access_control:
    - { path: ^/admin, roles: ROLE_ADMIN }
    - { path: ^/account, roles: ROLE_USER }

Le Maker Bundle gĂ©nĂšre l’entitĂ©, le formulaire et le contrĂŽleur correspondants en une commande :

composer require symfony/maker-bundle --dev
php bin/console make:user
php bin/console make:auth
php bin/console make:migration
php bin/console doctrine:migrations:migrate

Dans un contrÎleur, vérifier une permission tient en une ligne, pas dans un contrÎle manuel de la session :

class AdminController extends AbstractController
{
    #[IsGranted('ROLE_ADMIN')]
    public function dashboard(): Response
    {
        // only reachable by ROLE_ADMIN users; Symfony enforces it before this runs
    }
}

Quand le choisir

Toute application Symfony, sans vraie exception. Le Security Bundle est le chemin standard et auditĂ©. Bricoler une authentification par session Ă  cĂŽtĂ© ne ferait que ramener des bugs qu’il a dĂ©jĂ  corrigĂ©s.

Quand ce n’est pas le bon outil

Une application Symfony purement API, qui s’authentifie par jetons plutĂŽt que par sessions, utilise toujours le Security Bundle, avec un autre authentificateur (un authentificateur de jeton d’API Ă  la place de form_login). Moins un mauvais outil qu’une autre configuration du mĂȘme composant.

Sous le capot : #[IsGranted] est un attribut PHP 8, une mĂ©tadonnĂ©e accrochĂ©e Ă  la mĂ©thode et lue par Symfony Ă  l’exĂ©cution par rĂ©flexion. Le mĂȘme mĂ©canisme, attributs plus rĂ©flexion, permet Ă  une seule classe de piloter le routage, la validation et la sĂ©rialisation ailleurs dans le framework, sans fichiers de configuration rĂ©pĂ©titifs.

WordPress : rĂŽles, capacitĂ©s et mots de passe d’application

WordPress livre un systĂšme complet d’utilisateurs et de permissions depuis bien avant que « l’authentification en tant que service » ne soit une catĂ©gorie. Si le site est bĂąti sur WordPress, les comptes sont dĂ©jĂ  rĂ©glĂ©s, ce n’est pas une fonctionnalitĂ© Ă  ajouter.

Par dĂ©faut, WordPress fournit cinq rĂŽles : abonnĂ©, contributeur, auteur, Ă©diteur et administrateur. Chacun porte un jeu de capacitĂ©s (edit_posts, publish_posts, manage_options et des dizaines d’autres). Les Ă©crans d’inscription, de connexion et de rĂ©initialisation du mot de passe existent dĂ©jĂ  sous /wp-login.php.

Quand les rĂŽles par dĂ©faut ne correspondent pas Ă  l’équipe du client, des rĂŽles et des capacitĂ©s sur mesure tiennent en quelques lignes :

add_role('reviewer', 'Reviewer', [
    'read' => true,
    'edit_posts' => true,
    'publish_posts' => false,
]);

if (current_user_can('publish_posts')) {
    // show the publish button
}

En headless ou par API (une application mobile, un front dĂ©couplĂ© qui appelle l’API REST de WordPress), les mots de passe d’application donnent Ă  un utilisateur un identifiant Ă  portĂ©e limitĂ©e, sans exposer son vrai mot de passe :

curl -u "admin:xxxx xxxx xxxx xxxx xxxx xxxx" \
  https://example.com/wp-json/wp/v2/posts

Quand le choisir

Tout projet WordPress. RĂ©implĂ©menter l’authentification Ă  cĂŽtĂ© du cƓur, au lieu d’étendre ses rĂŽles, est du temps perdu et un risque de sĂ©curitĂ©.

Quand ce n’est pas le bon outil

Une installation headless qui veut une authentification par jetons (JWT, OAuth) plutît que des mots de passe d’application. Ce flux n’est pas dans le cƓur de WordPress et demande une extension, comme JWT Authentication.

Sous le capot : les capacitĂ©s de WordPress sont de simples chaĂźnes vĂ©rifiĂ©es par current_user_can(), stockĂ©es en donnĂ©es PHP sĂ©rialisĂ©es pour chaque rĂŽle dans la base. Il n’y a pas de moteur de permissions formel, et c’est ce qui rend l’ajout d’une capacitĂ© si facile : une chaĂźne dans un tableau, pas une migration de schĂ©ma.

Livrer un back-office

« On pourrait avoir un Ă©cran pour modifier les produits nous-mĂȘmes ? » TĂŽt ou tard, chaque application a besoin de cet Ă©cran : un endroit oĂč quelqu’un qui n’est pas dĂ©veloppeur corrige une fiche, valide une commande ou rĂ©pare une coquille dans une table de paramĂštres. Le construire formulaire par formulaire est l’une des façons les moins rentables de dĂ©penser un sprint. Le modĂšle de donnĂ©es que vous avez dĂ©jĂ  dĂ©crit suffit Ă  un outil pour gĂ©nĂ©rer cet Ă©cran.

Un petit éléphant glisse une seule feuille de papier dans une machine en forme de boßte munie d'une manivelle. De l'autre cÎté sort, sur un tapis roulant, un bureau complet avec ses tiroirs, un classeur, un formulaire et un tableau de lignes. Une personne, tasse de café à la main, le regarde arriver

Le choix dĂ©pend de ce qui dĂ©crit dĂ©jĂ  vos donnĂ©es : un modĂšle Eloquent, une entitĂ© Doctrine, une ressource d’API ou un type de contenu WordPress.

Laravel : Filament en un aprĂšs-midi

Pointez Filament sur un modĂšle Eloquent et il bĂątit la ressource d’administration autour : une liste avec recherche et filtres, un formulaire de crĂ©ation, un formulaire d’édition, des actions de suppression. Vous configurez une seule classe PHP, vous n’écrivez pas les Ă©crans.

composer require filament/filament
php artisan filament:install --panels
php artisan make:filament-resource Product --generate

La derniÚre commande inspecte la table products et pré-remplit une classe de ressource. Ce qui reste à écrire tient le plus souvent en une courte liste de champs :

use Filament\Forms\Components\TextInput;
use Filament\Forms\Components\Select;
use Filament\Tables\Columns\TextColumn;
use Filament\Tables\Columns\IconColumn;

class ProductResource extends Resource
{
    public static function form(Form $form): Form
    {
        return $form->schema([
            TextInput::make('name')->required(),
            TextInput::make('price')->numeric()->prefix('$'),
            Select::make('category_id')->relationship('category', 'name'),
        ]);
    }

    public static function table(Table $table): Table
    {
        return $table->columns([
            TextColumn::make('name')->searchable(),
            TextColumn::make('price')->money('usd'),
            IconColumn::make('is_active')->boolean(),
        ]);
    }
}

Vous obtenez un Ă©cran paginĂ©, triable, avec recherche, et des formulaires de crĂ©ation et d’édition validĂ©s. Pas une ligne de HTML, pas de contrĂŽleur.

Quand le choisir

Tout projet Laravel qui a besoin d’un Ă©cran d’administration interne et se satisfait de ce qu’un formulaire et un tableau dĂ©rivĂ©s du schĂ©ma savent exprimer. C’est le cas de la plupart des demandes de back-office.

Quand ce n’est pas le bon outil

Un tableau de bord destinĂ© aux clients, avec un design sur mesure. Un panneau gĂ©nĂ©rĂ© se bat contre ce genre de design au lieu de l’accĂ©lĂ©rer. Filament est fait pour les outils internes, pas pour les Ă©crans d’un produit.

Sous le capot : les constructeurs de formulaires et de tableaux de Filament sont des objets PHP fluides, chaßnables (TextInput::make(...)->required()->numeric()). Les arguments nommés et les énumérations natives rendent ce style agréable à écrire : un appel de méthode configure ce qui demandait autrefois plusieurs clés de tableau ou options de configuration.

Symfony : EasyAdmin et Sonata

Symfony a deux rĂ©ponses Ă©prouvĂ©es, taillĂ©es pour des tĂąches diffĂ©rentes. EasyAdmin vous donne un Ă©cran d’administration cette semaine ; Sonata est pour l’administration qui est elle-mĂȘme un produit.

EasyAdmin gĂ©nĂšre une interface CRUD propre Ă  partir d’une entitĂ© Doctrine, avec un minimum de configuration.

composer require easycorp/easyadmin-bundle
php bin/console make:admin:dashboard
php bin/console make:admin:crud
use EasyCorp\Bundle\EasyAdminBundle\Config\Crud;
use EasyCorp\Bundle\EasyAdminBundle\Field\TextField;
use EasyCorp\Bundle\EasyAdminBundle\Field\MoneyField;

class ProductCrudController extends AbstractCrudController
{
    public static function getEntityFqcn(): string
    {
        return Product::class;
    }

    public function configureFields(string $pageName): iterable
    {
        yield TextField::new('name');
        yield MoneyField::new('price')->setCurrency('USD');
        yield AssociationField::new('category');
    }
}

Sonata Admin est plus lourd, plus ancien et plus extensible. Il demande davantage de configuration au dĂ©part et, en Ă©change, il encaisse des rĂšgles de permissions complexes, des administrations imbriquĂ©es et des workflows pour lesquels EasyAdmin n’a jamais Ă©tĂ© conçu.

Lequel choisir

EasyAdmin pour la plupart des outils internes : rapide Ă  installer, facile Ă  lire, suffisant pour tout ce qui a la forme d’un CRUD. Sonata quand l’administration porte des permissions complexes ou des relations profondĂ©ment imbriquĂ©es, et qu’il lui faut plus de structure que le modĂšle simple d’EasyAdmin.

Quand ce n’est pas le bon outil

Un tableau de bord public, destinĂ© aux clients : mĂȘme rĂ©serve que pour Filament. Les deux outils sont faits pour des utilisateurs internes de confiance.

Sous le capot : les deux bundles lisent les mĂ©tadonnĂ©es des entitĂ©s Doctrine (les mĂȘmes attributs qui dĂ©finissent votre schĂ©ma de base de donnĂ©es) pour dĂ©duire le type des champs. Une colonne price typĂ©e decimal dans votre entitĂ© devient un champ numĂ©rique dans l’administration sans dĂ©claration supplĂ©mentaire, parce que le framework connaĂźt dĂ©jĂ  le type.

API Platform : une administration générée depuis votre API

Si vous construisez avec API Platform (voir Livrer une API que d’autres Ă©quipes peuvent utiliser), vos donnĂ©es sont dĂ©jĂ  dĂ©crites assez prĂ©cisĂ©ment pour une administration. Le panneau lit le schĂ©ma de l’API elle-mĂȘme, il n’y a donc aucun code d’administration Ă  Ă©crire.

Prenez une ressource dĂ©jĂ  exposĂ©e par l’API :

#[ApiResource]
class Product
{
    public ?int $id = null;

    #[ApiProperty(description: 'The product name')]
    public string $name;

    public float $price;

    #[ApiProperty]
    public ?Category $category = null;
}

Le paquet d’administration d’API Platform lit le schĂ©ma OpenAPI et affiche par-dessus une interface React (liste, crĂ©ation, Ă©dition, suppression) :

npm install @api-platform/admin
// src/App.js
import { HydraAdmin } from '@api-platform/admin';

export default () => <HydraAdmin entrypoint="https://api.example.com" />;

Aucune configuration champ par champ n’est nĂ©cessaire pour obtenir un panneau qui fonctionne. Vous n’en ajoutez que lĂ  oĂč un dĂ©faut doit ĂȘtre remplacĂ©, par exemple un composant personnalisĂ© pour un champ.

Quand le choisir

Tout projet dĂ©jĂ  bĂąti sur un backend API Platform. À ce stade, le panneau est presque gratuit : il lit des mĂ©tadonnĂ©es que vous avez produites pour la documentation de l’API, au lieu de vous demander de dĂ©crire le modĂšle de donnĂ©es une deuxiĂšme fois.

Quand ce n’est pas le bon outil

Un projet sans couche API. Monter une API rien que pour ce gĂ©nĂ©rateur est un dĂ©tour, alors que Filament ou EasyAdmin produiraient le mĂȘme panneau directement depuis la base de donnĂ©es.

Sous le capot : API Platform gĂ©nĂšre une description lisible par machine de votre API, en OpenAPI et en Hydra/JSON-LD, Ă  partir des attributs PHP posĂ©s sur vos classes. Le panneau d’administration est un client gĂ©nĂ©rique qui sait afficher une interface pour n’importe quelle API dĂ©crite ainsi, pas un programme Ă©crit pour votre projet.

WordPress : types de contenu personnalisés et ACF comme moteur CRUD

Membres de l’équipe, Ă©tudes de cas, fiches produits : un client sous WordPress a souvent besoin de gĂ©rer quelque chose qui n’est pas du tout un article de blog. L’administration de WordPress n’a pas Ă©tĂ© pensĂ©e comme un gĂ©nĂ©rateur de CRUD, mais les Custom Post Types alliĂ©s Ă  Advanced Custom Fields (ACF) finissent par en faire office. Un Ă©cran de gestion pour un nouveau type de contenu, c’est un appel d’enregistrement, pas une nouvelle administration.

add_action('init', function () {
    register_post_type('team_member', [
        'label' => 'Team Members',
        'public' => true,
        'show_in_rest' => true,
        'menu_icon' => 'dashicons-groups',
        'supports' => ['title', 'thumbnail'],
    ]);
});

Cela seul ajoute un Ă©cran de liste dans le menu de l’administration, avec recherche, actions groupĂ©es et pagination. ACF y ajoute ensuite des champs structurĂ©s, depuis son constructeur visuel ou depuis le code :

acf_add_local_field_group([
    'key' => 'group_team_member',
    'title' => 'Team Member Details',
    'fields' => [
        ['key' => 'field_role', 'label' => 'Role', 'name' => 'role', 'type' => 'text'],
        ['key' => 'field_linkedin', 'label' => 'LinkedIn', 'name' => 'linkedin', 'type' => 'url'],
    ],
    'location' => [[['param' => 'post_type', 'operator' => '==', 'value' => 'team_member']]],
]);

RĂ©sultat : une interface complĂšte de crĂ©ation, d’édition, de liste et de suppression pour les membres de l’équipe, construite par configuration. Le drapeau show_in_rest l’expose en prime dans l’API REST de WordPress.

Quand le choisir

Un site WordPress qui doit gĂ©rer un deuxiĂšme type de contenu structurĂ©, au-delĂ  des articles et des pages, pour un client dĂ©jĂ  Ă  l’aise dans l’administration de WordPress.

Quand ce n’est pas le bon outil

Des données relationnelles avec des relations plusieurs-à-plusieurs et une logique métier lourde. Le modÚle fondé sur les posts se plie loin, mais il reste un modÚle de contenu, pas une administration de base relationnelle.

Sous le capot : les Custom Post Types ne crĂ©ent aucune table. Chaque type, post, page ou votre team_member, est une ligne de la mĂȘme table wp_posts, distinguĂ©e par une colonne post_type. C’est pour cela qu’enregistrer un nouveau type de contenu tient en un appel de fonction et non en une migration.

Laravel Nova ($) : l’alternative officielle à Filament

Nova est le panneau d’administration construit et maintenu par l’équipe de Laravel elle-mĂȘme. FonctionnalitĂ© pour fonctionnalitĂ©, il recouvre largement Filament : ressources gĂ©nĂ©rĂ©es depuis les modĂšles Eloquent, tableaux avec recherche et filtres, champs et actions personnalisĂ©s. La diffĂ©rence, c’est qui rĂ©pond quand quelque chose casse ou quand une nouvelle version de Laravel sort.

composer require laravel/nova
php artisan nova:install
php artisan make:nova-resource Product
class Product extends Resource
{
    public function fields(NovaRequest $request): array
    {
        return [
            ID::make()->sortable(),
            Text::make('Name')->sortable()->rules('required', 'max:255'),
            Currency::make('Price'),
            BelongsTo::make('Category'),
        ];
    }
}

Licence

Nova se vend par dĂ©veloppeur ou par site, sans offre gratuite pour un usage commercial. En Ă©change, vous avez des canaux de support officiels, la compatibilitĂ© avec chaque nouvelle version de Laravel le jour de sa sortie, et une feuille de route dĂ©cidĂ©e par l’équipe qui Ă©crit le framework.

Quand le choisir

Les Ă©quipes ou les agences qui veulent un contrat de support derriĂšre leur administration, ou qui paient dĂ©jĂ  d’autres produits Laravel (Forge, Vapor, voir Livrer en production) et veulent un seul fournisseur responsable de toute la stack.

Quand ce n’est pas le bon outil

Un budget serrĂ©, ou une Ă©quipe qui se satisfait de la communautĂ© open source de Filament. Vu de l’extĂ©rieur, la plupart des projets ne distinguent pas les deux panneaux.

Sous le capot : ĂȘtre un produit payant ne change rien Ă  la façon dont Nova s’intĂšgre Ă  Laravel. Il s’installe par Composer comme n’importe quel paquet, avec le mĂȘme service provider et le mĂȘme mĂ©canisme de dĂ©couverte que les paquets gratuits. La licence est une dĂ©cision commerciale posĂ©e sur une architecture de paquet PHP tout Ă  fait ordinaire.

Livrer une API que d’autres Ă©quipes peuvent utiliser

« L’équipe mobile doit pouvoir lire nos donnĂ©es d’ici le prochain sprint. » Quelqu’un finit toujours par vouloir parler Ă  vos donnĂ©es : une application mobile, le systĂšme d’un partenaire, un front construit par une autre Ă©quipe. Cela veut dire des endpoints, de la validation des requĂȘtes, des rĂ©ponses d’erreur cohĂ©rentes et une documentation qui ne se pĂ©rime pas Ă  la premiĂšre modification du code. Écrire tout cela Ă  la main pour chaque ressource, c’est prĂ©cisĂ©ment le travail rĂ©pĂ©titif que l’outillage PHP existe pour supprimer.

Un guichet percé dans un mur. DerriÚre, un petit éléphant devant des étagÚres de boßtes étiquetées tend un colis. Dans la file d'attente, un smartphone, un ordinateur portable et un petit robot. Un panneau avec une liste d'icÎnes est punaisé à cÎté du guichet

La décision porte sur ce que vous voulez voir généré pour vous, et ce que vous préférez garder explicite.

API Platform : une API complùte à partir d’une classe PHP

Tout l’argumentaire d’API Platform tient dans un exemple. Une classe et un attribut donnent une API complĂšte et documentĂ©e.

<?php

namespace App\Entity;

use ApiPlatform\Metadata\ApiResource;
use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity]
#[ApiResource]
class Product
{
    #[ORM\Id, ORM\GeneratedValue, ORM\Column]
    public ?int $id = null;

    #[ORM\Column(length: 255)]
    public string $name;

    #[ORM\Column]
    public float $price;
}

C’est tout. Sans une ligne de plus, vous obtenez :

  • GET /api/products et GET /api/products/{id}
  • POST /api/products, PUT et DELETE, avec validation des requĂȘtes
  • une page de documentation interactive OpenAPI/Swagger sur /api/docs
  • un endpoint GraphQL sur /api/graphql, si le paquet GraphQL est installĂ©

Restreindre les opĂ©rations ou ajouter des filtres se fait par configuration sur le mĂȘme attribut, pas par un nouveau contrĂŽleur :

#[ApiResource(
    operations: [new GetCollection(), new Get(), new Post(security: 'is_granted("ROLE_ADMIN")')],
)]
#[ApiFilter(SearchFilter::class, properties: ['name' => 'partial'])]
class Product
{
    // ...
}

Quand le choisir

Un projet oĂč l’API est le produit, ou un modĂšle de donnĂ©es qui bouge encore assez vite pour que maintenir Ă  la main les contrĂŽleurs, les sĂ©rialiseurs et la documentation Ă  chaque changement vous ralentisse.

Quand ce n’est pas le bon outil

Une API Ă  un ou deux endpoints, sans perspective de croissance. LĂ , les conventions et la mise en place d’API Platform coĂ»tent plus cher que deux mĂ©thodes de contrĂŽleur.

Sous le capot : les attributs PHP se lisent Ă  l’exĂ©cution par rĂ©flexion. API Platform inspecte votre classe, ses propriĂ©tĂ©s et leurs types, puis gĂ©nĂšre le routage, la validation et le schĂ©ma OpenAPI depuis cette source unique de vĂ©ritĂ©, au lieu de trois sources sĂ©parĂ©es.

Laravel : Sanctum, Resources et versions d’API

L’approche par dĂ©faut de Laravel est plus manuelle que celle d’API Platform, et c’est souvent voulu. Routes, contrĂŽleurs et formes de rĂ©ponse restent explicites, au prix d’un peu plus de code par endpoint.

Sanctum gùre l’authentification des clients SPA et mobiles (par session) et celle des consommateurs tiers (par jeton), depuis un seul paquet.

composer require laravel/sanctum
php artisan vendor:publish --provider="Laravel\Sanctum\SanctumServiceProvider"
php artisan migrate
// issuing a token
$token = $user->createToken('mobile-app')->plainTextToken;

// protecting a route
Route::middleware('auth:sanctum')->get('/api/user', fn (Request $r) => $r->user());

Les API Resources donnent Ă  un modĂšle une forme JSON stable. Vos colonnes de base de donnĂ©es et votre contrat public cessent d’ĂȘtre la mĂȘme chose :

class ProductResource extends JsonResource
{
    public function toArray(Request $request): array
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'price_usd' => number_format($this->price, 2),
        ];
    }
}

// in a controller
return ProductResource::collection(Product::paginate());

Le versionnement est le plus souvent un préfixe de route, et délibérément rien de plus :

Route::prefix('v1')->group(base_path('routes/api_v1.php'));
Route::prefix('v2')->group(base_path('routes/api_v2.php'));

Quand le choisir

Le choix par dĂ©faut pour un projet Laravel qui expose une API Ă  cĂŽtĂ© d’une application web, ou pour une API autonome de taille petite Ă  moyenne oĂč le contrĂŽle de chaque forme de rĂ©ponse compte plus que la gĂ©nĂ©ration.

Quand ce n’est pas le bon outil

Un gros modĂšle de donnĂ©es qui Ă©volue vite, oĂč une classe Resource Ă©crite Ă  la main par modĂšle devient de la maintenance. C’est le cas pour lequel API Platform est fait.

Sous le capot : Sanctum stocke les jetons d’API hachĂ©s, comme des mots de passe, mais avec la fonction hash() de PHP plutĂŽt qu’avec password_hash(). Un jeton est une chaĂźne alĂ©atoire Ă  forte entropie, pas un mot de passe choisi par un humain, et un hachage rapide suffit donc Ă  le protĂ©ger.

WordPress : l’API REST intĂ©grĂ©e

Toute installation WordPress Ă  jour expose dĂ©jĂ  une API REST, sans extension ni configuration. Les articles, les pages, les mĂ©dias, les utilisateurs et tout type de contenu marquĂ© show_in_rest s’interrogent tout de suite :

curl https://example.com/wp-json/wp/v2/posts
curl https://example.com/wp-json/wp/v2/posts/42
curl "https://example.com/wp-json/wp/v2/posts?search=laravel&per_page=5"

L’éditeur de blocs lui-mĂȘme tourne sur cette API. Elle est sollicitĂ©e Ă  chaque modification de chaque site WordPress ; ce n’est pas un ajout tardif pour les consommateurs externes.

Les types de contenu personnalisés y entrent avec un seul drapeau (voir Types de contenu personnalisés et ACF comme moteur CRUD) :

register_post_type('case_study', [
    'public' => true,
    'show_in_rest' => true,
]);

Un endpoint sur mesure, pour tout ce qui ne ressemble ni Ă  un article ni Ă  une page, tient en quelques lignes :

add_action('rest_api_init', function () {
    register_rest_route('myapp/v1', '/stats', [
        'methods' => 'GET',
        'callback' => function () {
            return ['total_posts' => wp_count_posts()->publish];
        },
        'permission_callback' => '__return_true',
    ]);
});

Les Ă©critures (POST, PUT, DELETE) exigent une authentification : les mots de passe d’application entre serveurs, ou une extension qui ajoute OAuth ou JWT pour des applications clientes tierces.

Quand le choisir

Une architecture headless oĂč WordPress sert de backend de contenu Ă  un front sĂ©parĂ© (une application JavaScript, une application mobile), ou toute intĂ©gration qui doit lire du contenu WordPress existant par programme.

Quand ce n’est pas le bon outil

Un modÚle de données qui ne ressemble en rien à des articles, des pages ou un type de contenu personnalisé. Vous vous battez alors contre une API en forme de contenu, et un outil spécialisé (API Platform, Laravel) convient mieux.

Sous le capot : le routage et la mise en forme des rĂ©ponses de l’API REST reposent sur les hooks et les filtres de WordPress, le mĂȘme couple add_action/add_filter qui fait vivre les thĂšmes et les extensions. Il n’y a pas de framework d’API sĂ©parĂ© en dessous : c’est le mĂ©canisme d’extension que WordPress utilise depuis 2004, orientĂ© vers du JSON au lieu du HTML.

Livrer du temps réel

Une notification qui apparaĂźt d’elle-mĂȘme, un point de prĂ©sence, un widget de chat, un chiffre de tableau de bord qui se met Ă  jour seul : la page sait qu’il s’est passĂ© quelque chose, et personne n’a rechargĂ©. Le modĂšle requĂȘte-rĂ©ponse de PHP ne garde pas naturellement une connexion ouverte pour pousser des mises Ă  jour. L’écosystĂšme a comblĂ© ce vide de plusieurs cĂŽtĂ©s, et la question est de savoir si vous faites tourner le serveur de push vous-mĂȘme ou si vous confiez ce travail Ă  quelqu’un d’autre.

Un petit Ă©lĂ©phant assis Ă  un standard tĂ©lĂ©phonique branche un cĂąble. Des fils courent jusqu'Ă  quatre fenĂȘtres oĂč quatre personnes regardent des Ă©crans qui s'allument tous au mĂȘme instant, sans que personne ne les touche

Laravel : Reverb et Livewire, sans écrire de JavaScript

Reverb est le serveur WebSocket de Laravel, auto-hĂ©bergĂ© et gratuit. Il se branche sur le systĂšme de diffusion d’évĂ©nements dĂ©jĂ  prĂ©sent dans Laravel, et le service tiers devient facultatif.

composer require laravel/reverb
php artisan reverb:install
php artisan reverb:start
// broadcasting an event from anywhere in the app
broadcast(new OrderShipped($order))->toOthers();

// the event class
class OrderShipped implements ShouldBroadcast
{
    public function __construct(public Order $order) {}

    public function broadcastOn(): Channel
    {
        return new PrivateChannel('orders.' . $this->order->user_id);
    }
}

AssociĂ© Ă  Livewire, le front n’a souvent besoin d’aucun JavaScript. Un composant Livewire Ă©coute l’évĂ©nement diffusĂ© et se rĂ©affiche de lui-mĂȘme :

class OrderStatus extends Component
{
    public Order $order;

    #[On('echo-private:orders.{order.user_id},OrderShipped')]
    public function refreshStatus(): void
    {
        $this->order->refresh();
    }

    public function render()
    {
        return view('livewire.order-status');
    }
}

Le template Blade affiche $order->status, rien d’autre. Quand l’évĂ©nement arrive, Livewire rĂ©affiche ce fragment par la connexion WebSocket, sans le moindre Ă©tat client Ă©crit Ă  la main.

Quand le choisir

Un projet Laravel qui veut des notifications, des statuts en direct ou un chat simple sans adopter un framework front séparé ni payer un service de WebSockets.

Quand ce n’est pas le bon outil

Un front chargĂ© en JavaScript (un Ă©diteur sur canvas, une application monopage complexe), oĂč l’aller-retour serveur de Livewire ajoute une latence qu’un framework cĂŽtĂ© client n’aurait pas. Reverb reste utilisable comme transport. C’est Livewire qu’il faut reconsidĂ©rer.

Sous le capot : Reverb repose sur les Fibers de PHP, arrivĂ©es avec PHP 8.1. Un seul processus PHP peut tenir de nombreuses connexions ouvertes et passer de l’une Ă  l’autre de façon coopĂ©rative au lieu de bloquer. C’est ce qui rend un serveur WebSocket persistant praticable en PHP, un travail pour lequel le modĂšle d’un processus par requĂȘte n’a jamais Ă©tĂ© fait.

Symfony : UX Turbo et Mercure

Le temps rĂ©el de Symfony repose sur Mercure, un protocole ouvert et non une invention maison. Les mises Ă  jour arrivent au navigateur en HTTP ordinaire, sous forme de Server-Sent Events, et n’importe quel client peut s’y abonner, pas seulement un front Symfony.

composer require symfony/mercure-bundle
# Mercure hub runs as a small standalone binary, or via Docker
use Symfony\Component\Mercure\HubInterface;
use Symfony\Component\Mercure\Update;

class OrderController
{
    public function ship(Order $order, HubInterface $hub): Response
    {
        $order->markShipped();

        $hub->publish(new Update(
            "orders/{$order->getId()}",
            json_encode(['status' => 'shipped']),
        ));

        return new Response('OK');
    }
}

Turbo, par le paquet symfony/ux-turbo, abonne la page à cette mise à jour et remplace le fragment HTML concerné. Un attribut de données tient lieu de JavaScript écrit à la main :

<turbo-stream-source src="{{ mercure('orders/' ~ order.id) }}"></turbo-stream-source>

<div id="order-{{ order.id }}-status">
    {{ order.status }}
</div>

Quand le serveur diffuse une mise à jour Turbo Stream correspondante, Turbo remplace ce <div> sur place. Pas de rechargement, pas de code client à écrire.

Quand le choisir

Un projet Symfony qui veut des mises Ă  jour en direct sans framework JavaScript sĂ©parĂ©, et en particulier un projet oĂč un protocole ouvert, fondĂ© sur HTTP, compte pour des raisons d’infrastructure ou de conformitĂ©.

Quand ce n’est pas le bon outil

Un trafic bidirectionnel à haute fréquence : une interaction multijoueur en direct, un tableau de bord de trading rafraßchi plusieurs fois par seconde. Les Server-Sent Events ne vont que dans un sens, par conception, et une connexion WebSocket convient mieux à ce travail.

Sous le capot : les Server-Sent Events sont une fonctionnalitĂ© HTTP ordinaire : une rĂ©ponse longue qui continue d’envoyer des morceaux au fil du temps. Mercure bĂątit un hub complet de publication et d’abonnement sur cette seule primitive, et c’est pourquoi il traverse l’infrastructure HTTP habituelle (proxies, rĂ©partiteurs de charge) lĂ  oĂč un WebSocket brut rĂ©clame parfois une configuration Ă  part.

Nextcloud Talk : le temps rĂ©el au sein d’une plateforme

Nextcloud Talk est un systĂšme de chat et de visioconfĂ©rence en production Ă  grande Ă©chelle, construit comme une application Ă  l’intĂ©rieur d’une application PHP plutĂŽt que comme un produit parti de zĂ©ro. Vous ne toucherez peut-ĂȘtre jamais au code de Nextcloud, et il a quand mĂȘme quelque chose Ă  vous apprendre. « PHP ne sait pas faire de temps rĂ©el » n’a jamais Ă©tĂ© vrai ; tout l’art est de savoir ce qu’on garde dans PHP et ce qu’on dĂ©lĂšgue.

Talk s’installe comme une application dans n’importe quelle instance Nextcloud :

php occ app:install spreed
php occ app:enable spreed

Pour le chat, Talk s’appuie sur les mĂȘmes techniques de polling et de Server-Sent Events que le reste de ce chapitre. Pour les appels audio et vidĂ©o Ă  grande Ă©chelle, il passe la main Ă  un High-Performance Backend, un serveur de signalisation sĂ©parĂ©, au lieu de forcer les flux mĂ©dia dans le cycle de requĂȘte de PHP :

php occ talk:signaling:add wss://signaling.example.com "shared-secret-here"

Ce dĂ©coupage est le modĂšle Ă  emprunter. PHP possĂšde les comptes, les permissions et l’historique des conversations. Un service spĂ©cialisĂ© possĂšde le flux mĂ©dia.

Quand le choisir

Pas comme un paquet Ă  installer dans votre propre projet, mais comme une architecture de rĂ©fĂ©rence le jour oĂč votre fonctionnalitĂ© temps rĂ©el se met Ă  vouloir de la vidĂ©o ou de l’audio, et plus seulement des donnĂ©es : gardez PHP comme source de vĂ©ritĂ© pour les comptes et les permissions, et dĂ©lĂ©guez le transport mĂ©dia Ă  un service conçu pour ça.

Quand ce n’est pas le bon outil

Si la question est d’auto-hĂ©berger Nextcloud pour votre organisation (voir Livrer du stockage de fichiers et de la collaboration), Talk est l’une des applications livrĂ©es avec, pas une dĂ©cision Ă  part.

Sous le capot : le systĂšme d’applications de Nextcloud permet d’installer, de mettre Ă  jour et de dĂ©sactiver une fonctionnalitĂ© comme Talk indĂ©pendamment du cƓur, en s’appuyant sur les conventions de paquets et d’autoloading propres Ă  PHP. C’est la mĂȘme intuition que les extensions WordPress ou les bundles Symfony : un cƓur stable, et des fonctionnalitĂ©s posĂ©es par-dessus en unitĂ©s distinctes et interchangeables.

Pusher ($) : des WebSockets gérés, sans serveur à faire tourner

Pusher fait une seule chose : il fait tourner l’infrastructure WebSocket Ă  votre place. Une fonctionnalitĂ© qui exigerait Reverb ou Mercure comme service Ă  exploiter devient un appel d’API et un paquet npm.

composer require pusher/pusher-php-server
$pusher = new Pusher\Pusher(
    getenv('PUSHER_KEY'),
    getenv('PUSHER_SECRET'),
    getenv('PUSHER_APP_ID'),
    ['cluster' => 'us2', 'useTLS' => true],
);

$pusher->trigger('orders-channel', 'order.shipped', [
    'order_id' => $order->id,
    'status' => 'shipped',
]);

Le systĂšme de diffusion de Laravel a Ă©tĂ© conçu avec Pusher pour cible d’origine, et il se substitue toujours Ă  Reverb avec les mĂȘmes classes d’évĂ©nements et le mĂȘme appel broadcast(). Seule une valeur de configuration change :

# .env
BROADCAST_CONNECTION=pusher

Tarif

Pusher facture au nombre de connexions simultanĂ©es et de messages par jour. L’offre gratuite couvre le dĂ©veloppement et les petites applications en production ; au-delĂ , la facture mensuelle suit le trafic.

Quand le choisir

Une Ă©quipe qui ne veut pas du tout exploiter d’infrastructure WebSocket, ou un projet dont le trafic est assez imprĂ©visible pour qu’une couche de connexions gĂ©rĂ©e et auto-dimensionnĂ©e batte l’auto-hĂ©bergement de Reverb ou d’un hub Mercure.

Quand ce n’est pas le bon outil

Un trafic temps réel modeste et prévisible. Reverb et Mercure sont gratuits, auto-hébergés, et ne coûtent rien de plus que le serveur que vous faites probablement déjà tourner.

Sous le capot : l’abstraction de diffusion de Laravel ayant Ă©tĂ© dessinĂ©e sur la forme de l’API de Pusher, remplacer Pusher par Reverb est un changement de configuration, pas de code. La leçon se gĂ©nĂ©ralise : une bonne abstraction est ce qui fait de « l’hĂ©berger soi-mĂȘme » contre « payer quelqu’un pour le faire » une dĂ©cision qu’on peut repousser, ou inverser, sans réécriture.

Livrer du stockage de fichiers et de la collaboration

« Il nous faudrait notre propre Dropbox. » Envois de fichiers, liens de partage, permissions par dossier, historique des versions : la demande revient plus souvent que son ampleur ne le laisse croire, et la rĂ©ponse honnĂȘte est rarement de construire un Dropbox. Soit une plateforme toute faite est le bon choix, soit la demande se rĂ©sume Ă  des envois de fichiers dans une application existante.

Un grand classeur Ă  tiroirs, deux tiroirs fermĂ©s par un cadenas. Un petit Ă©lĂ©phant tend un dossier par une fenĂȘtre Ă  un ordinateur portable, un tĂ©lĂ©phone et un ordinateur de bureau. Au-dessus, un nuage contient le mĂȘme dossier, reliĂ© au classeur par une ligne pointillĂ©e

Nextcloud : un drive prĂȘt Ă  l’emploi, pas un projet Ă  bricoler

Quand la demande est « il nous faut notre propre Dropbox », la rĂ©ponse pragmatique n’est presque jamais d’en construire un. Nextcloud est une plateforme complĂšte et auto-hĂ©bergĂ©e de synchronisation et de partage de fichiers, Ă©crite en PHP, et elle se dĂ©ploie aujourd’hui. Clients de synchronisation pour ordinateur et mobile, liens de partage avec expiration et mot de passe, historique des versions, modĂšle de permissions complet : tout est dĂ©jĂ  lĂ .

docker run -d -p 8080:80 \
  -v nextcloud:/var/www/html \
  nextcloud

Pour une installation de production avec le reverse proxy, la base de donnĂ©es et le cache Redis dĂ©jĂ  cĂąblĂ©s, l’image Docker All-in-One (voir Livrer en production) est la voie officiellement recommandĂ©e.

Une fois la plateforme lancée, créer des utilisateurs et fixer des quotas se fait en ligne de commande, sans code :

php occ user:add jane.doe
php occ user:add-app-password jane.doe --group=editors
php occ files:external:create "shared-drive" local null::null -c datadir=/mnt/shared

Quand un client a besoin d’une chose que les fonctionnalitĂ©s intĂ©grĂ©es ne couvrent pas, vous Ă©crivez une application dans le systĂšme d’extensions de Nextcloud, la mĂȘme architecture que derriĂšre Nextcloud Talk, au lieu de forker la plateforme.

Quand le choisir

Une demande qui est vraiment « notre propre systĂšme de stockage et de partage de fichiers », et surtout un client dont les exigences de rĂ©sidence des donnĂ©es ou de confidentialitĂ© Ă©cartent Google Drive et Dropbox d’emblĂ©e.

Quand ce n’est pas le bon outil

Une fonctionnalitĂ© qui se rĂ©sume Ă  « laisser les utilisateurs envoyer une photo de profil » ou « joindre un PDF Ă  cette commande ». C’est de l’envoi de fichiers ordinaire (voir Laravel : abstraction de systĂšme de fichiers et stockage compatible S3), pas une raison de monter une plateforme.

Sous le capot : la synchronisation de Nextcloud repose sur des envois par morceaux et sur des ETags pour dĂ©tecter ce qui a changĂ© depuis la derniĂšre synchronisation, si bien qu’un client ne transfĂšre que les parties modifiĂ©es d’un gros fichier au lieu de le renvoyer en entier. Ce problĂšme a Ă©tĂ© rĂ©solu une fois, en PHP, et aucune application bĂątie par-dessus n’a Ă  le rĂ©soudre Ă  nouveau.

Laravel : abstraction de systĂšme de fichiers et stockage compatible S3

La façade Storage de Laravel enveloppe League/Flysystem derriĂšre une API indiffĂ©rente au support. Le mĂȘme code Ă©crit sur le disque local en dĂ©veloppement et sur S3 en production, et la configuration seule dĂ©cide lequel.

// config/filesystems.php
return [
    'disks' => [
        's3' => [
            'driver' => 's3',
            'key' => env('AWS_ACCESS_KEY_ID'),
            'secret' => env('AWS_SECRET_ACCESS_KEY'),
            'region' => env('AWS_DEFAULT_REGION'),
            'bucket' => env('AWS_BUCKET'),
        ],
    ],
];
use Illuminate\Support\Facades\Storage;

// storing an uploaded file
$path = $request->file('avatar')->store('avatars', 's3');

// generating a temporary, signed download link
$url = Storage::disk('s3')->temporaryUrl($path, now()->addMinutes(10));

// reading it back
$contents = Storage::disk('s3')->get($path);

Remplacez 'driver' => 's3' par 'driver' => 'local' pour le dĂ©veloppement, ou pointez-le vers un endpoint DigitalOcean Spaces ou Cloudflare R2 en production. Rien d’autre ne change dans l’application.

Quand le choisir

Toute fonctionnalitĂ© avec des fichiers envoyĂ©s par les utilisateurs : avatars, piĂšces jointes, PDF gĂ©nĂ©rĂ©s, exports. C’est la façon ennuyeuse et correcte de gĂ©rer des fichiers dans une application Laravel, et l’ennui est prĂ©cisĂ©ment ce que vous cherchez ici.

Quand ce n’est pas le bon outil

Une demande de partage, de synchronisation et de collaboration (voir Nextcloud) plutît que d’envoi et de lecture. Storage gùre des fichiers. Il ne vous donne ni liens de partage, ni historique des versions, ni client de synchronisation.

Sous le capot : temporaryUrl() gĂ©nĂšre une URL prĂ©-signĂ©e, un lien dont la signature cryptographique et la date d’expiration sont inscrites dans la chaĂźne de requĂȘte, et que S3 vĂ©rifie lui-mĂȘme sans qu’aucune requĂȘte n’atteigne votre application Laravel. Servir un fichier privĂ© de cette façon ne coĂ»te aucune bande passante Ă  votre serveur.

WordPress : la médiathÚque quand elle grossit

La mĂ©diathĂšque gĂšre les envois, la gĂ©nĂ©ration des vignettes et une grille avec recherche, sans extension. Pour la plupart des sites de contenu, c’est toute la fonctionnalitĂ©, dĂ©jĂ  faite.

$attachment_id = media_handle_upload('file', $post_id);
$url = wp_get_attachment_url($attachment_id);
$thumb = wp_get_attachment_image_url($attachment_id, 'medium');

Le premier problĂšme d’échelle est presque toujours l’espace disque local et la bande passante, une fois que le site compte des milliers d’images. Le remĂšde standard dĂ©porte le stockage vers un stockage objet compatible S3 par une extension, et les rĂ©dacteurs gardent la mĂȘme interface :

wp plugin install amazon-s3-and-cloudfront --activate
wp media-offload run

À partir de lĂ , les envois passent par le mĂȘme Ă©cran, et les fichiers sont stockĂ©s et servis depuis le stockage objet plutĂŽt que depuis le disque du serveur.

Le second problĂšme est le traitement des images lui-mĂȘme. GĂ©nĂ©rer plusieurs tailles de vignette pour chaque envoi pĂšse lourd sur le processeur Ă  grand volume, et la rĂ©ponse habituelle consiste Ă  laisser un CDN redimensionner Ă  la volĂ©e au lieu de prĂ©-gĂ©nĂ©rer chaque taille Ă  l’envoi.

Quand le choisir

Tout site WordPress avec plus d’une poignĂ©e d’images, autrement dit presque tous. MĂȘme un petit site vitrine reçoit gratuitement les tailles de vignette automatiques et la grille avec recherche.

Quand ce n’est pas le bon outil

L’hĂ©bergement de vidĂ©os, ou une application lourde en mĂ©dias Ă  grande Ă©chelle. Une plateforme mĂ©dia spĂ©cialisĂ©e, intĂ©grĂ©e par son API, sert mieux ce besoin qu’une mĂ©diathĂšque Ă©tirĂ©e bien au-delĂ  de ce pour quoi elle a Ă©tĂ© conçue.

Sous le capot : WordPress gĂ©nĂšre les tailles de vignette au moment de l’envoi avec l’extension GD ou Imagick de PHP, selon ce que le serveur possĂšde. Redimensionner d’avance plutĂŽt qu’à la demande explique pourquoi les grosses mĂ©diathĂšques finissent par avoir besoin du dĂ©port dĂ©crit plus haut : le coĂ»t est payĂ© une seule fois par envoi, mais payĂ© par chaque envoi.

Livrer une boutique

Des produits, un panier, un passage en caisse, et de l’argent rĂ©el qui change de mains sans qu’un numĂ©ro de carte bancaire ne finisse lĂ  oĂč il ne devrait pas. Taxes, remboursements, stocks et conformitĂ© des paiements prĂ©sentent tous un risque quand on les traite Ă  la lĂ©gĂšre. Le e-commerce est le domaine oĂč « on va le faire nous-mĂȘmes » n’est presque jamais la rĂ©ponse pragmatique.

Une petite boutique. Une personne pousse un chariot rempli de boĂźtes vers un comptoir oĂč un petit Ă©lĂ©phant en tablier tend un ticket de caisse. Sur le comptoir, une caisse fermĂ©e par un gros cadenas et une goulotte qui traverse le mur vers l'extĂ©rieur

WooCommerce : le e-commerce par-dessus WordPress

Quand un site WordPress (voir Livrer un site de contenu) doit vendre quelque chose, WooCommerce est la rĂ©ponse par dĂ©faut. Il ajoute une boutique complĂšte sous forme d’extension, dans l’administration que votre client connaĂźt dĂ©jĂ  : produits, dĂ©clinaisons, panier, passage en caisse, commandes, codes promo.

wp plugin install woocommerce --activate
wp wc --version

Les produits sont un type de contenu personnalisé, et tout ce que vous savez de la gestion de contenu WordPress reste valable :

$product = new WC_Product_Simple();
$product->set_name('Wireless Mouse');
$product->set_regular_price('29.99');
$product->set_stock_quantity(50);
$product->save();

Les paiements se branchent par des extensions de passerelle, pas par du code d’intĂ©gration maison :

wp plugin install woocommerce-gateway-stripe --activate

La logique sur mesure (une rĂšgle de prix, un programme de fidĂ©litĂ©, un systĂšme de stock externe) s’accroche aux actions et aux filtres de WooCommerce, le mĂȘme mĂ©canisme d’extension que le cƓur de WordPress :

add_filter('woocommerce_product_get_price', function ($price, $product) {
    if (is_user_logged_in() && current_user_can('wholesale_customer')) {
        return $price * 0.85;
    }
    return $price;
}, 10, 2);

Quand le choisir

Une boutique sur un site dĂ©jĂ  sous WordPress, ou un client dont le besoin ressemble davantage Ă  « un site de contenu qui vend aussi un catalogue modeste » qu’à une plateforme de commerce Ă  fort volume.

Quand ce n’est pas le bon outil

Un fort volume de transactions avec une logique de paiement sur mesure, lĂ  oĂč l’architecture de WordPress se met Ă  rĂ©sister Ă  la fois sur les performances et sur la personnalisation. C’est le territoire de Sylius.

Sous le capot : les produits WooCommerce vivent dans la mĂȘme table wp_posts que tout autre contenu, avec leurs donnĂ©es propres (prix, stock) dans wp_postmeta. C’est l’architecture « tout est un post » des types de contenu personnalisĂ©s, Ă©tirĂ©e jusqu’à modĂ©liser un catalogue entier.

Sylius : un framework e-commerce bĂąti sur Symfony

Sylius prend le contre-pied de WooCommerce. Au lieu d’une extension posĂ©e sur une plateforme de contenu, c’est un framework e-commerce assemblĂ© Ă  partir de composants Symfony. Il vise les boutiques dont la logique mĂ©tier se heurterait Ă  une architecture d’extensions gĂ©nĂ©rique au lieu d’y trouver un appui.

composer create-project sylius/sylius-standard my-shop
cd my-shop
symfony console sylius:install
symfony server:start

Parce que c’est du Symfony, l’étendre revient Ă  Ă©crire du code Symfony ordinaire (Ă©vĂ©nements, services, entitĂ©s Doctrine) plutĂŽt qu’à apprendre une API d’extensions propre au commerce :

class OrderPlacedListener
{
    public function __construct(private LoyaltyPointsCalculator $calculator) {}

    public function onOrderPlaced(ResourceControllerEvent $event): void
    {
        $order = $event->getSubject();
        $this->calculator->awardPoints($order->getCustomer(), $order->getTotal());
    }
}
services:
    App\EventListener\OrderPlacedListener:
        tags:
            - { name: kernel.event_listener, event: sylius.order.post_create, method: onOrderPlaced }

C’est le motif Ă©couteur d’évĂ©nements employĂ© partout dans Symfony (voir Livrer du travail en arriĂšre-plan), appliquĂ© aux Ă©vĂ©nements du commerce.

Quand le choisir

Une boutique avec des rÚgles de prix, des workflows de commande ou une logique B2B qui lui sont propres : tarifs par paliers, circuits de validation, préparation depuis plusieurs entrepÎts.

Quand ce n’est pas le bon outil

Un simple catalogue avec un passage en caisse standard. C’est beaucoup plus de mise en place, et beaucoup plus de Symfony Ă  connaĂźtre, que ce que WooCommerce demande pour le mĂȘme rĂ©sultat.

Sous le capot : Sylius est assemblĂ© presque entiĂšrement Ă  partir de composants Symfony rĂ©utilisables (le composant Form, le composant Workflow pour les machines Ă  Ă©tats des commandes, Doctrine pour la persistance), les mĂȘmes briques qu’au chapitre 2, agencĂ©es pour le commerce plutĂŽt qu’inventĂ©es de zĂ©ro.

Laravel : Cashier et Stripe ($) pour un paiement sur mesure

Toutes les demandes « il faut qu’on encaisse des paiements » ne sont pas des boutiques. Souvent, c’est un seul abonnement, un paiement unique ou une facturation Ă  l’usage greffĂ©e sur une application qui n’a rien d’un magasin. Cashier est l’enveloppe officielle de Laravel autour de Stripe (et, dans un paquet sĂ©parĂ©, de Paddle), conçue pour ce cas prĂ©cis.

composer require laravel/cashier
php artisan vendor:publish --tag="cashier-migrations"
php artisan migrate
class User extends Authenticatable
{
    use Billable;
}

// starting a subscription
$user->newSubscription('default', 'price_monthly_pro')
    ->create($paymentMethodId);

// checking access
if ($user->subscribed('default')) {
    // grant access
}

// a one-time checkout, no subscription
return $user->checkout(['price_one_time_item']);

Les webhooks (paiement rĂ©ussi, abonnement annulĂ©, carte expirĂ©e) arrivent sur une route que Cashier enregistre pour vous. Votre base reste alignĂ©e sur l’état de Stripe sans interrogation rĂ©pĂ©tĂ©e.

Tarif

Stripe prĂ©lĂšve un pourcentage plus un montant fixe par paiement rĂ©ussi ; c’est le $ du titre. Cashier lui-mĂȘme, le paquet Laravel, est gratuit et open source.

Quand le choisir

Une application Laravel qui a besoin d’abonnements, de paiements uniques ou de facturation à l’usage, sans catalogue de produits. Des paliers tarifaires de SaaS, pas un panier.

Quand ce n’est pas le bon outil

Un catalogue avec des stocks, des dĂ©clinaisons et de la livraison. C’est le territoire de WooCommerce ou de Sylius. Cashier n’a aucune notion de produit au-delĂ  d’un identifiant de prix Stripe.

Sous le capot : Cashier vĂ©rifie chaque webhook entrant de Stripe par une signature cryptographique contrĂŽlĂ©e avec un secret partagĂ©, si bien que la requĂȘte est reconnue comme venant de Stripe et non d’un usurpateur avant que son contenu ne serve Ă  mettre Ă  jour un abonnement dans votre base.

Livrer une recherche qui répond du tac au tac

« Est-ce que la recherche trouve le produit mĂȘme si je fais une faute de frappe ? » Un champ de recherche posĂ© sur un WHERE title LIKE '%query%' rĂ©pond non. Il ne tolĂšre aucune coquille, ne classe rien par pertinence, et parcourt toute la table dĂšs que les donnĂ©es grossissent. Une recherche qui rĂ©pond du tac au tac est un problĂšme rĂ©solu depuis longtemps : votre travail consiste Ă  brancher vos donnĂ©es sur l’outil qui le rĂ©sout, pas Ă  en construire un.

Un comptoir de bibliothĂšque. Une personne remplit une fiche de demande oĂč un gribouillis est barrĂ©. De l'autre cĂŽtĂ© du comptoir, un petit Ă©lĂ©phant Ă  lunettes tend dĂ©jĂ  le bon livre, devant un mur de tiroirs de fichier

Laravel : Scout avec Meilisearch ou Algolia ($)

Scout ajoute la recherche plein texte aux modĂšles Eloquent. À chaque enregistrement, mise Ă  jour ou suppression d’un modĂšle, Scout met l’index de recherche Ă  jour Ă  votre place. Le code de synchronisation que vous auriez Ă©crit n’existe pas.

composer require laravel/scout meilisearch/meilisearch-php
class Product extends Model
{
    use Searchable;

    public function toSearchableArray(): array
    {
        return ['name' => $this->name, 'description' => $this->description];
    }
}

// searching
$results = Product::search('wireles mouse')->get();

La coquille dans « wireles » ramĂšne quand mĂȘme la souris. TolĂ©rer les fautes et classer par pertinence, c’est le mĂ©tier du moteur de recherche, et un LIKE SQL n’a jamais su faire ni l’un ni l’autre.

Meilisearch est open source et s’hĂ©berge chez vous : un seul binaire, avec des rĂ©glages par dĂ©faut raisonnables.

docker run -p 7700:7700 getmeili/meilisearch

Algolia est l’équivalent hĂ©bergĂ© et payant. MĂȘme driver Scout, aucune infrastructure Ă  faire tourner.

composer require algolia/scout-extended
// config/scout.php
return [
    'driver' => env('SCOUT_DRIVER', 'algolia'),
];

Tarif

Meilisearch est gratuit Ă  hĂ©berger soi-mĂȘme. Algolia facture au volume de recherches et au nombre d’enregistrements indexĂ©s, avec un palier gratuit pour les petits projets. Le mĂȘme code Scout fonctionne avec l’un comme avec l’autre : la question se rĂ©sume Ă  faire tourner le moteur vous-mĂȘme ou payer quelqu’un pour le faire.

Quand le choisir

Toute application Laravel avec un champ de recherche sur un volume de donnĂ©es qui dĂ©passe l’anecdotique : un catalogue de produits, un site de documentation, un annuaire.

Quand ce n’est pas le bon outil

Un besoin de recherche assez simple pour qu’une colonne indexĂ©e et un LIKE fassent l’affaire. Ajouter un moteur de recherche Ă  cet endroit, c’est de l’infrastructure sans problĂšme Ă  rĂ©soudre.

Sous le capot : le systĂšme de drivers de Scout est une simple interface PHP ; les drivers Meilisearch et Algolia implĂ©mentent la mĂȘme poignĂ©e de mĂ©thodes (update, delete, search). Passer de l’un Ă  l’autre tient dans la configuration parce que Scout a Ă©tĂ© conçu contre cette interface, et non contre l’API de l’un ou l’autre moteur.

TYPO3 : intégration Solr et Elasticsearch

Un gros site TYPO3 (voir Du contenu structurĂ© Ă  l’échelle d’une institution) a prĂ©cisĂ©ment le problĂšme de recherche pour lequel les moteurs spĂ©cialisĂ©s existent. Des milliers de pages, plusieurs langues, et des rĂ©dacteurs qui attendent que les rĂ©sultats respectent les mĂȘmes droits d’accĂšs et la mĂȘme arborescence que le reste du site.

L’extension Solr indexe l’arborescence avec ses restrictions d’accùs : une recherche ne fait jamais remonter une page que le visiteur n’a pas le droit de voir.

composer require apache-solr-for-typo3/solr
plugin.tx_solr {
  solr {
    host = solr.example.com
    port = 8983
    scheme = https
  }
  search {
    faceting = 1
    faceting.facets {
      contentType {
        field = type
      }
    }
  }
}

La recherche Ă  facettes, oĂč le visiteur filtre les rĂ©sultats par type de contenu, par service ou par date, n’est plus que de la configuration une fois Solr branchĂ©. Pas de PHP sur mesure.

Quand le choisir

Les sites TYPO3 d’entreprise ou d’institution oĂč la justesse de la recherche compte pour l’organisation : contenu multilingue, droits par page, filtres Ă  facettes. Pas un champ de recherche posĂ© lĂ  pour faire joli.

Quand ce n’est pas le bon outil

Un site TYPO3 plus modeste oĂč l’extension de recherche indexĂ©e fournie suffit. Un cluster Solr ou Elasticsearch Ă  part, c’est de l’infrastructure dont le projet n’a pas encore besoin.

Sous le capot : l’intĂ©gration Solr reproduit le modĂšle de droits de TYPO3 au moment de l’indexation, en enregistrant pour chaque document les groupes d’utilisateurs autorisĂ©s Ă  le voir, Ă  cĂŽtĂ© de son contenu. C’est ce qui empĂȘche la recherche de devenir une fuite involontaire de contenu restreint, un dĂ©tail que les intĂ©grations de recherche gĂ©nĂ©riques oublient parfois.

WordPress : extensions de recherche, et quand passer Ă  Elasticsearch

La recherche intĂ©grĂ©e de WordPress est une requĂȘte LIKE sur les titres et le contenu des articles, et ça se voit. Aucun classement par pertinence digne de ce nom, aucune tolĂ©rance aux fautes, et un ralentissement net dĂšs que le site compte des milliers d’articles.

Le remĂšde le plus rapide est une extension qui remplace la requĂȘte intĂ©grĂ©e sans toucher aux templates.

wp plugin install relevanssi --activate

Relevanssi rĂ©indexe le contenu existant et prend la main sur la requĂȘte de recherche. Vous obtenez un score de pertinence et une correspondance approximative, sans modifier une ligne de code ou presque.

Pour les sites plus gros, ou ceux qui ont besoin de filtres Ă  facettes (catĂ©gorie et fourchette de prix en mĂȘme temps, par exemple), une extension adossĂ©e Ă  Elasticsearch remplace tout le moteur :

wp plugin install elasticpress --activate
wp elasticpress index --setup
$args = [
    's' => 'wireless mouse',
    'post_type' => 'product',
];
$query = new WP_Query($args); // ElasticPress intercepts this transparently

Le code de l’application bouge Ă  peine. WP_Query fonctionne comme avant, et ElasticPress lui rĂ©pond depuis Elasticsearch au lieu de MySQL.

Quand le choisir

Relevanssi pour la plupart des sites oĂč le reproche porte sur la qualitĂ© de la recherche, pas sur le volume. ElasticPress quand le site a assez de contenu, ou des filtres assez compliquĂ©s, pour qu’une requĂȘte SQL mĂȘme plus maligne ne soit ni assez rapide ni assez souple.

Quand ce n’est pas le bon outil

Un petit site de quelques dizaines de pages, oĂč la recherche par dĂ©faut rĂ©pond assez vite et oĂč personne ne s’est plaint. N’ajoutez pas d’infrastructure de recherche avant d’avoir un problĂšme.

Sous le capot : WP_Query est l’abstraction centrale de WordPress pour « donne-moi des articles », utilisĂ©e par presque tous les thĂšmes et extensions. ElasticPress se greffe sur cette classe et dĂ©tourne sa requĂȘte au dernier moment, ce qui explique que l’adopter oblige rarement Ă  réécrire le code d’un thĂšme.

Livrer du travail en arriĂšre-plan

Envoyer l’e-mail de confirmation plus tard. Redimensionner l’image envoyĂ©e plus tard. GĂ©nĂ©rer le rapport mensuel Ă  deux heures du matin, sans personne devant l’écran. Tout ce qui ne doit pas bloquer la requĂȘte de l’utilisateur, ou qui tourne Ă  heure fixe plutĂŽt qu’en rĂ©ponse Ă  un clic, est du travail en arriĂšre-plan. Le faire proprement demande une file d’attente et un processus worker, pas un sleep() et un peu d’espoir.

Un restaurant vu en coupe. Au comptoir, un petit éléphant tend aussitÎt un ticket à un client. Dans la cuisine derriÚre, un rail de bons de commande et deux éléphants en toque qui les traitent un par un

Laravel : files d’attente et Horizon

Tout ce qui est lent ou accessoire dans une requĂȘte Laravel peut devenir un Job, poussĂ© dans une file d’attente et exĂ©cutĂ© par un processus worker sĂ©parĂ©. La requĂȘte de l’utilisateur se termine tout de suite au lieu d’attendre.

php artisan make:job SendWelcomeEmail
class SendWelcomeEmail implements ShouldQueue
{
    use Queueable;

    public function __construct(private User $user) {}

    public function handle(): void
    {
        Mail::to($this->user)->send(new WelcomeEmail($this->user));
    }
}

// dispatching it
SendWelcomeEmail::dispatch($user);
php artisan queue:work

Cette derniĂšre commande, c’est le worker. Un gestionnaire de processus comme Supervisor le maintient en vie ; il prend les jobs dans la file (Redis, dans la plupart des installations de production) et les exĂ©cute.

Horizon ajoute un tableau de bord par-dessus les files Redis : débit, jobs en échec, relances à la main et métriques par file, sans outil de supervision à part.

composer require laravel/horizon
php artisan horizon:install
php artisan horizon

Les jobs en Ă©chec sont relancĂ©s avec un dĂ©lai croissant. Ceux qui Ă©chouent pour de bon atterrissent dans une table failed_jobs, oĂč vous pouvez les examiner, au lieu de disparaĂźtre.

Quand le choisir

Tout ce qui ne doit pas bloquer une requĂȘte web : envoyer un e-mail, traiter un fichier envoyĂ©, appeler une API tierce lente, gĂ©nĂ©rer un rapport. Si l’utilisateur remarquerait le dĂ©lai, ça va dans une file.

Quand ce n’est pas le bon outil

Le travail qui doit ĂȘtre terminĂ© avant la rĂ©ponse, comme valider un formulaire avant de l’enregistrer. Le mettre en file ajoute de la latence et de la complexitĂ© lĂ  oĂč le code synchrone Ă©tait dĂ©jĂ  juste.

Sous le capot : les jobs sont sĂ©rialisĂ©s (en gĂ©nĂ©ral avec le serialize() natif de PHP) avant d’ĂȘtre rangĂ©s dans la file. C’est pour cela qu’une classe de job ne devrait porter que des propriĂ©tĂ©s simples et sĂ©rialisables, comme l’identifiant d’un modĂšle, plutĂŽt que de gros objets ou des ressources ouvertes ; le worker dĂ©sĂ©rialise et reconstruit le job de zĂ©ro au moment de l’exĂ©cuter.

Symfony : le composant Messenger

Messenger est le bus de messages de Symfony. La mĂȘme abstraction sert aux tĂąches de fond, comme les files de Laravel, et au dialogue entre les parties d’une application ou entre services distincts, Ă  travers une seule interface.

composer require symfony/messenger
final class SendWelcomeEmail
{
    public function __construct(public readonly int $userId) {}
}

#[AsMessageHandler]
final class SendWelcomeEmailHandler
{
    public function __invoke(SendWelcomeEmail $message): void
    {
        $user = $this->users->find($message->userId);
        $this->mailer->send(new WelcomeEmail($user));
    }
}

// dispatching it, anywhere in the app
$this->bus->dispatch(new SendWelcomeEmail($user->getId()));
# config/packages/messenger.yaml
framework:
  messenger:
    transports:
      async: '%env(MESSENGER_TRANSPORT_DSN)%'
    routing:
      App\Message\SendWelcomeEmail: async
php bin/console messenger:consume async

Les messages et leurs handlers ne se rencontrent que par le bus. Le mĂȘme message SendWelcomeEmail pourra plus tard partir vers un autre transport, disons une file partagĂ©e avec un autre service, en changeant la configuration et non le code de l’application.

Quand le choisir

Toute application Symfony qui a besoin de traitements en arriĂšre-plan, et surtout celle qui pourrait un jour avoir besoin d’échanger des messages entre services. Le mĂȘme composant fait les deux, sans second outil.

Quand ce n’est pas le bon outil

Un petit script isolĂ© qui fait une chose lente de temps en temps. Un bus de messages complet pour une tĂąche cron, c’est plus de cĂ©rĂ©monie que le problĂšme n’en mĂ©rite ; une simple commande Console lancĂ©e par le cron suffit.

Sous le capot : Messenger route les messages vers leurs handlers grĂące au systĂšme de types de PHP. L’attribut #[AsMessageHandler] et le type dĂ©clarĂ© sur __invoke() indiquent Ă  Symfony quels messages un handler accepte ; ajouter un type de message revient Ă  dĂ©finir une classe, pas Ă  l’inscrire Ă  la main dans une table de correspondance.

WordPress : WP-Cron et l’Action Scheduler

WP-Cron est le planificateur intĂ©grĂ© de WordPress, et il a une particularitĂ© Ă  connaĂźtre avant de s’y fier. Il ne tourne pas sur une horloge systĂšme : il vĂ©rifie s’il y a des tĂąches en retard Ă  chaque fois qu’un visiteur charge une page. Un site sans trafic peut cesser d’exĂ©cuter ses tĂąches planifiĂ©es Ă  l’heure, sans prĂ©venir.

add_action('daily_report_hook', function () {
    // generate and email the report
});

if (!wp_next_scheduled('daily_report_hook')) {
    wp_schedule_event(time(), 'daily', 'daily_report_hook');
}

Le remÚde habituel, pour tout ce qui compte, consiste à désactiver le déclenchement au chargement de page et à appeler WP-Cron depuis un vrai cron systÚme :

// wp-config.php
define('DISABLE_WP_CRON', true);
# real crontab entry, running every 5 minutes
*/5 * * * * curl https://example.com/wp-cron.php?doing_wp_cron >/dev/null 2>&1

Au-delĂ  des simples hooks planifiĂ©s, et surtout pour du travail en file comme un envoi d’e-mails en masse ou un import, la bibliothĂšque Action Scheduler ajoute une vraie file d’attente, avec relances et journal, sur la mĂȘme idĂ©e. Elle est livrĂ©e avec WooCommerce et fonctionne aussi seule.

as_schedule_single_action(time(), 'process_import_batch', ['batch_id' => 42]);

add_action('process_import_batch', function ($batch_id) {
    // process it
});

Quand le choisir

WP-Cron avec un cron systĂšme pour tout ce qui a une contrainte horaire : rapports planifiĂ©s, renouvellements d’abonnement, prĂ©chauffage de cache. Action Scheduler dĂšs que vous avez besoin de relances, de traitement par lots, ou d’un moyen de savoir si une tĂąche de fond a rĂ©ussi.

Quand ce n’est pas le bon outil

Les traitements en arriĂšre-plan Ă  haute frĂ©quence ou Ă  haute fiabilitĂ©. Les files de Laravel et Symfony Messenger ont Ă©tĂ© bĂątis dĂšs le dĂ©part autour d’un vrai serveur de file, et reposent sur un sol plus ferme qu’un dĂ©clenchement au chargement de page.

Sous le capot : le principe « vĂ©rifier Ă  chaque chargement de page » de WP-Cron vient des hĂ©bergements mutualisĂ©s WordPress qui, historiquement, ne laissaient pas l’utilisateur configurer de cron systĂšme. C’est un contournement raisonnable de cette contrainte, pas un dĂ©faut de conception, et il faut le neutraliser dĂšs que votre hĂ©bergement autorise un vrai cron.

Livrer une fonctionnalité IA dans le sprint

« On peut ajouter un chatbot ? » « La recherche peut comprendre une phrase en français ? » « Ça peut rĂ©sumer le texte pour l’utilisateur ? » Les fonctionnalitĂ©s IA arrivent bien plus souvent comme de petites demandes Ă  greffer sur l’existant que comme une refonte du produit. En ajouter une Ă  une application PHP ne veut presque jamais dire faire tourner un modĂšle. Ça veut dire appeler une API, et bien traiter la rĂ©ponse.

Un petit éléphant assis à un bureau tient un téléphone à l'oreille et remplit un formulaire. Le fil sort du dessin vers un bùtiment lointain surmonté d'une étincelle. Une pile de formulaires remplis attend sur le bureau

Laravel : Prism et les clients PHP OpenAI et Anthropic

Prism est un paquet pensĂ© pour Laravel qui parle aux grands modĂšles de langage (OpenAI, Anthropic et d’autres) derriĂšre une seule API. Une fonctionnalitĂ© Ă©crite contre un fournisseur n’est pas enchaĂźnĂ©e Ă  lui.

composer require prism-php/prism
use Prism\Prism\Prism;
use Prism\Prism\Enums\Provider;

$response = Prism::text()
    ->using(Provider::Anthropic, 'claude-sonnet')
    ->withPrompt("Summarize this support ticket in two sentences:\n\n{$ticket->body}")
    ->generate();

echo $response->text;

Comparer le coĂ»t ou la qualitĂ© de deux fournisseurs sur la mĂȘme fonctionnalitĂ© tient en une ligne :

Prism::text()->using(Provider::OpenAI, 'gpt-4o')->withPrompt($prompt)->generate();

Quand le rĂ©sultat doit repartir dans votre base plutĂŽt que s’afficher Ă  l’écran, demandez une sortie structurĂ©e. Vous fournissez un schĂ©ma au lieu de dĂ©couper du texte Ă  la main :

$response = Prism::structured()
    ->using(Provider::Anthropic, 'claude-sonnet')
    ->withSchema($ticketClassificationSchema)
    ->withPrompt("Classify this ticket: {$ticket->body}")
    ->generate();

$category = $response->structured['category'];

Pour une couche plus mince, les paquets officiels openai-php/client et anthropic-php appellent directement l’API de chaque fournisseur. Ils conviennent Ă  une fonctionnalitĂ© qui n’aura jamais besoin que d’un seul fournisseur.

Quand le choisir

Une fonctionnalité précise et bornée (résumé, classification, chatbot de support, suggestions de contenu) ajoutée à une application qui reste, pour le reste, un produit Laravel ordinaire.

Quand ce n’est pas le bon outil

Une fonctionnalitĂ© oĂč le modĂšle doit agir sur des donnĂ©es privĂ©es et vivantes au moment de la requĂȘte, ce qu’un appel d’API seul ne fournit pas. Cela pointe en gĂ©nĂ©ral vers une Ă©tape de recherche prĂ©alable (chercher dans vos propres donnĂ©es, puis les glisser dans le prompt), pas vers une raison d’écarter l’approche.

Sous le capot : l’abstraction de fournisseur de Prism est une interface PHP, le mĂȘme motif que les adaptateurs de stockage de Flysystem : un contrat, plusieurs implĂ©mentations interchangeables, et un code applicatif qui dĂ©pend du contrat plutĂŽt que du SDK d’un Ă©diteur.

Symfony : l’AI Bundle

L’AI Bundle de Symfony reprend l’idĂ©e « parler Ă  un modĂšle derriĂšre une interface propre » dans les conventions de Symfony. L’agent est configurĂ©, pas construit Ă  la main, et le fournisseur de modĂšle ne se retrouve jamais cĂąblĂ© en dur dans votre logique mĂ©tier.

composer require symfony/ai-bundle
# config/packages/ai.yaml
ai:
  platform:
    anthropic:
      api_key: '%env(ANTHROPIC_API_KEY)%'
  agent:
    support_assistant:
      model: 'claude-sonnet'
      system_prompt: 'You are a concise, friendly support assistant.'
final class TicketSummaryController
{
    public function __construct(private AgentInterface $supportAssistant) {}

    public function summarize(Ticket $ticket): Response
    {
        $result = $this->supportAssistant->call(
            new UserMessage("Summarize this ticket:\n\n{$ticket->getBody()}"),
        );

        return new JsonResponse(['summary' => $result->getContent()]);
    }
}

Changer de modĂšle ou de fournisseur pour une fonctionnalitĂ©, c’est une ligne de YAML. Dans les tests, l’outillage de Symfony (voir Livrer de la confiance) substitue un faux agent, et aucune vraie API n’est jamais appelĂ©e.

Quand le choisir

Un projet Symfony qui ajoute une fonctionnalitĂ© IA, quand la cohĂ©rence avec la configuration et l’injection de dĂ©pendances de l’application compte, ou quand l’équipe veut pouvoir changer de fournisseur ou simuler l’appel dans les tests sans y passer la journĂ©e.

Quand ce n’est pas le bon outil

Un petit script, ou un projet qui n’est pas sous Symfony. Là, la couche de configuration du bundle demande plus de mise en place qu’un appel direct à l’API HTTP du fournisseur avec Guzzle.

Sous le capot : l’AgentInterface du bundle, c’est encore de l’injection de dĂ©pendances par interface : le conteneur de services de Symfony fournit Ă  votre contrĂŽleur l’implĂ©mentation d’agent configurĂ©e, par le mĂȘme mĂ©canisme qu’il utilise pour injecter une connexion Ă  la base ou un logger.

WordPress : extensions IA, et quand appeler une API Ă  la place

La fonctionnalitĂ© IA la plus rapide que vous livrerez jamais sur WordPress est celle que vous n’écrivez pas. Des extensions existent dĂ©jĂ  pour les demandes courantes : un assistant de rĂ©daction dans l’éditeur de blocs, des textes alternatifs gĂ©nĂ©rĂ©s pour les images, un chatbot entraĂźnĂ© sur le contenu du site.

wp plugin install ai-engine --activate

La plupart de ces extensions gardent votre propre clĂ© d’API chez un fournisseur (OpenAI, Anthropic) et l’habillent d’un Ă©cran de rĂ©glages et d’une intĂ©gration Ă  l’éditeur. Elles ne rĂ©inventent pas l’accĂšs au modĂšle.

Pour ce qu’aucune extension ne couvre, une petite extension maison peut appeler l’API du fournisseur directement. L’API HTTP de WordPress fait le travail en quelques lignes, sans bibliothùque à part :

add_action('save_post_product', function ($post_id) {
    $description = get_post_field('post_content', $post_id);

    $response = wp_remote_post('https://api.anthropic.com/v1/messages', [
        'headers' => [
            'x-api-key' => get_option('anthropic_api_key'),
            'content-type' => 'application/json',
        ],
        'body' => wp_json_encode([
            'model' => 'claude-sonnet',
            'max_tokens' => 100,
            'messages' => [['role' => 'user', 'content' => "Write a one-line SEO summary for: {$description}"]],
        ]),
    ]);

    $data = json_decode(wp_remote_retrieve_body($response), true);
    update_post_meta($post_id, 'ai_seo_summary', $data['content'][0]['text']);
});

Quand le choisir

Une extension existante pour les demandes dĂ©jĂ  balisĂ©es, l’aide Ă  la rĂ©daction ou les textes alternatifs. Une petite extension maison avec wp_remote_post() pour tout ce qui tient au modĂšle de contenu du site.

Quand ce n’est pas le bon outil

Une fonctionnalitĂ© qui est en rĂ©alitĂ© une application complĂšte (un moteur de recommandation, un enchaĂźnement d’étapes IA) dĂ©guisĂ©e en extension WordPress. À ce stade, Prism ou l’AI Bundle de Symfony vous donnent bien plus de structure que des appels d’API bruts accrochĂ©s Ă  des actions WordPress.

Sous le capot : wp_remote_post() est le client HTTP du cƓur de WordPress, conçu pour se comporter de la mĂȘme façon d’un hĂ©bergeur Ă  l’autre (certains restreignent les fonctions HTTP de PHP disponibles). C’est pour cela que le code WordPress Ă©vite par convention d’appeler curl ou file_get_contents() directement pour les requĂȘtes sortantes.

Livrer du multilingue et du multisite

Une seule base de code, plusieurs langues, plusieurs filiales nationales dont le contenu diffĂšre un peu. La demande ressemble Ă  un problĂšme de traduction. Dessous, c’est un problĂšme d’architecture de contenu : la façon dont une page traduite se rattache Ă  son original, et qui a le droit de modifier quoi, comptent plus que le mĂ©canisme de traduction.

Une arborescence de pages dessinée comme un organigramme. Chaque page a une ou deux petites pages jumelles reliées par des pointillés ; l'une des jumelles n'est qu'un contour en pointillés. Un petit éléphant, stylo en main, regarde celle qui manque

TYPO3 : des arbres de contenu multilingues bien faits

TYPO3 traite les langues comme une dimension Ă  part entiĂšre de son arborescence depuis bien avant la plupart de ses concurrents. Une traduction n’est pas une copie du site, mais un enregistrement reliĂ© Ă  son original, Ă  l’intĂ©rieur de la mĂȘme structure.

# config/sites/main/config.yaml
languages:
  - title: English
    languageId: 0
    locale: en_US.UTF-8
    base: /
  - title: French
    languageId: 1
    locale: fr_FR.UTF-8
    base: /fr/
    fallbackType: strict

Les rĂ©dacteurs traduisent page par page depuis la vue par langue du backend. Elle montre quelles traductions sont complĂštes, lesquelles sont pĂ©rimĂ©es parce que l’original a changĂ© depuis, et lesquelles manquent :

./vendor/bin/typo3 language:update

fallbackType: strict signifie qu’une page non traduite n’existe pas en français, au lieu d’afficher discrĂštement le contenu anglais. C’est un choix assumĂ©, pas un rĂ©glage par dĂ©faut qui livre aux visiteurs des pages Ă  moitiĂ© traduites.

Quand le choisir

Les grands sites institutionnels avec une vraie gestion de contenu multilingue : des rĂ©dacteurs qui gĂšrent chacun leur langue dans leur rĂ©gion, et un lien entre l’original et ses traductions qui doit survivre Ă  des annĂ©es de modifications par des personnes diffĂ©rentes.

Quand ce n’est pas le bon outil

Un petit site qui a besoin de deux ou trois pages statiques traduites. WPML sur WordPress, ou une extension de traduction plus simple, y arrive avec beaucoup moins de mise en place.

Sous le capot : TYPO3 enregistre le contenu traduit dans des enregistrements distincts, reliĂ©s par un identifiant commun (l10n_parent), plutĂŽt que dans un seul enregistrement avec une colonne par langue. C’est ce choix de structure qui permet Ă  une page d’avoir en mĂȘme temps trois traductions terminĂ©es et deux manquantes, suivies proprement au lieu d’ĂȘtre entassĂ©es dans les colonnes d’une seule ligne.

WordPress : Multisite et WPML

WordPress a deux réponses ici, à deux questions différentes. Se tromper de réponse est une erreur courante, et coûteuse à défaire.

« Nous avons plusieurs sites distincts qui doivent partager leurs utilisateurs et leurs extensions. » Plusieurs filiales nationales avec leur propre contenu et leur propre design, pas une traduction des mĂȘmes pages. C’est ce que rĂ©sout WordPress Multisite : une seule installation qui fait tourner un rĂ©seau de sites sĂ©parĂ©s, avec le code et les utilisateurs en commun, mais pas le contenu.

wp core multisite-convert
wp site create --slug=fr --title="Example France"
wp site create --slug=de --title="Example Germany"

« Nous avons un site qui doit exister en plusieurs langues. » Les mĂȘmes pages, traduites. Multisite est le mauvais outil pour ça, puisqu’il faudrait entretenir Ă  la main une copie de chaque page. Une extension de traduction comme WPML garde un seul site, avec pour chaque page ses traductions reliĂ©es :

wp plugin install sitepress-multilingual-cms --activate
wp wpml language add fr de
// getting a translated post ID for the current language
$translated_id = apply_filters('wpml_object_id', $post_id, 'post', true);

Lequel choisir

Multisite quand les sites diffĂšrent au-delĂ  de la traduction : autre design, autre stratĂ©gie de contenu, une Ă©quipe d’administration par pays. WPML quand c’est le mĂȘme site et le mĂȘme contenu, dans plus d’une langue.

Quand ce n’est pas le bon outil

Multisite comme outil de traduction, ou WPML pour faire tourner des sites qui sont en rĂ©alitĂ© sĂ©parĂ©s et gĂ©rĂ©s indĂ©pendamment. Les deux erreurs sont frĂ©quentes, et les deux coĂ»tent cher une fois qu’un an de contenu s’est accumulĂ© sur la mauvaise structure.

Sous le capot : Multisite ajoute un blog_id aux tables du cƓur de WordPress et fait passer les requĂȘtes par un amorçage conscient du rĂ©seau, ce qui revient Ă  faire tourner plusieurs installations logiquement sĂ©parĂ©es sur un mĂȘme code. WPML ajoute au contraire sa propre table de liaison entre articles traduits, et laisse intacte l’architecture monosite du cƓur.

Symfony : le composant Translation

Tout le reste de ce chapitre traduit du contenu, ce qu’un rĂ©dacteur a Ă©crit. Le composant Translation de Symfony rĂ©sout un problĂšme plus Ă©troit : l’interface de l’application elle-mĂȘme, les libellĂ©s, les boutons et les messages d’erreur qui vivent dans le code.

composer require symfony/translation
# translations/messages.en.yaml
welcome_message: "Welcome back, %name%!"
cart.empty: "Your cart is empty."
# translations/messages.fr.yaml
welcome_message: "Content de vous revoir, %name% !"
cart.empty: "Votre panier est vide."
<h1>{{ 'welcome_message'|trans({'%name%': user.firstName}) }}</h1>
$message = $translator->trans('cart.empty');

La locale active se fixe Ă  chaque requĂȘte, d’aprĂšs un prĂ©fixe d’URL, une prĂ©fĂ©rence de l’utilisateur ou l’en-tĂȘte Accept-Language. Tout ce qui passe par trans() la suit.

Quand le choisir

Toute application Symfony dont l’interface doit parler plusieurs langues : libellĂ©s, messages de validation, modĂšles d’e-mail, navigation. Pour une application Symfony avec des utilisateurs Ă  l’international, c’est la pratique normale, pas une fonctionnalitĂ© avancĂ©e.

Quand ce n’est pas le bon outil

Le contenu Ă©ditorial, articles de blog ou fiches produit. C’est le problĂšme que rĂ©solvent les arbres de contenu multilingues de TYPO3 ou WPML. Ce composant n’a aucune notion de contenu, seulement de clĂ©s de message.

Sous le capot : les fichiers de traduction sont chargĂ©s une fois et mis en cache sous forme de tableaux PHP compilĂ©s dans le rĂ©pertoire de cache de Symfony. En production, retrouver une chaĂźne traduite est une lecture dans un tableau, pas une lecture de fichier ni une requĂȘte en base, mĂȘme avec des centaines de clĂ©s dans une douzaine de langues.

Livrer de la confiance

« Ça marche sur ma machine » n’est pas une fonctionnalitĂ©. Le bug que votre utilisateur trouve Ă  23 h Ă©tait dĂ©jĂ  lĂ  sur votre machine ; simplement, personne ne le cherchait. La confiance est une fonctionnalitĂ©, et elle a sa place dans chaque projet de ce livre, pas seulement dans ceux oĂč il reste du temps Ă  la fin. Elle vient de trois vĂ©rifications qui tournent sans vous : une suite de tests qui attrape les rĂ©gressions, un analyseur statique qui attrape des familles entiĂšres de bugs avant que le code ne s’exĂ©cute, et un scan qui signale une dĂ©pendance vulnĂ©rable avant qu’elle ne parte en production.

Un tapis roulant fait passer des caisses sous trois portiques marqués d'une coche, d'une loupe et d'un cadenas, vers un camion de livraison ouvert. Un petit éléphant retire du tapis une caisse fissurée avant le premier portique

Chaque écosystÚme a ses propres portiques. Les deux derniÚres pages sont celles qui marchent partout.

Laravel : Pest, Larastan et composer audit

Pest est un framework de test construit sur PHPUnit, conçu pour qu’un test se lise presque comme une phrase. Un test facile Ă  lire est un test qu’on Ă©crit.

composer require pestphp/pest --dev --with-all-dependencies
php artisan pest:install
it('rejects an order with no items', function () {
    $order = Order::factory()->create();

    expect(fn () => $order->submit())
        ->toThrow(EmptyOrderException::class);
});

it('applies a discount code correctly', function () {
    $order = Order::factory()->create(['total' => 100]);

    $order->applyDiscount('SAVE10');

    expect($order->total)->toBe(90.0);
});
php artisan test

Larastan enveloppe PHPStan (voir PHPStan/Psalm cĂŽtĂ© Symfony pour la version indĂ©pendante du framework) avec la connaissance des types propre Ă  Laravel. Il repĂšre l’appel d’une mĂ©thode qui n’existe pas sur un modĂšle, ou le mauvais type passĂ© Ă  un job, sans exĂ©cuter le code.

composer require larastan/larastan --dev
# phpstan.neon
includes:
    - vendor/larastan/larastan/extension.neon
parameters:
    level: 6
    paths: [app]
vendor/bin/phpstan analyse

composer audit compare vos dĂ©pendances installĂ©es Ă  une base de vulnĂ©rabilitĂ©s connues. Le jour oĂč un paquet dont vous dĂ©pendez reçoit une CVE, cette commande vous le dit, avant qu’un attaquant ne s’en charge.

composer audit

Quand le choisir

Tout projet Laravel qui a dépassé le stade du prototype. Tests et analyse statique coûtent le moins cher le premier jour, et le plus cher à rattraper sur une base de code qui a déjà grossi sans eux.

Quand ce n’est pas le bon outil

Il n’y a pas de mauvais cas ici. Le seul Ă©chec possible, c’est de sauter cette page sous la pression d’une Ă©chĂ©ance.

Sous le capot : PHPStan, et Larastan avec lui, lit vos dĂ©clarations de types, y compris les types union, les propriĂ©tĂ©s readonly et les enums, et raisonne sur ce qui est possible sans rien exĂ©cuter. Plus vos types sont stricts, plus il attrape de bugs avant mĂȘme le premier test.

Symfony : PHPUnit, PHPStan/Psalm et Rector

Chez Symfony, les tests commencent avec PHPUnit tout court. Un paquet de liaison lisse ce qui tient au framework : dĂ©marrer le noyau, lui envoyer des requĂȘtes, interroger Doctrine depuis un test.

composer require symfony/test-pack --dev
class OrderControllerTest extends WebTestCase
{
    public function testSubmittingAnEmptyOrderFails(): void
    {
        $client = static::createClient();
        $client->request('POST', '/orders/1/submit');

        $this->assertResponseStatusCodeSame(422);
    }
}
php bin/phpunit

PHPStan, ou son proche cousin Psalm, analyse le code sans le lancer. Il attrape les erreurs de type, le code inatteignable et les appels Ă  des mĂ©thodes qui n’existent pas, avant qu’ils ne deviennent des bugs Ă  l’exĂ©cution. Les deux fonctionnent aussi hors de Symfony, sur les composants autonomes vus plus haut dans ce livre.

composer require phpstan/phpstan --dev
vendor/bin/phpstan analyse src --level=8

Rector automatise les montĂ©es de version et les refactorisations. Donnez-lui une version cible de PHP ou de Symfony et il réécrit votre syntaxe pour s’y conformer, mĂ©caniquement, sur des milliers de fichiers d’un coup.

composer require rector/rector --dev
// rector.php
return RectorConfig::configure()
    ->withPaths([__DIR__ . '/src'])
    ->withSets([SymfonySetList::SYMFONY_64]);
vendor/bin/rector process

Quand le choisir

Tout projet Symfony, quelle que soit sa taille. Rector gagne sa place le jour oĂč une montĂ©e de version majeure de Symfony ou de PHP se profile et oĂč retoucher chaque fichier concernĂ© Ă  la main cesse d’ĂȘtre rĂ©aliste.

Quand ce n’est pas le bon outil

Rector sur une base de code sans aucun test. Ses modifications sont mĂ©caniques, mais quelque chose doit vĂ©rifier qu’elles n’ont pas changĂ© le comportement. Associez-le au moins aux tests ci-dessus.

Sous le capot : Rector transforme votre code en AST (arbre de syntaxe abstraite), la structure que le moteur de PHP construit lui-mĂȘme avant l’exĂ©cution, lui applique une rĂšgle, puis rĂ©imprime du PHP modifiĂ©. C’est une transformation mĂ©canique du code, pas un modĂšle de langage qui devine une intention.

WordPress : PHPUnit, PHPCS/WPCS et WPScan

Tester une extension ou un thĂšme WordPress, c’est tester contre WordPress lui-mĂȘme, pas contre une imitation allĂ©gĂ©e. L’échafaudage officiel met en place prĂ©cisĂ©ment cela.

wp scaffold plugin-tests my-plugin
cd wp-content/plugins/my-plugin
composer install
./bin/install-wp-tests.sh wordpress_test root '' localhost latest
class DiscountCalculationTest extends WP_UnitTestCase
{
    public function test_bulk_discount_applies_over_ten_items(): void
    {
        $product = $this->factory->post->create(['post_type' => 'product']);

        $price = apply_filters('calculate_bulk_price', 100, 12);

        $this->assertEquals(90, $price);
    }
}

PHP_CodeSniffer avec le jeu de rÚgles WordPress Coding Standards (WPCS) relÚve les écarts de style, et avec eux une bonne part des erreurs de sécurité pour lesquelles les extensions WordPress sont connues : sortie non échappée, entrée non assainie.

composer require --dev squizlabs/php_codesniffer wp-coding-standards/wpcs
vendor/bin/phpcs --standard=WordPress my-plugin.php

WPScan compare les extensions et les thĂšmes d’un site en ligne Ă  une base de vulnĂ©rabilitĂ©s WordPress connues. Quand une brique dont vous dĂ©pendez reçoit une CVE publique, vous l’apprenez par le scan plutĂŽt que par vos logs.

wpscan --url https://example.com --api-token YOUR_TOKEN

Quand le choisir

Toute extension ou tout thÚme sur mesure qui contient de la logique, et pas seulement du balisage. Le code qui manipule des saisies utilisateur ou des paiements est celui qui profite le plus de WPCS et de ses contrÎles sur les sorties non échappées.

Quand ce n’est pas le bon outil

Un thĂšme enfant purement visuel, sans logique PHP, n’a pas grand-chose Ă  tester. Mettez l’effort lĂ  oĂč il y a du code, pas du balisage.

Sous le capot : WP_UnitTestCase exĂ©cute chaque test dans une transaction de base de donnĂ©es, annulĂ©e ensuite. Les tests peuvent crĂ©er des articles, des utilisateurs et des options Ă  volontĂ© sans salir la base pour le suivant, la mĂȘme stratĂ©gie d’isolation que la plupart des frameworks de test PHP.

Tous écosystÚmes : SAST, analyse des dépendances et barriÚres en CI

Tout ce qui prĂ©cĂšde dans ce chapitre dĂ©pend du framework. Cette page traite de ce qui fonctionne Ă  l’identique quelle que soit la stack que vous livrez, et de la façon de le cĂąbler pour qu’un build cassĂ© ou vulnĂ©rable n’atteigne jamais la production en silence.

L’analyse statique comme SAST lĂ©ger : PHPStan et Psalm, dĂ©jĂ  vus framework par framework, servent aussi de premiĂšre ligne de test de sĂ©curitĂ© statique (SAST). Ils repĂšrent une requĂȘte SQL construite Ă  partir d’une entrĂ©e non assainie, ou une variable utilisĂ©e avant d’ĂȘtre garantie dĂ©finie.

GitHub CodeQL va plus loin. Il suit le chemin d’une entrĂ©e non fiable Ă  travers le code jusqu’à un point dangereux, une requĂȘte SQL brute, un eval(), une sortie non Ă©chappĂ©e, au lieu de vĂ©rifier des types.

# .github/workflows/codeql.yml
- uses: github/codeql-action/init@v3
  with:
    languages: php
- uses: github/codeql-action/analyze@v3

Dependabot surveille votre composer.lock et ouvre une pull request dĂšs qu’une dĂ©pendance a une vulnĂ©rabilitĂ© connue avec un correctif disponible.

# .github/dependabot.yml
version: 2
updates:
  - package-ecosystem: "composer"
    directory: "/"
    schedule: { interval: "weekly" }

Snyk ($) couvre le mĂȘme terrain avec le vernis d’un produit payant : un tableau de bord, des contrĂŽles de conformitĂ© des licences et une couverture qui dĂ©passe les dĂ©pendances Composer, contre un abonnement au-delĂ  de l’offre gratuite.

Le cĂąbler dans la CI

Le but de tout cela est une barriĂšre, pas un rapport que personne ne lit :

# .github/workflows/ci.yml
jobs:
  quality:
    steps:
      - run: composer audit
      - run: vendor/bin/phpstan analyse
      - run: vendor/bin/pest # or php bin/phpunit

Si une Ă©tape Ă©choue, la pull request ne peut pas ĂȘtre fusionnĂ©e. VoilĂ  la fonctionnalitĂ©. Pas que les outils existent, mais que personne n’ait Ă  se souvenir de les lancer.

Sous le capot : CodeQL modĂ©lise les flux de donnĂ©es. Il suit une valeur depuis son entrĂ©e dans le programme (un paramĂštre $_GET, un champ de formulaire) jusqu’à son utilisation, au lieu de vĂ©rifier chaque ligne isolĂ©ment. C’est une analyse d’une autre nature, et plus coĂ»teuse, que la vĂ©rification de types de PHPStan et Psalm.

Attraper l’erreur en production : Sentry et Flare ($)

Les tests attrapent ce que vous avez pensĂ© Ă  tester. L’analyse statique attrape ce que le systĂšme de types peut prouver. Ni l’un ni l’autre n’attrape ce qu’un utilisateur fait Ă  23 h et que personne n’avait prĂ©vu. Le suivi des erreurs, c’est la confiance qui continue aprĂšs le bouton de dĂ©ploiement : vous apprenez qu’une chose a cassĂ© pour une vraie personne au moment oĂč ça arrive, avec la trace d’appels, au lieu d’un mail au support qui dit « ça ne marche pas ».

Sentry fonctionne avec tous les frameworks de ce livre, avec des SDK pour Laravel, Symfony et PHP nu.

composer require sentry/sentry-laravel
php artisan sentry:publish --dsn=your-dsn-here
try {
    $order->submit();
} catch (\Throwable $e) {
    \Sentry\captureException($e);
    throw $e;
}

Les exceptions non rattrapĂ©es sont capturĂ©es automatiquement une fois le SDK installĂ©. L’appel manuel ci-dessus sert pour une erreur que vous gĂ©rez proprement mais dont vous voulez quand mĂȘme ĂȘtre informĂ©.

Flare ($), de Spatie, dans l’écosystĂšme Laravel, se limite Ă  Laravel et ajoute Ă  chaque rapport le contexte du framework : quelle route, quelle requĂȘte, quel job, Ă  cĂŽtĂ© de la trace d’appels.

composer require spatie/laravel-flare

Tarif

Sentry a une offre gratuite utilisable pour les petits projets, puis un plan payant quand le volume d’évĂ©nements grandit. Flare est un produit payant, avec un essai gratuit mais pas d’offre gratuite dans la durĂ©e. Les deux portent le $ ici, celui de Sentry plus conditionnel que celui de Flare.

Quand le choisir

Toute application en production. Attendre qu’un utilisateur signale un bug qu’il ne sait pas dĂ©crire coĂ»te plus de temps de dĂ©bogage que l’abonnement.

Quand ce n’est pas le bon outil

Un prototype, ou un outil interne avec une poignĂ©e d’utilisateurs qui viendront vous voir directement quand quelque chose casse. La mise en place ne se justifie pas encore.

Sous le capot : Ces outils se branchent sur les gestionnaires d’exceptions et d’erreurs de PHP lui-mĂȘme (set_exception_handler(), set_error_handler()). C’est pour cela que les installer tient en quelques lignes d’amorçage, plutĂŽt qu’en une enveloppe autour de chaque appel de fonction de votre application.

Livrer vite, à grande échelle

La plupart des fonctionnalitĂ©s de ce livre tournent trĂšs bien sur du PHP ordinaire : un processus neuf par requĂȘte, une requĂȘte en base, une rĂ©ponse, terminĂ©. Puis le trafic grandit, ou une page se rĂ©vĂšle lente, et « ça marche » cesse discrĂštement de suffire. Ce chapitre s’adresse Ă  la seconde phase, celle oĂč la performance est devenue une exigence mesurĂ©e et non plus une inquiĂ©tude.

Une suite de larges tuyaux avec un court tronçon Ă©troit devant lequel des gouttes font la queue. Un petit Ă©lĂ©phant muni d'un chronomĂštre pointe le tronçon Ă©troit, pendant qu'une personne s'apprĂȘte Ă  resserrer une vanne sur une partie large du tuyau

Trois des quatre pages sont des remĂšdes. Lisez la quatriĂšme en premier : elle vous dit de quel remĂšde vous avez besoin.

FrankenPHP et Laravel Octane : les performances du mode worker

Le PHP traditionnel reconstruit toute votre application Ă  chaque requĂȘte, framework compris : dĂ©marrer le conteneur, charger la configuration, puis tout jeter une fois la rĂ©ponse envoyĂ©e. Cette habitude explique en bonne partie la rĂ©putation de lenteur de PHP face aux runtimes qui gardent une application rĂ©sidente en mĂ©moire.

Le mode worker dĂ©marre l’application une fois et sert de nombreuses requĂȘtes avec cette mĂȘme instance, en ne rĂ©initialisant entre elles que ce qui doit l’ĂȘtre.

composer require laravel/octane
php artisan octane:install --server=frankenphp
php artisan octane:start

FrankenPHP est un serveur d’applications PHP Ă©crit en Go. Il exĂ©cute PHP en mode worker nativement, et en mode classique aussi, avec HTTPS intĂ©grĂ© et sans serveur web sĂ©parĂ© :

frankenphp php-server --worker /path/to/public/index.php

Le gain est important pour les applications dont le goulot Ă©tait le dĂ©marrage du framework et non leur propre logique. Les benchmarks publiĂ©s par les projets montrent un multiple du dĂ©bit de PHP-FPM pour le mĂȘme code applicatif, inchangĂ© ; vos propres chiffres dĂ©pendront de la part du dĂ©marrage dans chaque requĂȘte.

La contrepartie mĂ©rite d’ĂȘtre dite sans dĂ©tour. L’état global qui se rĂ©initialisait entre les requĂȘtes, une propriĂ©tĂ© statique, un singleton qui retient des donnĂ©es de requĂȘte, peut maintenant fuir d’une requĂȘte Ă  la suivante. Le mĂȘme processus les sert Ă  la file au lieu de repartir de zĂ©ro.

Quand le choisir

Une application sous charge mesurĂ©e, oĂč le profilage (voir Blackfire) dĂ©signe l’amorçage du framework, et non votre logique mĂ©tier, comme goulot d’étranglement.

Quand ce n’est pas le bon outil

Un site Ă  faible trafic ou un outil interne. Le mode worker ajoute une catĂ©gorie de bugs, l’état qui fuit entre les requĂȘtes, qui ne vaut pas la peine d’ĂȘtre assumĂ©e avant d’avoir besoin du dĂ©bit.

Sous le capot : C’est le problĂšme que le serveur WebSocket de Reverb rĂ©sout avec les Fibers, pris par l’autre bout. Au lieu d’un processus qui tient de nombreuses connexions simultanĂ©es, le mode worker garde un processus vivant Ă  travers de nombreuses requĂȘtes successives. Les deux existent parce que le modĂšle « mourir aprĂšs chaque requĂȘte » de PHP, jadis une limite, est devenu optionnel.

TYPO3 : le framework de cache intégré

Le framework de cache de TYPO3 mĂ©rite un regard mĂȘme hors d’un projet TYPO3, parce qu’il traite le cache comme un problĂšme en couches et non comme un interrupteur. Le rendu des pages, chaque Ă©lĂ©ment de contenu, les rĂ©sultats de requĂȘtes en base et la configuration ont chacun leur cache, avec leurs propres rĂšgles d’invalidation.

# config/system/settings.php
$GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['pages'] = [
    'backend' => \TYPO3\CMS\Core\Cache\Backend\Typo3DatabaseBackend::class,
    'options' => ['defaultLifetime' => 86400],
];

Les rĂ©dacteurs ne gĂšrent jamais l’invalidation. Quand un contenu change, TYPO3 vide les caches qui en dĂ©pendent et rien d’autre, au lieu d’un brutal « tout vider » aprĂšs chaque modification :

$cacheManager = GeneralUtility::makeInstance(CacheManager::class);
$cacheManager->getCache('pages')->flushByTag('pageId_' . $pageId);

L’invalidation par Ă©tiquettes est ce qui rend un cache agressif sĂ»r sur un grand site. Corriger une faute de frappe sur une page n’oblige pas Ă  rĂ©gĂ©nĂ©rer toutes les autres.

Pour les sites Ă  fort trafic, TYPO3 ajoute devant tout cela un cache de proxy inverse, Varnish le plus souvent. Un visiteur anonyme qui demande une page inchangĂ©e la reçoit entiĂšrement rendue, sans que PHP ne s’exĂ©cute.

Quand le choisir

Les grands sites TYPO3 sous charge, oĂč la gĂ©nĂ©ration des pages pĂšse Ă  l’échelle de milliers de pages et oĂč le contenu change assez souvent pour que vider tout le cache en annule l’intĂ©rĂȘt.

Quand ce n’est pas le bon outil

Un site Ă  faible trafic, oĂč le cache par dĂ©faut suffit dĂ©jĂ . RĂ©gler des durĂ©es de vie et des Ă©tiquettes pour un site que personne ne sollicite rĂ©sout un problĂšme qui n’existe pas encore.

Sous le capot : L’invalidation par Ă©tiquettes associe Ă  chaque Ă©lĂ©ment mis en cache une ou plusieurs Ă©tiquettes (un identifiant de page, un type de contenu) au moment de l’écriture. Vider « tout ce qui porte pageId_42 » devient alors une opĂ©ration ciblĂ©e, pas une purge complĂšte. La plupart des systĂšmes de cache bien conçus, en PHP ou ailleurs, reposent sur le mĂȘme principe.

Nextcloud : faire grandir une plateforme auto-hébergée

Une plateforme auto-hĂ©bergĂ©e comme Nextcloud pose une question que la plupart des produits cloud n’exposent jamais Ă  leurs clients : quelqu’un dans votre Ă©quipe doit gĂ©rer la courbe de croissance, et pas seulement payer un forfait plus gros.

Chaque Ă©tape ci-dessous rĂ©pond Ă  un goulot d’étranglement mesurĂ©, dans l’ordre oĂč une organisation les rencontre d’habitude aprĂšs avoir dĂ©passĂ© un seul petit serveur :

# 1. Move sessions and caching to Redis instead of the filesystem
php occ config:system:set redis host --value=redis.internal
php occ config:system:set memcache.distributed --value='\OC\Memcache\Redis'

# 2. Move file storage to S3-compatible object storage instead of local disk
php occ config:system:set objectstore class --value='\OC\Files\ObjectStore\S3'

# 3. Add read replicas and split heavy background jobs onto dedicated workers
php occ background:cron

Redis entre en jeu quand les utilisateurs simultanĂ©s commencent Ă  se disputer les verrous de session sur fichiers. Le stockage objet arrive quand le disque local se remplit, ou quand les entrĂ©es-sorties d’un seul serveur deviennent la limite. Les workers sĂ©parĂ©s viennent quand les tĂąches planifiĂ©es, comme les aperçus de fichiers que Nextcloud gĂ©nĂšre de lui-mĂȘme, se mettent Ă  concurrencer les utilisateurs en ligne pour le processeur.

Une organisation qui ne veut pas du tout porter cette courbe a deux voies prises en charge : l’image Docker All-in-One (voir Nextcloud : dĂ©ploiement Docker All-in-One) ou l’offre hĂ©bergĂ©e de Nextcloud lui-mĂȘme, qui Ă©change la charge d’exploitation contre un abonnement.

Quand le choisir

Une instance Nextcloud passĂ©e d’une Ă©quipe pilote Ă  un dĂ©ploiement pour toute l’organisation, oĂč l’installation sur un seul serveur montre une tension mesurĂ©e.

Quand ce n’est pas le bon outil

L’instance d’une petite Ă©quipe, confortablement dans les limites d’un serveur bien dimensionnĂ©. Redis et le stockage objet avant tout goulot, c’est de la complexitĂ© payĂ©e d’avance sans bĂ©nĂ©fice mesurĂ©.

Sous le capot : L’abstraction de stockage de Nextcloud repose sur des adaptateurs Ă  la Flysystem (voir League/Flysystem). Le code qui lit et Ă©crit les fichiers ne change pas quand le stockage passe du disque local Ă  S3, parce qu’il n’a jamais Ă©tĂ© Ă©crit contre « le systĂšme de fichiers » directement.

Blackfire ($) : trouver le vrai goulot d’étranglement

Chaque remĂšde de ce chapitre suppose que vous savez dĂ©jĂ  ce qui est lent. Trompez-vous et vous perdez plus de temps que le remĂšde n’en aurait coĂ»tĂ© : un cache devant une requĂȘte qui n’a jamais Ă©tĂ© le goulot ne corrige rien. Blackfire profile une vraie requĂȘte et montre oĂč sont partis le temps et la mĂ©moire, fonction par fonction.

composer require blackfire/php-sdk --dev
blackfire run php artisan test

Ou, pour une requĂȘte en ligne, enveloppez-la directement :

blackfire curl https://example.com/checkout

Le profil est un graphe d’appels : quelle fonction a appelĂ© laquelle, combien de temps chacune a pris, combien de fois elle a tournĂ©. Les coupables habituels remontent tout de suite. Une boucle de requĂȘtes N+1. Une API externe appelĂ©e Ă  chaque itĂ©ration quand une fois aurait suffi. Une Ă©tape de template qui domine la requĂȘte alors qu’elle semble anodine dans le code.

// what profiling often reveals: 200 queries where one would do
foreach ($orders as $order) {
    echo $order->customer->name; // N+1: one query per order
}

// the fix, informed by the profile rather than a guess
$orders = Order::with('customer')->get();

Tarif

Blackfire a une offre gratuite pour un usage individuel. La collaboration en Ă©quipe et le profilage continu en CI sont payants, d’oĂč le $ pour tout ce qui dĂ©passe l’usage solo et occasionnel.

Quand le choisir

Le moment oĂč une page ou un point d’entrĂ©e est signalĂ© lent et oĂč la cause ne saute pas aux yeux Ă  la lecture du code. Profilez d’abord, corrigez ensuite. L’ordre inverse gĂąche un cycle.

Quand ce n’est pas le bon outil

Une page dont personne ne s’est plaint et qu’aucune mĂ©trique n’a signalĂ©e. Les outils de profilage servent aux problĂšmes mesurĂ©s, pas Ă  l’inquiĂ©tude devant des problĂšmes hypothĂ©tiques.

Sous le capot : Blackfire est une extension PHP qui se branche sur le mĂ©canisme d’appel de fonctions du Zend Engine et chronomĂštre chaque appel de façon transparente. C’est pour cela que le profilage ajoute un surcoĂ»t mesurable, et qu’on le lance sur une requĂȘte Ă  la demande plutĂŽt que sur tout le trafic de production.

Livrer en production

Une fonctionnalitĂ© n’est pas livrĂ©e tant qu’elle n’est pas en ligne. Et « en ligne » veut dire que quelqu’un, peut-ĂȘtre vous, est dĂ©sormais responsable de la garder debout, Ă  jour, et capable d’encaisser le trafic qu’elle reçoit. Ce chapitre est le dernier kilomĂštre entre « ça marche en local » et « un client s’en sert », et il ne contient aucun nouveau code.

Un quai de chargement. Un camion de livraison s'Ă©loigne vers la silhouette d'une ville. Un petit Ă©lĂ©phant relĂšve la rampe et tient une planchette oĂč toutes les cases sont cochĂ©es, pendant qu'une personne salue le camion, une clĂ© Ă  molette dans l'autre main

La bonne page dĂ©pend moins de votre framework que de qui dĂ©tient le contrat d’hĂ©bergement.

Laravel : Forge et Vapor ($)

L’équipe Laravel vend deux produits de dĂ©ploiement, pour deux idĂ©es diffĂ©rentes de ce qu’est un serveur.

Forge provisionne et administre un serveur classique sur votre propre compte AWS, DigitalOcean ou Hetzner, sans administration manuelle. Il configure Nginx, PHP-FPM, une base de donnĂ©es, les certificats SSL et les workers de file d’attente, puis vous donne un tableau de bord pour dĂ©ployer, surveiller et faire grandir.

# after connecting a server through Forge's dashboard, deployment is a git push
git push forge main

Le script de déploiement exécute ce dont votre projet a besoin à chaque push, et vous le modifiez site par site :

cd /home/forge/example.com
git pull origin main
composer install --no-dev --optimize-autoloader
php artisan migrate --force
php artisan queue:restart

Vapor est un autre modĂšle : un dĂ©ploiement serverless sur AWS Lambda. Il n’y a aucun serveur Ă  mettre Ă  jour ni Ă  dimensionner. L’application ne tourne que pendant qu’elle traite une requĂȘte, et s’adapte toute seule, de zĂ©ro Ă  des milliers de requĂȘtes simultanĂ©es.

composer require laravel/vapor-cli --dev
vapor deploy production

Tarif

Les deux sont des abonnements qui s’ajoutent Ă  l’infrastructure qu’ils provisionnent. Forge facture par serveur administrĂ© ; Vapor facture Ă  l’usage, plus les coĂ»ts AWS sous-jacents.

Lequel choisir

Forge pour une application qui profite d’un serveur persistant : workers en arriĂšre-plan, connexions WebSocket via Reverb. Vapor pour un trafic irrĂ©gulier ou imprĂ©visible, oĂč ne payer que l’usage, et ne plus jamais penser Ă  la capacitĂ©, l’emporte sur les contraintes du serverless.

Quand ce n’est pas le bon outil

Une Ă©quipe qui a dĂ©jĂ  l’expertise infrastructure et son outillage cloud prĂ©fĂ©rera peut-ĂȘtre gĂ©rer le dĂ©ploiement directement plutĂŽt que payer la couche de confort de Forge par-dessus.

Sous le capot : Le modĂšle serverless de Vapor fonctionne parce que le cycle de vie d’une requĂȘte Laravel a toujours Ă©tĂ© sans Ă©tat. Rien ne suppose que le mĂȘme processus traitera la requĂȘte suivante, et c’est prĂ©cisĂ©ment l’hypothĂšse dont le modĂšle « dĂ©marrage Ă  froid Ă  chaque invocation » de Lambda a besoin pour marcher.

Cloud : AWS, GCP et Azure sans se compliquer la vie

Parfois, la dĂ©cision de dĂ©ploiement ne vous appartient pas. Le client a dĂ©jĂ  un contrat AWS, Google Cloud ou Azure, pour des raisons de conformitĂ©, d’achats ou d’infrastructure existante qui n’ont rien Ă  voir avec ce qui vous arrange. Le choix pragmatique, c’est l’option de ce cloud qui coĂ»te le moins d’effort d’exploitation, pas une infrastructure montĂ©e Ă  la main dont vous n’avez pas besoin.

AWS : App Runner prend un conteneur et le fait tourner avec mise Ă  l’échelle et rĂ©partition de charge automatiques, avec bien moins de configuration qu’un montage EC2/ECS Ă  la main.

aws apprunner create-service \
  --service-name my-app \
  --source-configuration file://apprunner-config.json

Google Cloud : Cloud Run fait le mĂȘme travail pour un conteneur sur GCP. Il descend Ă  zĂ©ro instance quand il est inactif, ce qui convient Ă  une application Ă  trafic modeste facturĂ©e Ă  l’usage.

gcloud run deploy my-app --source . --platform managed --region us-central1

Azure : App Service exĂ©cute PHP directement, sans conteneur. Il est plus proche, dans l’esprit, d’un hĂ©bergement infogĂ©rĂ© classique que des options ci-dessus, pensĂ©es d’abord pour les conteneurs.

az webapp up --runtime "PHP:8.3" --name my-app

Un Dockerfile Ă©crit une fois, sur une image standard php:8.3-fpm ou FrankenPHP, tourne sur App Runner comme sur Cloud Run avec peu ou pas de changement. Les deux ne demandent qu’un conteneur qui Ă©coute sur un port.

Quand le choisir

Le client a déjà, ou exige, une infrastructure sur un cloud donné, et une plateforme liée au framework comme Forge ou un PaaS tiers comme Platform.sh est exclu par les achats ou la conformité.

Quand ce n’est pas le bon outil

Aucune relation cloud existante et aucune exigence de conformitĂ© qui en dĂ©signe un. Une option native du framework ou un PaaS spĂ©cialisĂ© atteint la production plus vite, avec moins de connaissances d’infrastructure.

Sous le capot : Les trois plateformes exĂ©cutent le mĂȘme processus PHP-FPM ou FrankenPHP que votre portable ; un conteneur est un conteneur. Les diffĂ©rences tiennent Ă  la mĂ©canique de dĂ©ploiement et Ă  la facturation, pas Ă  la façon dont PHP exĂ©cute votre code une fois lancĂ©.

Platform.sh ($) : un seul déploiement pour plusieurs frameworks

Platform.sh vend de l’infrastructure sous forme de code, indĂ©pendante du framework : un seul format de configuration, que le projet en dessous soit Laravel, Symfony, WordPress, TYPO3 ou autre chose. Une agence qui livre sur plusieurs des stacks de ce livre apprend une plateforme de dĂ©ploiement au lieu de cinq.

# .platform.app.yaml
name: app
type: php:8.3
dependencies:
  php:
    composer/composer: "^2"
relationships:
  database: "db:mysql"
hooks:
  build: composer install --no-dev --optimize-autoloader
  deploy: php artisan migrate --force
# .platform/services.yaml
db:
  type: mysql:8.0
git push platform main

Chaque push crée un environnement complet et isolé, avec sa propre base de données et son propre stockage, au lieu de déployer par-dessus un environnement partagé. Prévisualiser une branche comme une application qui tourne devient la routine, pas un montage spécial.

Tarif

Platform.sh est un service infogéré payant, facturé par projet et par environnement, sans offre gratuite pour la production.

Quand le choisir

Les agences ou les équipes qui font tourner plusieurs projets sur différents frameworks et CMS PHP, et pour qui un seul flux de déploiement commun compte plus que les facilités propres à chaque plateforme.

Quand ce n’est pas le bon outil

Un projet unique, engagĂ© sur un framework pour longtemps. Une option native comme Forge ou l’hĂ©bergement WordPress infogĂ©rĂ© est plus simple, et souvent moins chĂšre, pour ce cas-lĂ .

Sous le capot : Le modĂšle d’un environnement par branche fonctionne parce que Platform.sh traite l’infrastructure comme une configuration versionnĂ©e Ă  cĂŽtĂ© de votre code. C’est le rĂ©flexe d’un composer.lock qui fige les versions des dĂ©pendances, Ă©tendu Ă  la base de donnĂ©es et aux services dont un dĂ©ploiement a besoin.

WordPress : l’hĂ©bergement infogĂ©rĂ© bien fait (Kinsta, WP Engine $)

Un hĂ©bergement gĂ©nĂ©rique traite WordPress comme n’importe quelle application PHP. L’hĂ©bergement WordPress infogĂ©rĂ©, chez des fournisseurs comme Kinsta ou WP Engine, est bĂąti autour de ce dont WordPress a besoin, et on le sait : un cache objet et un cache de pages rĂ©glĂ©s sur ses schĂ©mas de requĂȘtes, un environnement de prĂ©production en un clic, des mises Ă  jour du cƓur et des extensions selon un calendrier que vous contrĂŽlez, et une recherche de logiciels malveillants ciblĂ©e sur les failles connues des extensions.

# a typical managed-host workflow: staging, then push to production
wp @staging plugin update --all
wp @staging cache flush
# after review in the staging environment
wp @production deploy

La diffĂ©rence avec un hĂ©bergement que vous gĂ©rez vous-mĂȘme apparaĂźt pendant un incident. Les hĂ©bergeurs infogĂ©rĂ©s incluent des sauvegardes automatiques avec restauration en un clic, et un support qui sait dĂ©jĂ  comment WordPress tombe en panne, plutĂŽt qu’un support serveur gĂ©nĂ©raliste qui dĂ©couvre la plateforme en lisant votre ticket.

Tarif

Kinsta et WP Engine sont payants, par paliers de trafic et de nombre de sites, sans offre gratuite. Le coĂ»t se situe bien au-dessus d’un hĂ©bergement mutualisĂ© gĂ©nĂ©rique et bien en dessous d’une Ă©quipe interne qui ferait Ă  la main le mĂȘme travail de fiabilitĂ© et de performance.

Quand le choisir

Tout site WordPress exposĂ© aux clients, gĂ©nĂ©rateur de revenus ou important pour une autre raison, oĂč une panne ou une page lente a un coĂ»t, et oĂč personne en interne ne veut prendre en charge le rĂ©glage serveur et la surveillance de sĂ©curitĂ© propres Ă  WordPress.

Quand ce n’est pas le bon outil

Un blog personnel sans enjeu, ou un outil interne. Un hĂ©bergement gĂ©nĂ©rique moins cher suffit, et l’outillage spĂ©cialisĂ© resterait inutilisĂ©.

Sous le capot : Une grande part de ce que vendent ces hĂ©bergeurs est du cache objet : les rĂ©sultats des requĂȘtes WordPress coĂ»teuses gardĂ©s en mĂ©moire, via Redis ou Memcached, pour qu’une page populaire ne relance pas les mĂȘmes requĂȘtes Ă  chaque visiteur. C’est le rĂ©flexe de cache derriĂšre le framework de cache de TYPO3, prĂ©configurĂ© pour les schĂ©mas de requĂȘtes habituels de WordPress.

Nextcloud : déploiement Docker All-in-One

Monter Nextcloud Ă  la main, c’est configurer un serveur web, PHP-FPM, une base de donnĂ©es, Redis, un proxy inverse avec un TLS valide et une tĂąche cron en arriĂšre-plan. Chacun est une occasion de mal rĂ©gler quelque chose de sensible pour la sĂ©curitĂ©. L’image Docker All-in-One (AIO) est la rĂ©ponse de Nextcloud lui-mĂȘme : tout cela, prĂ©cĂąblĂ©, sous la forme d’un ensemble coordonnĂ© de conteneurs.

docker run \
  --name nextcloud-aio-mastercontainer \
  --restart always \
  -p 8080:8080 \
  -v nextcloud_aio_mastercontainer:/mnt/docker-aio-config \
  -v /var/run/docker.sock:/var/run/docker.sock:ro \
  nextcloud/all-in-one:latest

L’interface web du conteneur vous guide ensuite pour les certificats TLS, le choix des applications optionnelles Ă  activer (dont le backend haute performance de Talk, vu dans le temps rĂ©el) et la configuration des sauvegardes. Un seul tableau de bord, au lieu d’une douzaine de fichiers de configuration.

Les mises Ă  jour de Nextcloud et de chaque application activĂ©e passent par la mĂȘme interface :

# update the mastercontainer image, then trigger an update from its UI
docker pull nextcloud/all-in-one:latest
docker stop nextcloud-aio-mastercontainer
docker rm nextcloud-aio-mastercontainer
# re-run the original docker run command to restart it on the new image

Quand le choisir

Auto-hĂ©berger Nextcloud pour un usage durable, pour une petite Ă©quipe ou toute une organisation. L’image AIO condense un savoir d’exploitation durement acquis sur la sĂ©curisation et l’entretien d’une instance, le genre de chose qu’on rate facilement, et subtilement, Ă  la main.

Quand ce n’est pas le bon outil

Une Ă©valuation locale rapide, oĂč l’image Docker simple (voir Nextcloud : un drive prĂȘt Ă  l’emploi) se jette plus vite. Ou un environnement oĂč Docker lui-mĂȘme n’est pas une option.

Sous le capot : Le motif du « mastercontainer », un conteneur qui gĂšre le cycle de vie de plusieurs autres Ă  travers la socket Docker, est une orchestration plus lĂ©gĂšre que Kubernetes et plus lourde qu’un simple docker run. Il existe pour que les mises Ă  jour de services interdĂ©pendants (l’application, la base, le proxy) se fassent dans le bon ordre, toutes seules.

Et ensuite

Ce livre a couvert beaucoup de terrain sans jamais vous demander de vous engager sur une stack pour de bon. C’était le but. Le savoir-faire du dĂ©veloppeur pragmatique n’est pas de maĂźtriser un framework ; c’est d’associer une fonctionnalitĂ© Ă  l’outil qui la livre le plus vite, encore et encore, d’un projet et d’un client Ă  l’autre. Ce dernier chapitre parle d’entretenir ce savoir-faire une fois le livre refermĂ©.

Un petit Ă©lĂ©phant tient une porte ouverte sur un atelier oĂč un moteur de voiture repose sur un support. Une personne avec une ceinture Ă  outils se tient sur le seuil, un pied Ă  l'intĂ©rieur, et regarde le moteur

Évaluer une nouvelle stack en une journĂ©e

Un nouveau client, un nouvel outil, un framework dans lequel vous n’avez encore rien livrĂ©. Ce livre couvre les options d’aujourd’hui ; il y en aura d’autres demain, et les clients n’attendent pas la prochaine Ă©dition. Une journĂ©e, quatre Ă©tapes, et vous savez s’il faut y engager du temps de projet.

Le matin : installer et se repérer

Suivez le guide de dĂ©marrage de l’outil, tel qu’il est documentĂ©, sans raccourci. Notez combien de temps ça a pris, combien de dĂ©cisions ont Ă©tĂ© prises pour vous, et combien de libertĂ© il vous reste. Un premier projet en moins d’une minute montre Ă  quoi cela ressemble pour les frameworks et les CMS de ce livre.

À midi : construire une vraie petite chose

Pas un « hello world ». Un formulaire de connexion, une table de donnĂ©es, un seul point d’entrĂ©e d’API. ChronomĂ©trez, et notez oĂč vous avez bloquĂ© dans la documentation. Cette friction est le signal le plus honnĂȘte que vous aurez sur ce qu’un projet avec cet outil donnera au quotidien.

L’aprĂšs-midi : vĂ©rifier les bords

Cherchez ce que chaque chapitre de ce livre tient pour dĂ©cisif. Existe-t-il une voie officielle et maintenue pour les tests (voir Livrer de la confiance) ? Pour le dĂ©ploiement (voir Livrer en production) ? Une question bloquante obtient-elle une rĂ©ponse en heures plutĂŽt qu’en semaines (voir Les communautĂ©s qui valent le dĂ©tour) ?

Le soir : décider selon le brief, pas selon le marketing

La page d’accueil de chaque outil se dit rapide, moderne et agrĂ©able pour les dĂ©veloppeurs. Rien de tout cela ne compte autant que la question posĂ©e en premier par le chapitre 1 : framework, CMS ou headless ? Et cette option correspond-elle Ă  la fonctionnalitĂ© qu’on vous a demandĂ©e ?

Sous le capot : La mĂȘme pratique (le guide de dĂ©marrage, puis une petite fonctionnalitĂ©, puis les bords) sert aussi Ă  Ă©valuer des outils hors de PHP. Ce qui est propre Ă  ce livre, c’est la liste des bords : l’écosystĂšme PHP a des rĂ©ponses mĂ»res pour les tests, le dĂ©ploiement et l’entraide, si bien qu’un nouvel outil Ă  qui il manque l’une d’elles mĂ©rite d’ĂȘtre traitĂ© comme un signal d’alerte, pas comme un dĂ©tail.

Les communautés qui valent le détour

La documentation rĂ©pond Ă  la question que vous saviez poser. Une communautĂ© rĂ©pond Ă  celle que vous ne saviez pas poser. Chaque Ă©cosystĂšme de ce livre a un lieu oĂč des praticiens rĂ©pondent Ă  des problĂšmes prĂ©cis, souvent plus vite qu’un moteur de recherche ne vous trouve une rĂ©ponse Ă  jour.

  • Laravel : le Discord Laravel et le forum de Laracasts sont tous deux actifs, et la documentation officielle sur laravel.com est remarquablement bien entretenue d’une version Ă  l’autre.
  • Symfony : le Slack Symfony et le forum communautaire accessibles depuis symfony.com sont lĂ  oĂč se rĂšglent la plupart des questions sur le framework et ses composants.
  • WordPress : make.wordpress.org hĂ©berge les Ă©quipes de contributeurs qui construisent le cƓur de WordPress, tandis que les forums d’entraide de WordPress.org couvrent les questions sur les extensions et les thĂšmes.
  • TYPO3 : le Slack TYPO3, accessible depuis typo3.org, donne de la profondeur aux questions de CMS institutionnel que ce livre n’a eu la place que d’introduire.
  • API Platform : les GitHub Discussions du dĂ©pĂŽt du projet, accessibles depuis api-platform.com, reçoivent la plupart des questions de mise en Ɠuvre.
  • Nextcloud : le forum communautaire et les discussions GitHub accessibles depuis nextcloud.com couvrent aussi bien l’exploitation en auto-hĂ©bergement que le dĂ©veloppement d’applications.

Une habitude Ă  garder

Au-delĂ  de chaque framework, PHP a une scĂšne active de confĂ©rences et de groupes d’utilisateurs locaux, et les grands frameworks publient des journaux de modifications et des guides de migration dĂ©taillĂ©s plutĂŽt que de vous prendre par surprise. Suivez les notes de version d’un framework, pas seulement ses annonces. C’est l’habitude la plus rentable pour rester Ă  jour sans rĂ©apprendre votre stack de zĂ©ro.

Sous le capot : Sans objet ici. Les communautĂ©s sont faites de gens, pas de code, et c’est bien le sujet. La rĂ©ponse la plus rapide Ă  un blocage vient souvent de quelqu’un qui a heurtĂ© le mĂȘme mur le mois dernier, pas d’une lecture plus poussĂ©e des sources.

Si vous devenez curieux de ce qu’il y a dessous

Si vous avez ouvert chaque encadrĂ© « Sous le capot » de ce livre, vous en savez dĂ©jĂ  plus sur le moteur que ce livre ne vous demandait d’apprendre. Vous avez vu des Fibers rendre possible un serveur WebSocket, des attributs et de la rĂ©flexion engendrer une API entiĂšre Ă  partir d’une classe, et un systĂšme de types assez solide pour que l’analyse statique attrape des bugs avant le premier test. Rien de tout cela n’était prĂ©sentĂ© comme une leçon de langage. C’était prĂ©sentĂ© comme « voilĂ  pourquoi la facilitĂ© que vous venez d’utiliser fonctionne ».

Si ce motif a commencĂ© Ă  vous intĂ©resser pour lui-mĂȘme, ce livre a Ă©tĂ© discrĂštement construit pour vous mener ici.

The PHP Book reprend Ă  ce point prĂ©cis : variables, types, structures de contrĂŽle, classes, et le modĂšle d’erreurs du moteur lui-mĂȘme, enseignĂ©s pour de bon plutĂŽt que dĂ©duits du comportement d’un framework. Il suppose ce que vous avez apportĂ© ici, de l’expĂ©rience de code ailleurs, et la tourne vers le langage plutĂŽt que vers les conventions d’un framework.

Vous n’en avez pas besoin pour continuer Ă  livrer. Chaque fonctionnalitĂ© de ce livre marche aujourd’hui, en production, sans l’ouvrir une seule fois. Il est lĂ  pour le jour oĂč « livre, c’est tout » devient « attendez, comment ça marche ? ». Si vous avez lu jusqu’ici, ce jour viendra peut-ĂȘtre plus tĂŽt que prĂ©vu.

Lire The PHP Book

Annexes

Trois pages de rĂ©fĂ©rence, faites pour y chercher quelque chose plutĂŽt que pour ĂȘtre lues d’un trait :

A - L’antisùche des stacks

Une page : le besoin Ă  gauche, le choix Ă  droite. Un $ signale tout ce qui n’est pas open source. Quand deux choix apparaissent, le premier est en gĂ©nĂ©ral le plus rapide Ă  dĂ©marrer.

Vous devez livrer
PrenezChapitre
Une application sur mesure avec sa propre logique métierLaravel ou SymfonyCh. 1
Un site vitrine ou un blog que le client modifie lui-mĂȘmeWordPressCh. 3
Un grand site institutionnel, multi-services et multilingueTYPO3Ch. 3 / Ch. 13
Un script ponctuel ou un outil en ligne de commande, sans frameworkSymfony/Console, Guzzle, MonologCh. 2
Connexion, inscription, mot de passe oubliéLaravel Breeze/Fortify, Symfony Security ou les rÎles WordPressCh. 4
Un back-office interneLaravel Filament, Symfony EasyAdmin ou Nova $Ch. 5
Une API REST/GraphQL documentéeAPI PlatformCh. 6
Des mises Ă  jour en direct sans recharger la pageLaravel Reverb, Symfony Mercure ou Pusher $Ch. 7
Du partage et de la synchronisation de fichiers (« notre propre Dropbox »)NextcloudCh. 8
Des envois de fichiers ordinaires dans une application existanteLaravel Storage / League/FlysystemCh. 8
Un catalogue de produits et un paiementWooCommerce, Sylius ou Cashier + Stripe $Ch. 9
Une recherche qui tolĂšre les fautes de frappe et classe par pertinenceLaravel Scout + Meilisearch (ou Algolia $)Ch. 10
Des tùches en arriÚre-plan et des tùches planifiéesLaravel Queues, Symfony Messenger ou Action SchedulerCh. 11
Une fonctionnalité IA ajoutée à une application existanteLaravel Prism ou Symfony AI BundleCh. 12
Plusieurs langues ou plusieurs sites régionauxTYPO3, WPML ou Symfony TranslationCh. 13
Tests, analyse statique et recherche de vulnérabilitésPest/Larastan, PHPStan/Psalm, composer auditCh. 14
Les erreurs vues en productionSentry (ou Flare $)Ch. 14
Plus de dĂ©bit sans réécrire l’applicationFrankenPHP / Laravel OctaneCh. 15
Trouver le goulot d’étranglementBlackfire $Ch. 15
Déployer une application LaravelForge ou Vapor $Ch. 16
Déployer sur un contrat AWS/GCP/Azure existantApp Runner, Cloud Run ou App ServiceCh. 16
DĂ©ployer plusieurs frameworks de la mĂȘme façonPlatform.sh $Ch. 16
DĂ©ployer WordPress lĂ  oĂč une panne coĂ»te de l’argentKinsta ou WP Engine $Ch. 16
Auto-hĂ©berger Nextcloud en productionL’image Docker All-in-OneCh. 16

B - Glossaire de l’écosystĂšme

Chaque terme est dĂ©fini par ce qu’il fait pour vous, pas par sa dĂ©finition formelle.

Adaptateur Un petit morceau de code qui fait parler une chose (un stockage, un moteur de recherche) dans l’interface qu’attend votre application, pour qu’échanger le service en dessous n’oblige pas Ă  réécrire l’application. Voir League/Flysystem.

Attribut Une mĂ©tadonnĂ©e Ă©crite juste au-dessus d’une classe ou d’une mĂ©thode PHP (#[ApiResource], #[IsGranted('ROLE_ADMIN')]), qu’un framework lit Ă  l’exĂ©cution pour dĂ©cider comment la traiter. Il remplace ce qui demandait autrefois des fichiers de configuration sĂ©parĂ©s.

Bundle Le mot de Symfony pour un paquet installable qui ajoute une fonctionnalitĂ© Ă  une application : le Security Bundle, l’AI Bundle. En gros, un paquet Laravel ou une extension WordPress.

Façade Une convention Laravel : un appel court, d’apparence statique (Storage::get(...)), adossĂ© Ă  un vrai objet interchangeable en dessous. Vous gagnez une syntaxe mĂ©morisable sans perdre la souplesse de l’injection de dĂ©pendances.

Fiber Une fonctionnalitĂ© de PHP 8.1 qui permet Ă  un seul processus de suspendre et de reprendre son exĂ©cution Ă  volontĂ©, en gardant de nombreuses choses en vol Ă  la fois sans un thread par tĂąche. C’est ce qui rend possible le serveur WebSocket de Reverb.

Hook / Filtre Le mĂ©canisme d’extension de WordPress : un point nommĂ© dans le code de base oĂč une extension exĂ©cute sa propre fonction (add_action) ou modifie une valeur au passage (add_filter), sans toucher Ă  WordPress lui-mĂȘme.

Migration Un changement de schĂ©ma de base de donnĂ©es, incrĂ©mental et versionnĂ©, Ă©crit en code plutĂŽt qu’appliquĂ© Ă  la main. Chaque dĂ©veloppeur et chaque environnement aboutit Ă  la mĂȘme structure en exĂ©cutant les mĂȘmes fichiers de migration.

ORM (Object-Relational Mapper) La couche qui transforme les lignes de la base en objets PHP et inversement (Eloquent chez Laravel, Doctrine chez Symfony), pour que le code de tous les jours s’écrive $product->price au lieu de SQL Ă  la main.

Provider (Service Provider / conteneur de services) La partie d’un framework qui construit les objets et les remet Ă  qui en a besoin. Une classe dĂ©clare « il me faut un logger » dans son constructeur et ne saura jamais comment ce logger a Ă©tĂ© construit ni configurĂ©.

PSR Une PHP Standards Recommendation : une interface convenue (PSR-3 pour les logs, PSR-7 pour les messages HTTP) qui permet Ă  des paquets d’éditeurs diffĂ©rents de fonctionner ensemble sans connaĂźtre leurs entrailles respectives.

Ressource Dans une API, un type de chose que l’API expose (un Product, un Order) avec les opĂ©rations disponibles dessus. Laravel emploie aussi le mot, plus Ă©troitement, pour la classe qui met un modĂšle en forme JSON.

Webhook Un rappel. Au lieu que votre application demande sans arrĂȘt Ă  un service « il s’est passĂ© quelque chose ? », le service envoie une requĂȘte HTTP Ă  votre application dĂšs que c’est le cas. C’est ainsi que Stripe prĂ©vient votre application qu’un paiement a abouti.

Worker Un processus de longue durĂ©e qui prend les tĂąches dans une file d’attente et les exĂ©cute, Ă  part du processus qui sert les requĂȘtes web, pour qu’un travail lent ne bloque jamais un utilisateur qui attend une page. Voir Livrer du travail en arriĂšre-plan.

C - Index des encadrés « Sous le capot »

Chaque apartĂ© optionnel de ce livre, dans l’ordre de lecture, pour le jour oĂč l’un d’eux vous est restĂ© en tĂȘte et oĂč vous voulez le retrouver.

ChapitreCe qu’il explique
Framework, CMS ou headless ?Pourquoi frameworks, CMS et outils d’API partagent les mĂȘmes traits du langage sous des emballages diffĂ©rents
Un premier projetLa rĂ©solution des dĂ©pendances et l’autoloading de Composer
Symfony/ConsoleLes commandes console comme simples classes PHP, sans runtime spécial
GuzzlePSR-7 et PSR-18, les interfaces qui font coopérer les clients HTTP
League/PlatesPourquoi des templates en PHP pur n’ont pas besoin d’étape de compilation
MonologPSR-3, l’interface standard de journalisation
Respect/ValidationDes bibliothùques de validation qui s’appuient sur le systùme de types de PHP
League/FlysystemLe polymorphisme par interface appliqué au stockage
ThÚmes de blocs WordPressDes blocs stockés en HTML structuré, pas en templates PHP
Contenu structurĂ© TYPO3Le TCA comme gĂ©nĂ©ration d’interface pilotĂ©e par des mĂ©tadonnĂ©es
StatamicDes fichiers plats, les fonctions de fichiers de PHP et du cache Ă  la place du SQL
Craft CMSL’accĂšs dynamique aux propriĂ©tĂ©s derriĂšre des champs de contenu flexibles
Laravel Breeze/FortifyPourquoi le hachage des mots de passe est lent exprĂšs (bcrypt/argon2id)
Symfony SecurityL’attribut #[IsGranted] et la rĂ©flexion
RÎles WordPressDes capacités qui sont de simples chaßnes, pas un moteur de permissions formel
Laravel FilamentDes objets fluides et chaßnables rendus possibles par les arguments nommés et les enums
Symfony EasyAdmin/SonataLire les mĂ©tadonnĂ©es d’entitĂ© Doctrine pour dĂ©duire les types de champs
API Platform AdminGĂ©nĂ©rer un schĂ©ma OpenAPI/Hydra Ă  partir d’attributs
WordPress CPT en CRUDTous les types de contenu dans une seule table wp_posts
Laravel NovaPourquoi une licence payante ne change rien au mécanisme des paquets
API Platform depuis une classeAttributs et réflexion qui engendrent routage, validation et documentation
Laravel SanctumPourquoi les jetons ne sont pas hachés comme les mots de passe
API REST WordPressL’API REST construite sur les hooks et les filtres de WordPress
Laravel Reverb/LivewireLes Fibers de PHP, et comment elles rendent possible un serveur WebSocket
Symfony Mercure/TurboLes Server-Sent Events, une simple fonctionnalité HTTP
Nextcloud TalkLe systùme d’applications de Nextcloud et les conventions d’autoloading de PHP
PusherPourquoi une bonne abstraction rend réversible le choix « héberger ou payer »
Stockage NextcloudEnvois par morceaux et ETags pour une synchronisation efficace
Laravel Storage/S3URL présignées et signatures cryptographiques
MédiathÚque WordPressLa génération immédiate des vignettes avec GD/Imagick
WooCommerceDes donnĂ©es de commerce modĂ©lisĂ©es dans les mĂȘmes tables wp_posts/wp_postmeta
SyliusAssemblé à partir de composants Symfony réutilisables, pas réinventé
Laravel Cashier/StripeVĂ©rifier la signature d’un webhook avant de faire confiance Ă  son contenu
Laravel ScoutUne interface de pilote qui rend les moteurs de recherche interchangeables
TYPO3 SolrReproduire les permissions des pages dans l’index de recherche
Recherche WordPressWP_Query comme point d’accroche pour des moteurs de recherche plus malins
Files d’attente LaravelLa sĂ©rialisation des jobs, et pourquoi ils doivent rester simples
Symfony MessengerRouter les messages vers leurs handlers grĂące au systĂšme de types de PHP
WP-Cron WordPressPourquoi WP-Cron se déclenche au chargement des pages et non sur une horloge systÚme
Laravel PrismUne interface de fournisseur, le mĂȘme motif que les adaptateurs de Flysystem
Symfony AI BundleL’injection de dĂ©pendances appliquĂ©e Ă  un agent IA
Extensions IA WordPressPourquoi WordPress embarque son propre client HTTP portable
Arbres multilingues TYPO3Des traductions comme enregistrements liés, pas comme colonnes supplémentaires
WordPress Multisite/WPMLDeux réponses structurelles à deux problÚmes différents
Symfony TranslationDes fichiers de traduction compilés en tableaux PHP mis en cache
Laravel Pest/LarastanL’analyse statique qui raisonne sur les types dĂ©clarĂ©s sans exĂ©cuter le code
Symfony PHPStan/RectorRector qui réécrit le code en analysant et modifiant son AST
Tests WordPressL’isolation des tests par annulation de transaction
SAST tous écosystÚmesAnalyse des flux de données contre vérification des types
Sentry/FlareSe brancher sur les gestionnaires d’exceptions et d’erreurs de PHP
FrankenPHP/OctaneLe mode worker, image inversée des Fibers
Cache TYPO3L’invalidation de cache par Ă©tiquettes
Montée en charge NextcloudLes adaptateurs de stockage, cette fois sous la pression de la croissance
BlackfireLe profilage par une extension du Zend Engine
Laravel Forge/VaporL’absence d’état comme condition du dĂ©ploiement serverless
HĂ©bergement cloudLe mĂȘme processus PHP, quel que soit le cloud qui l’exĂ©cute
Platform.shL’infrastructure comme configuration versionnĂ©e
Hébergement WordPress infogéréLe cache objet avec Redis/Memcached
Nextcloud AIOL’orchestration de conteneurs par le motif du mastercontainer