Laravel 11 et PHP 8.4 : installer l’environnement et maîtriser la nouvelle architecture

En novembre 2024, PHP publiait sa version 8.4 — une mise à jour majeure qui introduit les property hooks, la visibilité asymétrique, de nouvelles fonctions de tableau et une API BCMath orientée objet. Quelques mois plus tôt, en mars 2024, Laravel 11 redessinait son architecture interne : un fichier bootstrap/app.php repensé comme hub de configuration central, un unique AppServiceProvider, des routes API devenues optionnelles. Pour un développeur qui découvre ou approfondit ce duo en 2025, comprendre ces deux évolutions en profondeur est la différence entre subir un framework et en maîtriser chaque couche.

Ce guide vous donne les fondations solides pour travailler avec Laravel 11 et PHP 8.4 : comment installer l’environnement sur Ubuntu, Debian ou Windows, pourquoi la structure du projet a été allégée, et comment chaque brique du framework s’articule autour du nouveau fichier de configuration central. Chaque section documente non seulement les commandes exactes, mais aussi les sorties attendues, les signaux de réussite, et le raisonnement derrière chaque choix architectural.

Les six tutoriels de cette série couvrent un spectre plus large : création d’API REST, Eloquent ORM avancé, authentification Sanctum, queues asynchrones et tests avec Pest. Ce guide est votre point de départ et votre référence permanente.

Pourquoi PHP 8.4 change la donne pour le développement moderne

PHP célèbre en 2024 ses 30 ans d’existence — et la version 8.4 est sans doute l’une des plus structurantes de la décennie. Elle n’apporte pas seulement des performances accrues (environ 5 à 10 % de gain sur les benchmarks de type web réaliste), elle introduit des constructions langagières qui rapprochent PHP des patterns modernes que l’on retrouve en Kotlin, C#, ou TypeScript.

La caractéristique la plus discutée est sans conteste les property hooks. Avant PHP 8.4, un objet avec de la logique de lecture/écriture sur une propriété nécessitait des méthodes getX()/setX() explicites, alourdissant le code et l’API publique de la classe. Les property hooks permettent désormais d’inliner cette logique directement dans la déclaration de propriété, sans rompre la rétrocompatibilité. Pour Laravel, cela ouvre la voie à des modèles Eloquent plus expressifs, des DTOs plus compacts et des Value Objects sans plomberie.

La visibilité asymétrique règle un problème classique : rendre une propriété publique en lecture mais privée en écriture nécessitait de passer par des getters ou des méthodes factory. PHP 8.4 introduit la syntaxe public private(set), qui exprime exactement cette intention en un seul modificateur. Les nouvelles fonctions de tableau (array_find(), array_find_key(), array_any(), array_all()) comblent enfin un manque que les développeurs PHP compensaient par des combinaisons de array_filter() + array_keys(). Enfin, la syntaxe allégée pour l’instantiation d’objets (new Foo()->method() sans parenthèses autour de new) améliore la lisibilité des chaînes d’appels.

Les cinq innovations PHP 8.4 que vous utiliserez dans Laravel

1. Property Hooks — propriétés intelligentes

Les property hooks permettent d’attacher de la logique de validation ou de transformation directement à une propriété de classe, sans créer de méthodes accesseur explicites. Il existe deux hooks : get (appelé lors de la lecture) et set (appelé lors de l’écriture). Voici un exemple concret dans le contexte d’un modèle ou d’un DTO Laravel :

<?php

class UserProfile
{
    // Hook set : normalise automatiquement l'email à la minuscule
    public string $email {
        set(string $value) {
            $this->email = strtolower(trim($value));
        }
    }

    // Hook get : calcule le nom complet à la volée
    public string $fullName {
        get => trim("{$this->firstName} {$this->lastName}");
    }

    public function __construct(
        public string $firstName,
        public string $lastName,
    ) {}
}

$profile = new UserProfile('Mamadou', 'Diallo');
$profile->email = '  Mamadou@Example.Com  ';

echo $profile->email;    // mamadou@example.com (normalisé automatiquement)
echo $profile->fullName; // Mamadou Diallo (calculé à la volée)

Ce que ce code fait réellement : à l’affectation $profile->email = '...', PHP appelle automatiquement le hook set qui applique strtolower(trim()) avant de stocker la valeur. Pour $fullName, le hook get est déclenché à chaque lecture et construit le nom complet sans stocker de donnée redondante. Le signal de réussite est que vous n’avez plus besoin de méthodes setEmail() ou getFullName() explicites — l’API de votre classe reste propre.

2. Visibilité asymétrique — encapsulation précise

Cette fonctionnalité répond à une demande récurrente : exposer une propriété en lecture publique tout en restreignant son écriture à la classe elle-même. Le pattern courant avant PHP 8.4 était de rendre la propriété privée et d’exposer un getter public, ce qui alourdissait inutilement le code. PHP 8.4 introduit la syntaxe public private(set) :

<?php

class InvoiceStatus
{
    // Lisible de partout, modifiable uniquement depuis la classe elle-même
    public private(set) string $status = 'draft';
    public private(set) DateTimeImmutable $updatedAt;

    public function __construct()
    {
        $this->updatedAt = new DateTimeImmutable();
    }

    public function submit(): void
    {
        $this->status    = 'submitted';           // autorisé — même classe
        $this->updatedAt = new DateTimeImmutable(); // autorisé — même classe
    }
}

$invoice = new InvoiceStatus();
echo $invoice->status;   // 'draft' — lecture publique OK

$invoice->status = 'paid'; // ⚠️ Error: Cannot modify private(set) property

L’avantage immédiat en Laravel : vos entités de domaine et vos Value Objects peuvent exposer leurs propriétés directement sans risque de modification externe accidentelle. Vous évitez des dizaines de getters et vos tests accèdent aux propriétés sans passer par des méthodes intermédiaires.

3. Nouvelles fonctions de tableau

PHP 8.4 introduit quatre fonctions qui simplifient les opérations courantes sur les tableaux. Avant, retrouver le premier élément d’un tableau satisfaisant une condition nécessitait un array_filter() suivi d’un reset() ou d’un array_values()[0] — fragile et verbeux. Voici les nouvelles fonctions :

<?php

$users = [
    ['name' => 'Alice', 'role' => 'admin', 'active' => true],
    ['name' => 'Bob',   'role' => 'user',  'active' => false],
    ['name' => 'Carol', 'role' => 'admin', 'active' => true],
];

// Trouver le premier admin actif
$firstAdmin = array_find($users, fn($u) => $u['role'] === 'admin' && $u['active']);
// ['name' => 'Alice', 'role' => 'admin', 'active' => true]

// Trouver la clé du premier admin actif
$adminKey = array_find_key($users, fn($u) => $u['role'] === 'admin' && $u['active']);
// 0

// Vérifier qu'il existe au moins un admin actif
$hasActiveAdmin = array_any($users, fn($u) => $u['role'] === 'admin' && $u['active']);
// true

// Vérifier que TOUS les utilisateurs sont actifs
$allActive = array_all($users, fn($u) => $u['active']);
// false

Dans un projet Laravel, vous utiliserez souvent ces fonctions dans les helpers, les règles de validation personnalisées, ou les services qui manipulent des collections de données brutes avant de les passer à Eloquent.

4. Instantiation simplifiée

Avant PHP 8.4, chaîner une méthode directement après new nécessitait des parenthèses englobantes : (new Foo())->bar(). PHP 8.4 lève cette restriction et permet new Foo()->bar() sans parenthèses supplémentaires. C’est une amélioration mineure mais qui rend le code de type factory ou builder beaucoup plus lisible :

<?php

// Avant PHP 8.4
$result = (new QueryBuilder())->from('users')->where('active', true)->get();

// PHP 8.4+
$result = new QueryBuilder()->from('users')->where('active', true)->get();

La nouvelle architecture de Laravel 11 : ce qui change vraiment

Laravel 11, publié le 12 mars 2024, est le résultat d’un effort concerté pour alléger la structure par défaut d’un projet Laravel. La philosophie est simple : ne générer que le code dont vous avez réellement besoin, et centraliser la configuration dans le moins de fichiers possible. Pour un développeur venant de Laravel 10, les changements sont visibles dès la première commande composer create-project.

Le fichier bootstrap/app.php devient le hub de configuration

Dans Laravel 10, la configuration de l’application était répartie entre app/Http/Kernel.php (middleware), app/Providers/ (cinq service providers par défaut), et plusieurs fichiers de configuration. Laravel 11 condense tout cela dans bootstrap/app.php :

<?php

use IlluminateFoundationApplication;
use IlluminateFoundationConfigurationExceptions;
use IlluminateFoundationConfigurationMiddleware;

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        commands: __DIR__.'/../routes/console.php',
        health: '/up',
    )
    ->withMiddleware(function (Middleware $middleware) {
        // Ajouter un middleware global
        $middleware->append(EnsureJsonResponse::class);
        // Exclure une route du CSRF
        $middleware->validateCsrfTokens(except: ['stripe/*']);
    })
    ->withExceptions(function (Exceptions $exceptions) {
        // Personnaliser la gestion des exceptions
        $exceptions->render(function (ModelNotFoundException $e) {
            return response()->json(['error' => 'Resource not found'], 404);
        });
    })->create();

Ce fichier remplace à lui seul l’ancien Kernel.php HTTP et la plupart de la configuration des service providers. Le gain de lisibilité est immédiat : tout ce qui configure le comportement fondamental de l’application est dans un seul fichier, consultable en quelques secondes.

Un seul AppServiceProvider

Laravel 10 créait cinq service providers par défaut (AuthServiceProvider, BroadcastServiceProvider, EventServiceProvider, RouteServiceProvider, AppServiceProvider). Dans Laravel 11, seul AppServiceProvider est généré. Tous les enregistrements de policies, d’events, et de routes passent par lui ou par bootstrap/app.php. Si vous avez besoin d’un provider supplémentaire, vous le créez manuellement — pas de boilerplate imposé.

Les routes API sont opt-in

Une des suppressions les plus notables : routes/api.php n’est plus créé par défaut. Laravel 11 part du principe que toutes les applications ne sont pas des APIs. Pour créer les routes API et installer Sanctum en même temps :

php artisan install:api

Cette commande crée routes/api.php, installe Laravel Sanctum, publie ses migrations et les exécute. C’est l’approche moderne : vous déclarez explicitement que vous faites de l’API. De même, routes/channels.php (broadcasting) est opt-in via php artisan install:broadcasting.

Le scheduling dans routes/console.php

Avant Laravel 11, les tâches planifiées se définissaient dans la méthode schedule() de app/Console/Kernel.php. Ce fichier n’existe plus dans Laravel 11. Le scheduling se fait directement dans routes/console.php :

<?php

use IlluminateSupportFacadesSchedule;

// Envoyer les emails quotidiennement à 8h
Schedule::command('emails:send')->dailyAt('08:00');

// Nettoyer les tokens expirés toutes les heures
Schedule::command('sanctum:prune-expired --hours=24')->hourly();

// Exécuter une closure toutes les 5 minutes
Schedule::call(function () {
    AppModelsReport::generateDailyStats();
})->everyFiveMinutes();

Installer PHP 8.4 sur Ubuntu et Debian

Ubuntu 22.04 LTS (Jammy) et 24.04 LTS (Noble) ne livrent pas PHP 8.4 dans leurs dépôts officiels par défaut. La méthode recommandée est le PPA d’Ondřej Surý, le mainteneur officiel des paquets PHP Debian/Ubuntu. Ce PPA est utilisé en production par des millions de serveurs et supporte des installations parallèles de plusieurs versions PHP (utile si vous gérez des projets en PHP 8.1, 8.2 et 8.4 sur la même machine).

# 1. Ajouter le PPA Ondřej Surý (source officielle pour PHP sur Debian/Ubuntu)
sudo add-apt-repository ppa:ondrej/php
sudo apt-get update

# 2. Installer PHP 8.4 avec les extensions nécessaires pour Laravel
sudo apt-get install -y   php8.4-cli   php8.4-fpm   php8.4-common   php8.4-mbstring   php8.4-xml   php8.4-curl   php8.4-zip   php8.4-mysql   php8.4-pgsql   php8.4-sqlite3   php8.4-redis   php8.4-bcmath   php8.4-intl   php8.4-gd

# 3. Vérifier l'installation
php -v

La commande php -v doit retourner quelque chose comme PHP 8.4.x (cli) avec la date de compilation. Si vous avez plusieurs versions installées, vous pouvez sélectionner PHP 8.4 par défaut :

# Sélectionner PHP 8.4 comme version CLI par défaut
sudo update-alternatives --set php /usr/bin/php8.4

# Vérifier que la bonne version est active
php --version
# Doit afficher : PHP 8.4.x ...

Pour Nginx + PHP-FPM, assurez-vous de pointer vers le socket PHP 8.4 dans votre configuration Nginx : fastcgi_pass unix:/run/php/php8.4-fpm.sock;. Rechargez ensuite PHP-FPM avec sudo systemctl restart php8.4-fpm.

Installer PHP 8.4 sur Windows

Sur Windows, deux approches s’imposent selon votre contexte. La première, et la plus recommandée pour les développeurs sérieux, est d’utiliser WSL2 (Windows Subsystem for Linux) avec Ubuntu — vous bénéficiez alors exactement des mêmes commandes que la section Linux précédente et d’un environnement identique à votre serveur de production. La seconde est d’installer PHP nativement via un gestionnaire de paquets Windows.

# Option 1 : Activer WSL2 (recommandé — ouvrir PowerShell en administrateur)
wsl --install
# Redémarrer Windows, puis choisir Ubuntu dans le Microsoft Store
# Suivre ensuite les instructions Ubuntu de la section précédente

# Option 2 : Installation native via Chocolatey
# Prérequis : installer Chocolatey (chocolatey.org)
choco install php --version=8.4.0

# Vérification
php -v

Pour une solution clé en main incluant PHP, MySQL, Redis et un serveur web configurés pour Laravel, Laravel Herd (disponible sur Windows et macOS via herd.laravel.com) est l’environnement officiel recommandé par l’équipe Laravel. Herd installe automatiquement PHP 8.4, crée des sites .test locaux et gère les versions PHP par projet en quelques clics — sans aucune configuration manuelle. C’est le choix idéal pour démarrer rapidement.

Installer Composer 2.x

Composer est le gestionnaire de dépendances de PHP. Laravel l’utilise pour toutes ses opérations : installation du framework, ajout de packages, autoloading des classes. La version actuelle est Composer v2.9.8 (mai 2026) et requiert PHP 7.2 minimum. Voici l’installation globale recommandée sur Linux/macOS :

# Télécharger le script d'installation officiel
php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"

# Vérifier l'intégrité du script (hash SHA-384 disponible sur getcomposer.org/download)
HASH=$(curl -sS https://composer.github.io/installer.sig)
php -r "
  if (hash_file('sha384', 'composer-setup.php') === '$HASH') {
    echo 'Installer verified' . PHP_EOL;
  } else {
    echo 'Installer CORRUPT' . PHP_EOL;
    unlink('composer-setup.php');
    exit(1);
  }
"

# Exécuter l'installation
php composer-setup.php

# Supprimer le script et déplacer Composer dans le PATH global
php -r "unlink('composer-setup.php');"
sudo mv composer.phar /usr/local/bin/composer

# Vérification
composer --version
# Doit afficher : Composer version 2.x.x ...

Une fois Composer installé, la commande composer --version confirme l’installation. Le point important : vérifiez toujours le hash d’intégrité avant d’exécuter le script d’installation — c’est une bonne pratique de sécurité documentée sur getcomposer.org.

Créer votre premier projet Laravel 11

Deux approches existent pour créer un nouveau projet Laravel 11. La première utilise Composer directement, la seconde passe par l’installeur Laravel — qui offre un wizard interactif pour choisir les features dès la création.

# Méthode 1 : via Composer (la plus directe)
composer create-project laravel/laravel mon-projet "11.*"
cd mon-projet

# Méthode 2 : via l'installeur Laravel (recommandée, wizard interactif)
composer global require laravel/installer
laravel new mon-projet
# Le wizard demande : starter kit (None / Breeze / Jetstream), tests (PHPUnit / Pest), etc.
cd mon-projet

Après la création du projet, configurez le fichier d’environnement et générez la clé de chiffrement :

# Copier le fichier d'environnement exemple
cp .env.example .env

# Générer la clé d'application (chiffrement des sessions, cookies, données sensibles)
php artisan key:generate

# Vérifier que l'application démarre
php artisan serve
# Sortie attendue : INFO  Server running on [http://127.0.0.1:8000]

Ouvrez http://127.0.0.1:8000 dans votre navigateur. Si vous voyez la page d’accueil Laravel avec le logo et les liens vers la documentation, votre environnement est fonctionnel. Le signal d’échec le plus courant à cette étape est une clé d’application manquante (APP_KEY= vide dans .env) — la commande php artisan key:generate résout ce problème.

La structure du projet Laravel 11 expliquée

Un projet Laravel 11 fraîchement créé contient moins de fichiers que ses prédécesseurs, mais chaque dossier a un rôle précis. Comprendre cette structure est essentiel avant d’écrire la première ligne de code métier.

Le dossier app/ contient votre code applicatif : app/Http/Controllers/ pour les contrôleurs, app/Models/ pour les modèles Eloquent, app/Providers/AppServiceProvider.php comme unique service provider. Contrairement à Laravel 10, les sous-dossiers Policies, Rules, Jobs, Mail, Notifications et Events ne sont plus créés par défaut — ils apparaissent uniquement quand vous les générez via Artisan (php artisan make:policy, make:job, etc.).

Le dossier bootstrap/ contient le fichier app.php dont nous avons parlé — c’est désormais le seul fichier important de ce dossier. Le cache de configuration et de routes y est stocké dans bootstrap/cache/. Le dossier config/ regroupe tous les fichiers de configuration (database, cache, mail, queue, etc.) — en Laravel 11, ces fichiers sont disponibles mais ne sont publiés dans votre projet que si vous les modifiez, réduisant le bruit visuel dans les nouveaux projets.

Le dossier database/ contient les migrations (migrations/), les factories (factories/) et les seeders (seeders/). routes/ contient web.php (routes avec session et CSRF) et console.php (commandes Artisan et scheduling) — api.php n’est créé qu’après php artisan install:api. Enfin, resources/ contient les vues Blade, le CSS et le JavaScript du frontend.

Les commandes Artisan indispensables

Artisan est l’outil en ligne de commande de Laravel. Voici les commandes fondamentales à maîtriser dès le départ, regroupées par catégorie :

# Génération de code
php artisan make:model Article -m          # Modèle + migration
php artisan make:model Article -mfsc       # Modèle + migration + factory + seeder + controller
php artisan make:controller ArticleController --api  # Contrôleur API (sans create/edit)
php artisan make:request StoreArticleRequest         # Form Request (validation)
php artisan make:job ProcessEmail                     # Job pour les queues
php artisan make:middleware EnsureIsAdmin             # Middleware personnalisé

# Base de données
php artisan migrate                   # Exécuter les migrations en attente
php artisan migrate:fresh --seed      # Recréer la BDD et la remplir (⚠️ efface tout)
php artisan db:seed                   # Exécuter les seeders
php artisan migrate:rollback          # Annuler la dernière migration

# Utilitaires
php artisan route:list                # Lister toutes les routes
php artisan model:show Article        # Inspecter un modèle (nouveauté L11)
php artisan config:cache              # Mettre en cache la configuration (production)
php artisan route:cache               # Mettre en cache les routes (production)
php artisan cache:clear               # Vider le cache de l'application
php artisan tinker                    # REPL interactif (tester du code Laravel)

La commande php artisan model:show Article est particulièrement utile : elle affiche les colonnes, les types, les attributs fillable/guarded, les relations et les casts d’un modèle Eloquent — sans avoir à ouvrir la migration ou le modèle. C’est un outil de débogage et d’introspection très pratique.

Les six tutoriels de cette série

Ce guide couvre l’environnement et l’architecture. Les cinq tutoriels suivants approfondissent chaque aspect technique de Laravel 11 de manière progressive et pratique :

• Créer une API REST avec Laravel 11 — Routes API, contrôleurs ressource, validation, réponses JSON structurées et versioning d’API.
• Maîtriser Eloquent ORM dans Laravel 11 — Relations (hasMany, belongsTo, morphTo), query scopes, casts, HasUuids, lazy loading et optimisation des requêtes N+1.
• Authentification avec Laravel Sanctum — Tokens API, protection des routes, SPA authentication avec CSRF, token abilities et expiration.
• Queues et jobs Laravel 11 — Drivers disponibles (database, Redis), création de jobs, dispatch, retry, supervision avec Supervisor et Horizon.
• Tester son application avec Pest — Installation de Pest 3, tests unitaires et fonctionnels, feature tests HTTP, Sanctum::actingAs, architecture testing.

Erreurs fréquentes à éviter

FAQ

Laravel 11 requiert-il obligatoirement PHP 8.4 ?
Non. Laravel 11 requiert PHP 8.2 au minimum et supporte PHP 8.3 et 8.4. PHP 8.4 n’est pas obligatoire mais apporte les property hooks et la visibilité asymétrique qui enrichissent l’expressivité de votre code.

Puis-je migrer un projet Laravel 10 vers Laravel 11 ?
Oui, mais la migration n’est pas automatique. Le guide officiel de mise à jour (laravel.com/docs/11.x/upgrade) liste les changements breaking : suppression des Kernels HTTP/Console, restructuration des service providers, etc. Pour les nouveaux projets, partez directement sur Laravel 11.

Quelle est la durée de support de Laravel 11 ?
Les corrections de bugs sont assurées jusqu’au 3 septembre 2025 et les corrections de sécurité jusqu’au 12 mars 2026. Pour un projet long terme, évaluez la migration vers Laravel 12 lorsqu’il sera disponible.

PHP 8.4 est-il disponible sur tous les hébergeurs partagés ?
Pas encore universellement. Les hébergeurs VPS (DigitalOcean, Hetzner, OVH, Hostinger VPS) permettent d’installer PHP 8.4 via le PPA Ondřej. Sur les hébergements mutualisés, vérifiez la disponibilité auprès de votre fournisseur — la plupart devraient proposer PHP 8.4 d’ici fin 2025.

Est-ce que Composer 2.x est rétrocompatible avec Composer 1.x ?
Composer 2.x est significativement plus rapide (chargement parallèle, cache amélioré) et gère correctement tous les packages Composer 1.x. La migration de 1.x vers 2.x est transparente dans la quasi-totalité des cas.

Comment gérer plusieurs versions PHP sur le même serveur ?
Avec le PPA Ondřej, les versions sont co-installables. Utilisez php8.2 artisan serve ou php8.4 artisan serve pour choisir la version par projet. Pour PHP-FPM, chaque version a son propre socket et son propre service systemd (php8.2-fpm, php8.4-fpm).

Références

• Annonce officielle PHP 8.4 — php.net
• Notes de version Laravel 11 — laravel.com
• Guide de migration Laravel 10 → 11 — laravel.com
• Installation de Composer — getcomposer.org
• PPA PHP Ondřej Surý — launchpad.net
• Laravel Herd — environnement local officiel