đ Livrez avec PHP
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.
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.
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 ? : les trois formes que prend un projet, et celle que décrit votre cahier des charges.
- Un premier projet en moins dâune minute : la commande Ă lancer pour chaque option majeure de ce livre, pour les comparer les mains dans le clavier plutĂŽt que sur un tableau.
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.
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
- Parler Ă dâautres API : Guzzle
- Des templates sans framework : League/Plates
- Des logs qui marchent tout de suite : Monolog
- Valider les entrées : Respect/Validation
- Stocker des fichiers sans adopter un framework : League/Flysystem
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Ă©thodeexecute(). 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
Httpde Laravel, leHttpClientde 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 requirepeut 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,fileExistset 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.
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 : le chemin le plus court vers un site modifiable, et la plus grande part du web de contenu.
- TYPO3 : du contenu structurĂ© Ă lâĂ©chelle dâune institution : quand « contenu » veut dire des milliers de pages structurĂ©es rĂ©parties entre des services.
- Statamic ($ en usage commercial) : un CMS à fichiers plats bùti sur Laravel : une édition à la WordPress sans base de données, pour les développeurs Laravel.
- Craft CMS ($) : un CMS sous licence, pensĂ© pour les rĂ©dactions : un modĂšle de contenu sur mesure, pour les clients prĂȘts Ă payer une licence.
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 diffsert 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.
- Laravel : Breeze, Fortify et Jetstream : trois kits de dĂ©marrage officiels, des « seules vues » jusquâau squelette complet dâun SaaS avec Ă©quipes.
- Symfony : le Security Bundle : authentification et autorisation pilotées par la configuration.
- WordPress : rĂŽles, capacitĂ©s et mots de passe dâapplication : ce que le cĆur de WordPress livre dĂ©jĂ , et quand cela suffit.
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
Hashde 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.
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 génÚre une administration complÚte à partir des modÚles Eloquent, presque sans code répétitif.
- Symfony : EasyAdmin et Sonata, lâoption lĂ©gĂšre et lâoption lourde pour un projet Doctrine.
- API Platform : une administration gĂ©nĂ©rĂ©e depuis votre API transforme lâAPI que vous exposez dĂ©jĂ en panneau dâadministration, gratuitement.
- WordPress : types de contenu personnalisĂ©s et ACF comme moteur CRUD montre jusquâoĂč lâadministration de WordPress sâĂ©tire avant quâil faille autre chose.
- Laravel Nova ($) : lâalternative officielle Ă Filament Ă©change un panneau open source contre un support Ă©diteur et une feuille de route.
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
pricetypĂ©edecimaldans 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,pageou votreteam_member, est une ligne de la mĂȘme tablewp_posts, distinguĂ©e par une colonnepost_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.
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 gĂ©nĂšre REST, GraphQL et la documentation OpenAPI depuis une seule classe annotĂ©e.
- Laravel : Sanctum, Resources et versions dâAPI, lâapproche plus lĂ©gĂšre, plus manuelle et plus rĂ©pandue.
- WordPress : lâAPI REST intĂ©grĂ©e, ce quâun site WordPress expose dĂ©jĂ avant que vous nâinstalliez quoi que ce soit.
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/productsetGET /api/products/{id}POST /api/products,PUTetDELETE, 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âavecpassword_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_filterqui 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.
- Laravel : Reverb et Livewire, sans écrire de JavaScript associe un serveur WebSocket officiel et auto-hébergé à un modÚle de composants réactifs.
- Symfony : UX Turbo et Mercure sâappuie sur un protocole temps rĂ©el ouvert plutĂŽt que sur un serveur maison.
- Nextcloud Talk : le temps rĂ©el au sein dâune plateforme, ou comment une grosse application PHP gĂšre le chat et les appels Ă grande Ă©chelle.
- Pusher ($) : des WebSockets gĂ©rĂ©s, sans serveur Ă faire tourner Ă©change lâinfrastructure contre un abonnement.
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.
- Nextcloud : un drive prĂȘt Ă lâemploi, pas un projet Ă bricoler met en place une plateforme complĂšte de partage de fichiers en un aprĂšs-midi.
- Laravel : abstraction de systÚme de fichiers et stockage compatible S3 ajoute envois et stockage à une application que vous avez déjà .
- WordPress : la médiathÚque quand elle grossit, ce qui est déjà là , et ce qui casse en premier quand le site grandit.
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.
- WooCommerce : le e-commerce par-dessus WordPress, le chemin le plus court quand le site est, ou devrait ĂȘtre, sous WordPress.
- Sylius : un framework e-commerce bùti sur Symfony convient à une boutique sur mesure avec sa propre logique métier.
- Laravel : Cashier et Stripe ($) pour un paiement sur mesure convient Ă une application Laravel qui a besoin dâun abonnement ou dâun paiement, pas dâune boutique.
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_postsque tout autre contenu, avec leurs donnĂ©es propres (prix, stock) danswp_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.
- Laravel : Scout avec Meilisearch ou Algolia ($) : un index de recherche tenu à jour avec vos modÚles, sur un serveur à vous ou loué.
- TYPO3 : intĂ©gration Solr et Elasticsearch : une recherche sur des milliers de pages qui respecte les droits dâaccĂšs et les langues.
- WordPress : extensions de recherche, et quand passer à Elasticsearch : ce qui est déjà là , et les deux extensions qui le remplacent quand ça ne suffit plus.
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_Queryest 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.
- Laravel : files dâattente et Horizon : des jobs dans une file, un worker pour les exĂ©cuter, un tableau de bord pour les surveiller.
- Symfony : le composant Messenger : un seul bus de messages pour les tĂąches de fond et pour le dialogue entre services.
- WordPress : WP-Cron et lâAction Scheduler : ce que WordPress utilise pour ses tĂąches planifiĂ©es, son dĂ©faut bien connu, et le remĂšde.
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.
- Laravel : Prism et les clients PHP OpenAI et Anthropic : une seule API pour plusieurs fournisseurs de modĂšles, interchangeables en une ligne.
- Symfony : lâAI Bundle : la mĂȘme idĂ©e dans les conventions de Symfony, configurĂ©e plutĂŽt que construite Ă la main.
- WordPress : extensions IA, et quand appeler une API Ă la place : le chemin le plus court pour un site WordPress, et le moment oĂč il ne suffit plus.
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â
AgentInterfacedu 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âappelercurloufile_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.
- TYPO3 : des arbres de contenu multilingues bien faits : une structure de contenu conçue pour ça dĂšs lâorigine.
- WordPress : Multisite et WPML : deux réponses WordPress à deux versions différentes de la question.
- Symfony : le composant Translation : traduire lâinterface de lâapplication elle-mĂȘme, pas son contenu.
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_idaux 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.
Chaque écosystÚme a ses propres portiques. Les deux derniÚres pages sont celles qui marchent partout.
- Laravel : Pest, Larastan et
composer audit: des tests qui se lisent comme des phrases, un vĂ©rificateur de types qui connaĂźt Laravel, et un scan de vulnĂ©rabilitĂ©s en une commande. - Symfony : PHPUnit, PHPStan/Psalm et Rector : les trois mĂȘmes, plus un outil qui réécrit votre code pour la prochaine version majeure.
- WordPress : PHPUnit, PHPCS/WPCS et WPScan : des tests contre un vrai WordPress, un linter qui repÚre les sorties non échappées, et un scanner des failles connues des extensions.
- Tous Ă©cosystĂšmes : SAST, analyse des dĂ©pendances et barriĂšres en CI : ce qui tourne Ă lâidentique quelle que soit la stack, cĂąblĂ© pour quâun build cassĂ© ne puisse pas ĂȘtre fusionnĂ©.
- Attraper lâerreur en production : Sentry et Flare ($) : le moment oĂč la confiance doit dĂ©passer votre suite de tests et atteindre ce que rencontrent les vrais utilisateurs.
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
readonlyet 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.
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 : garder lâapplication dĂ©marrĂ©e en mĂ©moire entre les requĂȘtes au lieu de la reconstruire Ă chaque fois.
- TYPO3 : le framework de cache intégré : un cache en couches avec invalidation ciblée, livré avec une grande plateforme de contenu.
- Nextcloud : faire grandir une plateforme auto-hĂ©bergĂ©e : ce qui change quand une application PHP auto-hĂ©bergĂ©e passe dâune Ă©quipe Ă toute une organisation.
- Blackfire ($) : trouver le vrai goulot dâĂ©tranglement : mesurer oĂč part le temps avant de corriger quoi que ce soit.
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.
La bonne page dĂ©pend moins de votre framework que de qui dĂ©tient le contrat dâhĂ©bergement.
- Laravel : Forge et Vapor ($) : les produits de dĂ©ploiement de lâĂ©quipe Laravel, un pour les serveurs, un pour le serverless.
- Cloud : AWS, GCP et Azure sans se compliquer la vie : lâoption la moins coĂ»teuse en exploitation sur chaque cloud, quand le client y a dĂ©jĂ un contrat.
- Platform.sh ($) : un seul déploiement pour plusieurs frameworks : une plateforme infogérée qui se moque du framework en dessous.
- WordPress : lâhĂ©bergement infogĂ©rĂ© bien fait (Kinsta, WP Engine $) : un hĂ©bergement bĂąti autour des besoins de WordPress.
- Nextcloud : dĂ©ploiement Docker All-in-One : la voie auto-hĂ©bergĂ©e que Nextcloud recommande lui-mĂȘme.
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.lockqui 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Ă©.
- Ăvaluer une nouvelle stack en une journĂ©e : une mĂ©thode reproductible pour jauger un outil que vous nâavez jamais utilisĂ©.
- Les communautĂ©s qui valent le dĂ©tour : lĂ oĂč chaque Ă©cosystĂšme de ce livre obtient des rĂ©ponses Ă ses questions.
- Si vous devenez curieux de ce quâil y a dessous : la porte qui ramĂšne au langage lui-mĂȘme, pour le jour oĂč « livre, câest tout » devient « attendez, comment ça marche ? »
Ă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.
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 : chaque dĂ©cision « lequel choisir » de ce livre, sur une page.
- B - Glossaire de lâĂ©cosystĂšme : le vocabulaire rĂ©current, dĂ©fini par ce quâil fait pour vous.
- C - Index des encadrĂ©s « Sous le capot » : chaque apartĂ© optionnel, dans lâordre de lecture, pour le jour oĂč lâun dâeux vous est restĂ© en tĂȘte.
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⊠| Prenez | Chapitre |
|---|---|---|
| Une application sur mesure avec sa propre logique métier | Laravel ou Symfony | Ch. 1 |
| Un site vitrine ou un blog que le client modifie lui-mĂȘme | WordPress | Ch. 3 |
| Un grand site institutionnel, multi-services et multilingue | TYPO3 | Ch. 3 / Ch. 13 |
| Un script ponctuel ou un outil en ligne de commande, sans framework | Symfony/Console, Guzzle, Monolog | Ch. 2 |
| Connexion, inscription, mot de passe oublié | Laravel Breeze/Fortify, Symfony Security ou les rÎles WordPress | Ch. 4 |
| Un back-office interne | Laravel Filament, Symfony EasyAdmin ou Nova $ | Ch. 5 |
| Une API REST/GraphQL documentée | API Platform | Ch. 6 |
| Des mises Ă jour en direct sans recharger la page | Laravel Reverb, Symfony Mercure ou Pusher $ | Ch. 7 |
| Du partage et de la synchronisation de fichiers (« notre propre Dropbox ») | Nextcloud | Ch. 8 |
| Des envois de fichiers ordinaires dans une application existante | Laravel Storage / League/Flysystem | Ch. 8 |
| Un catalogue de produits et un paiement | WooCommerce, Sylius ou Cashier + Stripe $ | Ch. 9 |
| Une recherche qui tolĂšre les fautes de frappe et classe par pertinence | Laravel Scout + Meilisearch (ou Algolia $) | Ch. 10 |
| Des tùches en arriÚre-plan et des tùches planifiées | Laravel Queues, Symfony Messenger ou Action Scheduler | Ch. 11 |
| Une fonctionnalité IA ajoutée à une application existante | Laravel Prism ou Symfony AI Bundle | Ch. 12 |
| Plusieurs langues ou plusieurs sites régionaux | TYPO3, WPML ou Symfony Translation | Ch. 13 |
| Tests, analyse statique et recherche de vulnérabilités | Pest/Larastan, PHPStan/Psalm, composer audit | Ch. 14 |
| Les erreurs vues en production | Sentry (ou Flare $) | Ch. 14 |
| Plus de dĂ©bit sans réécrire lâapplication | FrankenPHP / Laravel Octane | Ch. 15 |
| Trouver le goulot dâĂ©tranglement | Blackfire $ | Ch. 15 |
| Déployer une application Laravel | Forge ou Vapor $ | Ch. 16 |
| Déployer sur un contrat AWS/GCP/Azure existant | App Runner, Cloud Run ou App Service | Ch. 16 |
| DĂ©ployer plusieurs frameworks de la mĂȘme façon | Platform.sh $ | Ch. 16 |
| DĂ©ployer WordPress lĂ oĂč une panne coĂ»te de lâargent | Kinsta ou WP Engine $ | Ch. 16 |
| Auto-hĂ©berger Nextcloud en production | Lâimage Docker All-in-One | Ch. 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.
| Chapitre | Ce 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 projet | La rĂ©solution des dĂ©pendances et lâautoloading de Composer |
| Symfony/Console | Les commandes console comme simples classes PHP, sans runtime spécial |
| Guzzle | PSR-7 et PSR-18, les interfaces qui font coopérer les clients HTTP |
| League/Plates | Pourquoi des templates en PHP pur nâont pas besoin dâĂ©tape de compilation |
| Monolog | PSR-3, lâinterface standard de journalisation |
| Respect/Validation | Des bibliothĂšques de validation qui sâappuient sur le systĂšme de types de PHP |
| League/Flysystem | Le polymorphisme par interface appliqué au stockage |
| ThÚmes de blocs WordPress | Des blocs stockés en HTML structuré, pas en templates PHP |
| Contenu structurĂ© TYPO3 | Le TCA comme gĂ©nĂ©ration dâinterface pilotĂ©e par des mĂ©tadonnĂ©es |
| Statamic | Des fichiers plats, les fonctions de fichiers de PHP et du cache Ă la place du SQL |
| Craft CMS | LâaccĂšs dynamique aux propriĂ©tĂ©s derriĂšre des champs de contenu flexibles |
| Laravel Breeze/Fortify | Pourquoi le hachage des mots de passe est lent exprĂšs (bcrypt/argon2id) |
| Symfony Security | Lâattribut #[IsGranted] et la rĂ©flexion |
| RÎles WordPress | Des capacités qui sont de simples chaßnes, pas un moteur de permissions formel |
| Laravel Filament | Des objets fluides et chaßnables rendus possibles par les arguments nommés et les enums |
| Symfony EasyAdmin/Sonata | Lire les mĂ©tadonnĂ©es dâentitĂ© Doctrine pour dĂ©duire les types de champs |
| API Platform Admin | GĂ©nĂ©rer un schĂ©ma OpenAPI/Hydra Ă partir dâattributs |
| WordPress CPT en CRUD | Tous les types de contenu dans une seule table wp_posts |
| Laravel Nova | Pourquoi une licence payante ne change rien au mécanisme des paquets |
| API Platform depuis une classe | Attributs et réflexion qui engendrent routage, validation et documentation |
| Laravel Sanctum | Pourquoi les jetons ne sont pas hachés comme les mots de passe |
| API REST WordPress | LâAPI REST construite sur les hooks et les filtres de WordPress |
| Laravel Reverb/Livewire | Les Fibers de PHP, et comment elles rendent possible un serveur WebSocket |
| Symfony Mercure/Turbo | Les Server-Sent Events, une simple fonctionnalité HTTP |
| Nextcloud Talk | Le systĂšme dâapplications de Nextcloud et les conventions dâautoloading de PHP |
| Pusher | Pourquoi une bonne abstraction rend réversible le choix « héberger ou payer » |
| Stockage Nextcloud | Envois par morceaux et ETags pour une synchronisation efficace |
| Laravel Storage/S3 | URL présignées et signatures cryptographiques |
| MédiathÚque WordPress | La génération immédiate des vignettes avec GD/Imagick |
| WooCommerce | Des donnĂ©es de commerce modĂ©lisĂ©es dans les mĂȘmes tables wp_posts/wp_postmeta |
| Sylius | Assemblé à partir de composants Symfony réutilisables, pas réinventé |
| Laravel Cashier/Stripe | VĂ©rifier la signature dâun webhook avant de faire confiance Ă son contenu |
| Laravel Scout | Une interface de pilote qui rend les moteurs de recherche interchangeables |
| TYPO3 Solr | Reproduire les permissions des pages dans lâindex de recherche |
| Recherche WordPress | WP_Query comme point dâaccroche pour des moteurs de recherche plus malins |
| Files dâattente Laravel | La sĂ©rialisation des jobs, et pourquoi ils doivent rester simples |
| Symfony Messenger | Router les messages vers leurs handlers grĂące au systĂšme de types de PHP |
| WP-Cron WordPress | Pourquoi WP-Cron se déclenche au chargement des pages et non sur une horloge systÚme |
| Laravel Prism | Une interface de fournisseur, le mĂȘme motif que les adaptateurs de Flysystem |
| Symfony AI Bundle | Lâinjection de dĂ©pendances appliquĂ©e Ă un agent IA |
| Extensions IA WordPress | Pourquoi WordPress embarque son propre client HTTP portable |
| Arbres multilingues TYPO3 | Des traductions comme enregistrements liés, pas comme colonnes supplémentaires |
| WordPress Multisite/WPML | Deux réponses structurelles à deux problÚmes différents |
| Symfony Translation | Des fichiers de traduction compilés en tableaux PHP mis en cache |
| Laravel Pest/Larastan | Lâanalyse statique qui raisonne sur les types dĂ©clarĂ©s sans exĂ©cuter le code |
| Symfony PHPStan/Rector | Rector qui réécrit le code en analysant et modifiant son AST |
| Tests WordPress | Lâisolation des tests par annulation de transaction |
| SAST tous écosystÚmes | Analyse des flux de données contre vérification des types |
| Sentry/Flare | Se brancher sur les gestionnaires dâexceptions et dâerreurs de PHP |
| FrankenPHP/Octane | Le mode worker, image inversée des Fibers |
| Cache TYPO3 | Lâinvalidation de cache par Ă©tiquettes |
| Montée en charge Nextcloud | Les adaptateurs de stockage, cette fois sous la pression de la croissance |
| Blackfire | Le profilage par une extension du Zend Engine |
| Laravel Forge/Vapor | Lâabsence dâĂ©tat comme condition du dĂ©ploiement serverless |
| HĂ©bergement cloud | Le mĂȘme processus PHP, quel que soit le cloud qui lâexĂ©cute |
| Platform.sh | Lâinfrastructure comme configuration versionnĂ©e |
| Hébergement WordPress infogéré | Le cache objet avec Redis/Memcached |
| Nextcloud AIO | Lâorchestration de conteneurs par le motif du mastercontainer |