Authentification dans Laravel

Pourquoi Authentification dans Laravel ?

L'authentification est un aspect essentiel des applications web modernes. Elle permet d'assurer la sécurité et la confidentialité des utilisateurs, en les identifiant et en contrôlant leur accès aux différentes parties de l’application. En tant que développeur(e), comprendre comment mettre en place une authentification robuste dans Laravel est crucial pour développer des applications sécurisées et fiables.

Un cas d'usage concret serait un site e-commerce, où chaque utilisateur doit être authentifié pour accéder à son compte personnel, voir l'historique de ses achats, modifier sa commande en cours, etc. Sans une authentification solide, les informations des utilisateurs seraient vulnérables et potentiellement volées.

Prerequis

Pour suivre ce tutoriel, vous devez avoir les connaissances suivantes :

• Connaissances de base de Laravel
• Compétence en PHP
• Familiarité avec le système de fichiers et la gestion des commandes en ligne
• Maîtrise des bases du HTML et CSS pour une meilleure compréhension de l'interface utilisateur

Vous aurez besoin des outils suivants :

• PHP (version recommandée : 7.3 ou plus tard)
• Composer (gestionnaire de dépendances PHP)
• Laravel Installer (pour créer rapidement un nouveau projet Laravel)
• Un éditeur de code (comme Visual Studio Code, Sublime Text, etc.)
• Un serveur local comme XAMPP, WAMP ou Homestead

Concepts fondamentaux

Utilisateurs et Roles

Dans Laravel, les utilisateurs sont représentés par le modèle App\Models\User. Les rôles peuvent être gérés en utilisant des packages tiers comme Spatie Permissions.

// app/Models/User.php
namespace App\Models;

use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;

class User extends Authenticatable
{
    use Notifiable;

    protected $fillable = [
        'name', 'email', 'password',
    ];

    protected $hidden = [
        'password', 'remember_token',
    ];
}

Authentification automatique

Laravel utilise le middleware auth pour gérer l'authentification des utilisateurs. Ce middleware est appliqué dans les routes qui nécessitent une authentification.

// web.php
Route::middleware('auth')->get('/dashboard', function () {
    return view('dashboard');
});

Gestionnaire d'authentification

Laravel fournit un service Auth pour gérer l'authentification des utilisateurs. Vous pouvez utiliser ce service dans vos contrôleurs pour vous connecter, déconnecter et vérifier les identifiants des utilisateurs.

// app/Http/Controllers/Auth/LoginController.php
namespace App\Http\Controllers\Auth;

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

class LoginController extends Controller
{
    public function showLoginForm()
    {
        return view('auth.login');
    }

    public function login(Request $request)
    {
        if (Auth::attempt(['email' => $request->email, 'password' => $request->password])) {
            return redirect()->intended('dashboard');
        }

        return back()->withErrors([
            'email' => 'Ces identifiants ne correspondent pas à nos enregistrements.',
        ]);
    }
}

Middleware d'autorisation

Laravel permet de gérer les autorisations via des middleware. Vous pouvez créer un middleware personnalisé pour vérifier si l'utilisateur a le droit d'accéder à une ressource.

// app/Http/Middleware/CheckRole.php
namespace App\Http\Middleware;

use Closure;
use Illuminate\Support\Facades\Auth;

class CheckRole
{
    public function handle($request, Closure $next, $role)
    {
        if (!Auth::check() || !Auth::user()->hasRole($role)) {
            abort(403);
        }

        return $next($request);
    }
}

Gestion des sessions

Laravel gère les sessions de manière transparente grâce à sa fonctionnalité Session. Vous pouvez utiliser ces sessions pour stocker et récupérer des données utilisateurs.

// app/Http/Controllers/Auth/LoginController.php
public function login(Request $request)
{
    if (Auth::attempt(['email' => $request->email, 'password' => $request->password])) {
        $user = Auth::user();
        session(['user_id' => $user->id]);
        return redirect()->intended('dashboard');
    }
}

Mise en pratique : projet fil rouge

Création du projet

Commencez par créer un nouveau projet Laravel :

composer create-project --prefer-dist laravel/laravel task-manager
cd task-manager

Configuration de la base de données

Modifiez le fichier .env pour configurer votre base de données.

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=task_manager
DB_USERNAME=root
DB_PASSWORD=

Créez la base de données et les tables :

php artisan migrate

Création des modèles et migrations

Créez un modèle Task et sa migration.

php artisan make:model Task -m

Editez la migration pour ajouter les champs nécessaires :

// database/migrations/xxxx_xx_xx_xxxxxx_create_tasks_table.php
public function up()
{
    Schema::create('tasks', function (Blueprint $table) {
        $table->id();
        $table->string('title');
        $table->text('description')->nullable();
        $table->foreignId('user_id')->constrained()->onDelete('cascade');
        $table->timestamps();
    });
}

Création des contrôleurs

Créez un contrôleur TaskController.

php artisan make:controller TaskController --resource

Ajoutez les méthodes nécessaires dans le contrôleur :

// app/Http/Controllers/TaskController.php
namespace App\Http\Controllers;

use App\Models\Task;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

class TaskController extends Controller
{
    public function index()
    {
        $tasks = Task::where('user_id', Auth::id())->get();
        return view('tasks.index', compact('tasks'));
    }

    public function create()
    {
        return view('tasks.create');
    }

    public function store(Request $request)
    {
        $task = new Task;
        $task->title = $request->title;
        $task->description = $request->description;
        $task->user_id = Auth::id();
        $task->save();

        return redirect()->route('tasks.index');
    }

    public function edit(Task $task)
    {
        return view('tasks.edit', compact('task'));
    }

    public function update(Request $request, Task $task)
    {
        $task->title = $request->title;
        $task->description = $request->description;
        $task->save();

        return redirect()->route('tasks.index');
    }

    public function destroy(Task $task)
    {
        $task->delete();
        return redirect()->route('tasks.index');
    }
}

Création des vues

Créez les vues pour la gestion des tâches.

php artisan make:view tasks.index --plain
php artisan make:view tasks.create --plain
php artisan make:view tasks.edit --plain

Editez les vues pour ajouter le code HTML et PHP nécessaire :

<!-- resources/views/tasks/index.blade.php -->
@extends('layouts.app')

@section('content')
<h1>Tasks</h1>
<a href="route('tasks.create')" class="btn btn-primary">Create New Task</a>

<table class="table">
    <thead>
        <tr>
            <th>Title</th>
            <th>Description</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach($tasks as $task)
        <tr>
            <td>$task->title</td>
            <td>$task->description</td>
            <td>
                <a href="route('tasks.edit', $task)" class="btn btn-warning">Edit</a>
                <form action="route('tasks.destroy', $task)" method="POST" style="display: inline-block;">
                    @csrf
                    @method('DELETE')
                    <button type="submit" class="btn btn-danger" onclick="return confirm('Are you sure?')">Delete</button>
                </form>
            </td>
        </tr>
        @endforeach
    </tbody>
</table>
@endsection

Routes

Ajoutez les routes dans web.php :

// web.php
Route::resource('/tasks', TaskController::class)->middleware('auth');
Auth::routes();

Erreurs frequentes et debugging

1. Erreur de connexion

Code incorrect :

public function login(Request $request)
{
    if (Auth::attempt(['email' => $request->email, 'password' => $request->password])) {
        return redirect()->intended('dashboard');
    }

    return back()->withErrors([
        'email' => 'Ces identifiants ne correspondent pas à nos enregistrements.',
    ]);
}

Code correct :

public function login(Request $request)
{
    if (Auth::attempt(['email' => $request->email, 'password' => $request->password])) {
        return redirect()->intended('dashboard');
    }

    return back()->withErrors([
        'email' => 'Ces identifiants ne correspondent pas à nos enregistrements.',
    ]);
}

2. Erreur de redirection

Code incorrect :

public function store(Request $request)
{
    $task = new Task;
    $task->title = $request->title;
    $task->description = $request->description;
    $task->user_id = Auth::id();
    $task->save();

    return redirect()->route('tasks.index');
}

Code correct :

public function store(Request $request)
{
    $task = new Task;
    $task->title = $request->title;
    $task->description = $request->description;
    $task->user_id = Auth::id();
    $task->save();

    return redirect()->route('tasks.index');
}

3. Erreur de session

Code incorrect :

public function login(Request $request)
{
    if (Auth::attempt(['email' => $request->email, 'password' => $request->password])) {
        $user = Auth::user();
        session(['user_id' => $user->id]);
        return redirect()->intended('dashboard');
    }
}

Code correct :

public function login(Request $request)
{
    if (Auth::attempt(['email' => $request->email, 'password' => $request->password])) {
        $user = Auth::user();
        session(['user_id' => $user->id]);
        return redirect()->intended('dashboard');
    }
}

Pour aller plus loin

1. Utilisation de Spatie Permissions

Spatie Permissions est un package populaire pour gérer les rôles et permissions dans Laravel.

Lien vers Spatie Permissions

2. Authentification API avec Sanctum

Laravel Sanctum facilite l'authentification d'applications API en utilisant des tokens de porteur JWT.

Lien vers Sanctum Documentation

3. Sécurité des formulaires

Utilisez la fonction @csrf pour protéger vos formulaires contre les attaques CSRF.

<form action="route('tasks.store')" method="POST">
    @csrf
    <input type="text" name="title" required>
    <textarea name="description"></textarea>
    <button type="submit">Create Task</button>
</form>

Défi pratique

Créez une application de gestion de projet simple avec des fonctionnalités comme la création et l'édition de projets, le suivi des tâches associées à chaque projet, et les autorisations basées sur les rôles (par exemple, un rôle "admin" pour créer/modifier/supprimer des projets).