Caching avec Laravel et Redis

Pourquoi Caching avec Laravel et Redis ?

Le caching est une technique essentielle pour améliorer les performances des applications web en stockant temporairement les données fréquemment accédées dans la mémoire du serveur ou dans un système de stockage distribué comme Redis. En utilisant le caching, vous pouvez réduire le temps de réponse et la charge sur votre base de données, ce qui est particulièrement important pour les applications à faible latence.

Un cas d'usage concret peut être une application e-commerce : lorsque des utilisateurs consultent les détails d'un produit, ces données sont souvent récupérées depuis la base de données. Si vous utilisez le caching, les détails du produit peuvent être stockés en cache pendant une certaine période, réduisant ainsi les requêtes à la base de données et améliorant ainsi l'expérience utilisateur.

Prerequis

• Connaissance avancée de Laravel
• Installation de PHP >= 7.3
• Installation de Composer (gestionnaire de dépendances)
• Installation de Redis
• Configuration d'un environnement de développement (XAMPP, MAMP, Docker)

Concepts fondamentaux

1. Cache Store

Dans Laravel, vous pouvez configurer différents stores de cache tels que file, database, et redis. Le store redis est particulièrement adapté pour les applications à faible latence en raison de sa capacité à stocker des données en mémoire.

// config/cache.php
return [
    'default' => env('CACHE_DRIVER', 'redis'),
    'stores' => [
        'redis' => [
            'driver' => 'redis',
            'connection' => 'default',
        ],
    ],
];

2. Cache Tags

Les tags vous permettent de regrouper des éléments de cache et de les supprimer en une seule opération.

Cache::tags(['authors', 'books'])->put('author:1', $author, 60);

3. Permanent Cache

Il existe un type spécial de cache appelé "permanent" qui n'expire jamais.

Cache::forever('name', 'Taylor');

Mise en pratique : projet fil rouge

Nous allons créer une application simple pour gérer les tâches à faire (To-Do List). Cette application va utiliser Redis comme système de cache pour accélérer le chargement des données.

Étape 1 : Créer un nouveau projet Laravel

composer create-project --prefer-dist laravel/laravel todo-app
cd todo-app

Étape 2 : Installer Redis et configurer la connexion

Assurez-vous que Redis est installé sur votre système. Vous pouvez vérifier cela en exécutant redis-cli ping qui doit renvoyer PONG.

Editez le fichier .env pour configurer la connexion à Redis :

CACHE_DRIVER=redis
REDIS_HOST=127.0.0.1
REDIS_PASSWORD=null
REDIS_PORT=6379

Étape 3 : Créer un modèle et une migration

php artisan make:model Task -m

Editez la migration pour ajouter des 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->boolean('completed')->default(false);
        $table->timestamps();
    });
}

Exécutez la migration :

php artisan migrate

Étape 4 : Créer un contrôleur et des routes

php artisan make:controller TaskController

Ajoutez les méthodes suivantes au contrôleur TaskController :

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

use Illuminate\Http\Request;
use App\Models\Task;
use Cache;

class TaskController extends Controller
{
    public function index()
    {
        $tasks = Cache::remember('tasks', now()->addMinutes(30), function () {
            return Task::all();
        });

        return view('tasks.index', compact('tasks'));
    }

    public function store(Request $request)
    {
        $task = Task::create($request->all());
        Cache::forget('tasks');
        return redirect()->route('tasks.index');
    }
}

Étape 5 : Créer les vues

Créez un fichier index.blade.php dans le répertoire resources/views/tasks/ :

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

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

<ul>
    @foreach ($tasks as $task)
        <li>$task->title - $task->description</li>
    @endforeach
</ul>
@endsection

Ajoutez une route dans routes/web.php :

// routes/web.php
Route::resource('tasks', TaskController::class);

Étape 6 : Créer un formulaire pour ajouter des tâches

Créez un fichier create.blade.php dans le répertoire resources/views/tasks/ :

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

@section('content')
<h1>Add Task</h1>
<form action="route('tasks.store')" method="POST">
    @csrf
    <div class="form-group">
        <label for="title">Title:</label>
        <input type="text" name="title" id="title" class="form-control">
    </div>
    <div class="form-group">
        <label for="description">Description:</label>
        <textarea name="description" id="description" class="form-control"></textarea>
    </div>
    <button type="submit" class="btn btn-primary">Add Task</button>
</form>
@endsection

Étape 7 : Configurer la vue principale

Créez un fichier app.blade.php dans le répertoire resources/views/ :

<!-- resources/views/layouts/app.blade.php -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Task Manager</title>
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css">
</head>
<body>
    <div class="container mt-5">
        @yield('content')
    </div>
</body>
</html>

Erreurs frequentes et debugging

1. Erreur : Cache key is not a string

## ❌ Mauvais
Cache::put(123, 'value', now()->addMinutes(30));

## ✅ Correct
Cache::put('task:123', 'value', now()->addMinutes(30));

2. Erreur : Cache store [redis] not found

## ❌ Mauvais
config(['cache.default' => 'file']);

## ✅ Correct
config(['cache.default' => 'redis']);

3. Erreur : Cache tag is not a string or array

## ❌ Mauvais
Cache::tags(123)->put('task:123', 'value', now()->addMinutes(30));

## ✅ Correct
Cache::tags(['tasks'])->put('task:123', 'value', now()->addMinutes(30));

Pour aller plus loin

1. Utiliser des callbacks pour le cache

Les callbacks permettent de définir la logique de récupération des données à mettre en cache.

$tasks = Cache::remember('tasks', 60, function () {
    return Task::all();
});

2. Expérimenter avec d'autres stores de cache

Tentez d'utiliser différents stores de cache comme database pour voir la différence des performances.

3. Créer un système de sauvegarde automatique

Créez un système qui sauvegarde les données en base de données toutes les heures pour s'assurer que le cache est cohérent.

Cache::put('tasks', Task::all(), now()->addHours(1));

Défi pratique

Créez une application CLI (Command Line Interface) qui utilise Laravel et Redis pour stocker et récupérer des informations sur les utilisateurs. Cette application devrait être capable de :

• Ajouter un utilisateur
• Supprimer un utilisateur
• Mettre à jour un utilisateur
• Afficher tous les utilisateurs

Utilisez le caching pour accélérer les opérations d'accès aux données.