> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Introduction à l'authentification

> Bases de l'authentification Laravel : mise en place via un kit de démarrage et récupération de l'utilisateur authentifié.

## Qu'est-ce que l'authentification

L'authentification (Authentication) est le mécanisme qui vérifie « qui » est l'utilisateur qui accède à l'application.
Sur une application web, un formulaire de connexion reçoit un e-mail et un mot de passe : si les identifiants sont valides, les informations utilisateur sont stockées en session.
Pour les requêtes suivantes, cette session sert à identifier l'utilisateur.

L'authentification Laravel repose sur deux concepts : les « gardes » (guards) et les « providers ».

* **Garde** : définit comment authentifier l'utilisateur à chaque requête. Par défaut, la garde `session` utilise la session et les cookies pour gérer l'état.
* **Provider** : définit comment récupérer les utilisateurs depuis la base. Par défaut, Eloquent est utilisé.

<Info>
  Le fichier de configuration d'authentification est `config/auth.php`. Ses valeurs par défaut couvrent la plupart des applications web.
</Info>

```mermaid theme={null}
flowchart TD
    A["Requête de connexion"] --> B["Garde<br>(définit la méthode d'authentification)"]
    B --> C["Provider<br>(récupère l'utilisateur en DB)"]
    C --> D{"Vérification"}
    D -- "Succès" --> E["Enregistrement<br>en session"]
    E --> F["Redirection vers<br>la page authentifiée"]
    D -- "Échec" --> G["Redirection vers<br>la page de connexion"]
```

## Authentification via un kit de démarrage

Avec Laravel, il suffit de choisir un kit de démarrage lors de la création via `laravel new` pour que la connexion, l'inscription et la réinitialisation du mot de passe soient configurées automatiquement. C'est la méthode recommandée.

<Steps>
  <Step title="Créer l'application">
    Créez l'application avec l'installateur Laravel. Une invite propose de choisir un kit de démarrage.

    ```shell theme={null}
    laravel new my-app
    ```

    Vous pouvez choisir entre **React**, **Vue**, **Livewire** et **Svelte**.
    Sélectionnez celui qui correspond à la pile technique de votre équipe.
  </Step>

  <Step title="Installer les dépendances frontend">
    ```shell theme={null}
    cd my-app
    npm install && npm run build
    ```
  </Step>

  <Step title="Préparer la base de données">
    Vérifiez la configuration de base de données dans `.env`, puis exécutez les migrations.

    ```shell theme={null}
    php artisan migrate
    ```

    La migration initiale, qui inclut la table `users`, est appliquée.
  </Step>

  <Step title="Démarrer le serveur de développement">
    ```shell theme={null}
    composer run dev
    ```

    En vous rendant sur `http://localhost:8000`, vous verrez les liens « Register » et « Log in ». Accédez à `/register` pour créer un utilisateur.
  </Step>
</Steps>

Le kit de démarrage donne accès immédiat aux fonctionnalités suivantes.

| Fonctionnalité                   | URL                 |
| -------------------------------- | ------------------- |
| Inscription                      | `/register`         |
| Connexion                        | `/login`            |
| Réinitialisation du mot de passe | `/forgot-password`  |
| Vérification de l'e-mail         | `/email/verify`     |
| Édition du profil                | `/settings/profile` |

<Tip>
  Le code généré par le kit (contrôleurs, routes, vues) se trouve dans votre application. Vous êtes libre de le modifier et de le personnaliser.
</Tip>

### Kits de démarrage disponibles

#### React

Application SPA moderne construite avec React 19, TypeScript, Tailwind et [shadcn/ui](https://ui.shadcn.com).
Grâce à [Inertia](https://inertiajs.com), vous conservez le routage côté serveur tout en utilisant un frontend React.

#### Vue

Utilise la Composition API de Vue, TypeScript, Tailwind et [shadcn-vue](https://www.shadcn-vue.com/).
Comme pour React, Inertia sert de pont avec le backend.

#### Livewire

Utilise [Livewire](https://livewire.laravel.com) pour construire des UI dynamiques uniquement en PHP.
Idéal pour les équipes centrées sur Blade ou celles qui veulent éviter les frameworks JavaScript.
La bibliothèque de composants [Flux UI](https://fluxui.dev) est incluse.

#### Svelte

Utilise Svelte 5, TypeScript, Tailwind et [shadcn-svelte](https://www.shadcn-svelte.com/).
Combiné à Inertia pour construire une SPA moderne.

## Façade d'authentification

La façade `Auth` permet d'obtenir l'utilisateur courant et de vérifier l'état d'authentification.

### Récupérer l'utilisateur authentifié

```php theme={null}
use Illuminate\Support\Facades\Auth;

// Utilisateur courant
$user = Auth::user();

// ID uniquement
$id = Auth::id();
```

Dans un contrôleur, vous pouvez aussi l'obtenir depuis l'objet `Request`.

```php theme={null}
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class DashboardController extends Controller
{
    public function index(Request $request)
    {
        $user = $request->user();

        return view('dashboard', ['user' => $user]);
    }
}
```

### Vérifier l'état d'authentification

`Auth::check()` retourne `true` si l'utilisateur est connecté, `false` sinon.

```php theme={null}
use Illuminate\Support\Facades\Auth;

if (Auth::check()) {
    // Connecté
} else {
    // Non connecté
}
```

Dans un template Blade, les directives `@auth` et `@guest` sont pratiques.

```blade theme={null}
@auth
    <p>Bonjour, {{ Auth::user()->name }}</p>
    <a href="/logout">Déconnexion</a>
@endauth

@guest
    <a href="/login">Connexion</a>
    <a href="/register">Inscription</a>
@endguest
```

## Protéger des routes

Pour restreindre une route aux utilisateurs connectés, utilisez le middleware `auth`.

```php theme={null}
// routes/web.php

// Accessible aux utilisateurs authentifiés uniquement
Route::get('/dashboard', function () {
    return view('dashboard');
})->middleware('auth');
```

Un utilisateur non authentifié est redirigé automatiquement vers `/login`.

Pour protéger plusieurs routes, utilisez un groupe.

```php theme={null}
Route::middleware('auth')->group(function () {
    Route::get('/dashboard', [DashboardController::class, 'index']);
    Route::get('/profile', [ProfileController::class, 'show']);
    Route::get('/settings', [SettingsController::class, 'index']);
});
```

<Warning>
  Sans le middleware `auth`, un utilisateur non connecté peut accéder aux routes. Appliquez-le systématiquement aux routes protégées.
</Warning>

### Routes réservées aux invités

Pour rediriger les utilisateurs déjà connectés, utilisez le middleware `guest`.
Appliqué aux pages de connexion et d'inscription, il redirige les utilisateurs connectés vers le tableau de bord.

```php theme={null}
Route::middleware('guest')->group(function () {
    Route::get('/login', [AuthController::class, 'showLogin']);
    Route::get('/register', [AuthController::class, 'showRegister']);
});
```

## Authentification manuelle

Pour implémenter la connexion manuellement (sans kit de démarrage), utilisez `Auth::attempt()`.

```php theme={null}
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Http\RedirectResponse;
use Illuminate\Support\Facades\Auth;

class LoginController extends Controller
{
    public function login(Request $request): RedirectResponse
    {
        $credentials = $request->validate([
            'email' => ['required', 'email'],
            'password' => ['required'],
        ]);

        if (Auth::attempt($credentials)) {
            // Succès — régénérer la session pour prévenir les attaques CSRF
            $request->session()->regenerate();

            return redirect()->intended('/dashboard');
        }

        // Échec
        return back()->withErrors([
            'email' => 'L\'e-mail ou le mot de passe est incorrect.',
        ])->onlyInput('email');
    }
}
```

Le premier argument est un tableau d'identifiants.
Le mot de passe est comparé automatiquement au hachage : passez-le en clair.

Pour implémenter la fonctionnalité « Se souvenir de moi », passez `true` comme second argument.

```php theme={null}
// Utilise la valeur de la case à cocher « Se souvenir de moi »
Auth::attempt($credentials, $request->boolean('remember'));
```

<Info>
  Même en implémentation manuelle, inspirez-vous du code du kit de démarrage : c'est un excellent exemple de mise en œuvre sécurisée.
</Info>

## Déconnexion

Appelez `Auth::logout()` pour déconnecter l'utilisateur.
Il est recommandé d'invalider la session et de régénérer le token CSRF en même temps.

```php theme={null}
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Http\RedirectResponse;
use Illuminate\Support\Facades\Auth;

class LogoutController extends Controller
{
    public function logout(Request $request): RedirectResponse
    {
        Auth::logout();

        // Invalider la session
        $request->session()->invalidate();

        // Régénérer le token CSRF
        $request->session()->regenerateToken();

        return redirect('/');
    }
}
```

Utilisez la méthode POST pour la route.

```php theme={null}
Route::post('/logout', [LogoutController::class, 'logout'])->middleware('auth');
```

Dans un template Blade, utilisez un formulaire pour envoyer une requête POST.

```blade theme={null}
<form method="POST" action="/logout">
    @csrf
    <button type="submit">Déconnexion</button>
</form>
```

## Récapitulatif

| Objectif                              | Méthode                             |
| ------------------------------------- | ----------------------------------- |
| Ajouter rapidement l'authentification | Kit de démarrage (`laravel new`)    |
| Récupérer l'utilisateur courant       | `Auth::user()` / `$request->user()` |
| Vérifier l'état de connexion          | `Auth::check()`                     |
| Protéger une route                    | `->middleware('auth')`              |
| Se connecter manuellement             | `Auth::attempt($credentials)`       |
| Se déconnecter                        | `Auth::logout()`                    |

## Prochaines étapes

<Card title="Middleware" icon="shield-halved" href="/fr/middleware">
  Découvrez plus en détail le middleware `auth` et la création de vos propres middlewares.
</Card>


## Related topics

- [Introduction aux tests](/fr/testing.md)
- [Implémenter un guard d'authentification personnalisé](/fr/advanced/custom-auth-guard.md)
- [Introduction à Svelte — bases pour l'utiliser avec Inertia × Laravel](/fr/blog/svelte-introduction.md)
- [Introduction à React — bases pour l'utiliser avec Inertia × Laravel](/fr/blog/react-introduction.md)
- [Introduction à Vue.js — les bases pour l'utiliser avec Inertia × Laravel](/fr/blog/vue-introduction.md)