> ## Documentation Index > Fetch the complete documentation index at: https://kawax.biz/llms.txt > Use this file to discover all available pages before exploring further. # Laravel Fortify et les starter kits > Découvrez la conception interne du backend d'authentification agnostique du frontend, Laravel Fortify. Pourquoi les starter kits actuels utilisent Fortify, la configuration de FortifyServiceProvider, l'activation du 2FA et des passkeys. ## Qu'est-ce que Fortify [Laravel Fortify](https://github.com/laravel/fortify) est une implémentation de backend d'authentification indépendante du frontend. Il fournit toutes les routes et contrôleurs nécessaires pour la connexion, l'inscription, la réinitialisation du mot de passe, la vérification e-mail, le 2FA et les passkeys. Fortify n'a pas d'interface utilisateur. Il fonctionne lorsque le starter kit ou votre propre interface envoie des requêtes aux routes de Fortify. La philosophie de conception « indépendante du frontend » est centrale. Que vous utilisiez Blade, Inertia (React/Vue/Svelte) ou une API, vous réutilisez le même backend d'authentification. C'est la raison pour laquelle Fortify continue d'être utilisé aussi longtemps. ## Historique : de Jetstream aux starter kits actuels ```mermaid theme={null} timeline title Évolution de Fortify 2020 Laravel 8 : Apparu en même temps que Jetstream : Fortify installé automatiquement comme moteur en coulisses de Jetstream 2020 Laravel 8 : Apparition de Breeze (sans Fortify) : Indépendant, comme échafaudage d'authentification simple 2025 Refonte des starter kits : Les starter kits React/Vue nécessitent le support du 2FA : Fortify est réadopté → tout l'authentification passe sous Fortify 2026 Support des passkeys : Ajout de la fonctionnalité Passkeys à Fortify ``` ### Pourquoi Fortify est utilisé dans les starter kits actuels Les starter kits React/Vue initiaux étaient implémentés sans Fortify. Mais **lorsque la prise en charge de l'authentification à deux facteurs (2FA) est devenue nécessaire, Fortify a été adopté tel quel**, ce qui a fait basculer toute l'authentification sur une base Fortify. Comme Fortify est conçu pour être « indépendant du frontend », il s'accorde bien avec les starter kits basés sur Inertia, et il est toujours utilisé aujourd'hui. Fortify est actuellement le package d'authentification officiel Laravel utilisé sur la plus longue durée. Depuis son apparition en 2020, il reste en service au fil de ses avatars : Jetstream → starter kits actuels. ## Structure des starter kits actuels Dans les starter kits React/Vue, Fortify est configuré via ces fichiers. * `app/Providers/FortifyServiceProvider.php` — enregistrement des vues, actions et rate limits * `config/fortify.php` — fonctionnalités activées et paramètres d'authentification ### Principaux paramètres de `config/fortify.php` ```php theme={null} use Laravel\Fortify\Features; return [ 'guard' => 'web', 'username' => 'email', 'home' => '/dashboard', 'limiters' => [ 'login' => 'login', 'two-factor' => 'two-factor', ], 'features' => [ Features::registration(), Features::resetPasswords(), Features::emailVerification(), Features::twoFactorAuthentication([ 'confirm' => true, 'confirmPassword' => true, ]), ], ]; ``` Dans les starter kits, les passkeys (`Features::passkeys()`) ne sont pas activées par défaut. Pour les activer, ajoutez-les au tableau `features`. ## Configuration de `FortifyServiceProvider` Le `FortifyServiceProvider` du starter kit remplit trois rôles. ### 1. Configuration des actions ```php theme={null} private function configureActions(): void { Fortify::resetUserPasswordsUsing(ResetUserPassword::class); Fortify::createUsersUsing(CreateNewUser::class); } ``` Personnalisez la logique de création d'utilisateur et de réinitialisation du mot de passe via les classes placées dans `app/Actions/Fortify/`. La validation et le hachage sont regroupés ici. ### 2. Configuration des vues ```php theme={null} private function configureViews(): void { Fortify::loginView(fn (Request $request) => Inertia::render('auth/login', [ 'canResetPassword' => Features::enabled(Features::resetPasswords()), 'canRegister' => Features::enabled(Features::registration()), 'status' => $request->session()->get('status'), ])); Fortify::resetPasswordView(fn (Request $request) => Inertia::render('auth/reset-password', [ 'email' => $request->email, 'token' => $request->route('token'), ])); Fortify::requestPasswordResetLinkView( fn (Request $request) => Inertia::render('auth/forgot-password', [ 'status' => $request->session()->get('status'), ]) ); Fortify::verifyEmailView( fn (Request $request) => Inertia::render('auth/verify-email', [ 'status' => $request->session()->get('status'), ]) ); Fortify::registerView(fn () => Inertia::render('auth/register')); Fortify::twoFactorChallengeView(fn () => Inertia::render('auth/two-factor-challenge')); Fortify::confirmPasswordView(fn () => Inertia::render('auth/confirm-password')); } ``` Chaque méthode de vue reçoit une closure qui retourne un composant Inertia. Le point clé est l'utilisation de `Features::enabled()` pour vérifier les feature flags et les passer à la vue. Dans une application Blade, retournez `view('auth.login')` au lieu de `Inertia::render(...)`. Même en changeant de frontend, seul `FortifyServiceProvider` doit être modifié ; la logique d'authentification ne change pas. ### 3. Configuration du rate limiting ```php theme={null} private function configureRateLimiting(): void { RateLimiter::for('two-factor', function (Request $request) { return Limit::perMinute(5)->by($request->session()->get('login.id')); }); RateLimiter::for('login', function (Request $request) { $throttleKey = Str::transliterate( Str::lower($request->input(Fortify::username())) . '|' . $request->ip() ); return Limit::perMinute(5)->by($throttleKey); }); } ``` * Limiteur `login` : limite par combinaison e-mail + adresse IP (protection contre le brute-force) * Limiteur `two-factor` : limite par ID de tentative de connexion en session Enregistrez sur `RateLimiter::for()` des clés qui correspondent à celles de la clé `limiters` de `config/fortify.php`. ## Principales fonctionnalités et routes enregistrées Voici les principales routes enregistrées par Fortify, classées par fonctionnalité. | Fonctionnalité | Méthode | Route | | ------------------------------ | ------------------------- | ---------------------------------- | | Connexion | `GET` | `/login` | | Connexion | `POST` | `/login` | | Déconnexion | `POST` | `/logout` | | Inscription | `GET` | `/register` | | Inscription | `POST` | `/register` | | Demande de réinitialisation | `GET` / `POST` | `/forgot-password` | | Réinitialisation | `GET` / `POST` | `/reset-password` | | Vérification e-mail | `GET` | `/email/verify` | | Renvoi du lien de vérification | `POST` | `/email/verification-notification` | | Confirmation du mot de passe | `GET` / `POST` | `/user/confirm-password` | | Activation du 2FA | `POST` | `/user/two-factor-authentication` | | Challenge 2FA | `GET` / `POST` | `/two-factor-challenge` | | Connexion par passkey | `GET` / `POST` | `/passkeys/login` | | Gestion des passkeys | `GET` / `POST` / `DELETE` | `/user/passkeys` | Vérifiez les routes réellement enregistrées avec `php artisan route:list --name=fortify` ou simplement `php artisan route:list`. ## Authentification à deux facteurs (2FA) Dans les starter kits, `Features::twoFactorAuthentication()` est activée. `confirm` et `confirmPassword` sont tous deux à `true`. | Option | Signification | | ----------------- | ----------------------------------------------------------------------------- | | `confirm` | Exige une confirmation par code d'authentification après activation | | `confirmPassword` | Exige une confirmation du mot de passe avant de modifier la configuration 2FA | Depuis l'écran de paramétrage 2FA, l'utilisateur peut effectuer les opérations suivantes. Envoyez une requête POST à `/user/two-factor-authentication`. En cas de succès, le statut `two-factor-authentication-enabled` est mis en session. Envoyez une requête GET à `/user/two-factor-qr-code`. Le SVG du QR code à scanner par l'application d'authentification est retourné. Envoyez une requête POST avec le code à `/user/confirmed-two-factor-authentication` pour finaliser la configuration. Envoyez une requête GET à `/user/two-factor-recovery-codes`, récupérez les codes de récupération et stockez-les en lieu sûr. ## Passkeys Les passkeys sont une fonctionnalité récemment ajoutée à Fortify. C'est une authentification sans mot de passe utilisant WebAuthn, compatible avec Face ID, Touch ID, Windows Hello et les clés de sécurité matérielles. ### Activation Ajoutez au tableau `features` de `config/fortify.php`. ```php theme={null} 'features' => [ Features::registration(), Features::resetPasswords(), Features::emailVerification(), Features::twoFactorAuthentication([ 'confirm' => true, 'confirmPassword' => true, ]), Features::passkeys([ 'confirmPassword' => true, ]), ], ``` Ensuite, ajoutez le contrat `PasskeyUser` et le trait `PasskeyAuthenticatable` au modèle `User`. ```php theme={null} use Illuminate\Foundation\Auth\User as Authenticatable; use Laravel\Fortify\Contracts\PasskeyUser; use Laravel\Fortify\PasskeyAuthenticatable; class User extends Authenticatable implements PasskeyUser { use PasskeyAuthenticatable; } ``` Les paramètres WebAuthn sont gérés dans la clé `passkeys` de `config/fortify.php`. ```php theme={null} 'passkeys' => [ 'relying_party_id' => parse_url(config('app.url'), PHP_URL_HOST), 'allowed_origins' => [config('app.url')], 'user_handle_secret' => config('app.key'), 'timeout' => 60000, ], ``` Les passkeys de Fortify s'appuient en interne sur le package Composer `laravel/passkeys`. Il n'est pas nécessaire de publier le fichier de configuration de `laravel/passkeys` ; la clé `passkeys` de `config/fortify.php` est prioritaire. Pour les détails d'implémentation des passkeys (client JS `@laravel/passkeys`, helpers React/Vue/Svelte, etc.), consultez aussi [Introduction aux passkeys](/fr/blog/passkeys-introduction). ## Pages associées Découvrez comment créer un guard d'authentification personnalisé en implémentant les interfaces Guard et StatefulGuard. Consultez la documentation officielle pour l'installation, l'ensemble des fonctionnalités et la personnalisation. ## Related topics - [Construire une SPA avec Inertia.js](/fr/blog/inertia-introduction.md) - [Guide de migration de laravel/ui vers Fortify](/fr/blog/ui-to-fortify.md) - [Laravel Maestro — l'orchestrateur de développement des starter kits](/fr/blog/maestro-introduction.md) - [Créer un starter kit Laravel](/fr/advanced/starter-kit-creation.md) - [Première analyse de Laravel Passkeys (passkeys-server + @laravel/passkeys)](/fr/blog/passkeys-introduction.md)