Bien sûr ! Voici un tutoriel détaillé sur les files d'attente (queues) dans Laravel, couvrant la création d'un job, l'utilisation du job middleware, le dispatching des jobs et le job batching. Ce tutoriel inclut également des graphiques et des mindmaps utilisant Mermaid.js.

Table des matières

Introduction
Présentation du concept de File d'Attente (Queue)
Configuration de la file d'attente
Création d’un job
Job Middleware
Dispatching jobs
Job Batching
Conclusion

1. Introduction

Les files d'attente (queues) dans Laravel permettent de différer l'exécution de tâches longues ou intensives, telles que l'envoi d'e-mails, le traitement d'images, etc., afin d'améliorer la performance de votre application. Ce tutoriel vous guidera à travers la mise en place et l'utilisation des files d'attente dans une application Laravel.

Mindmap avec Mermaid.js

mindmap
    root(Tutoriel)
        Introduction
        Présentation du concept de File d'Attente (Queue)
        Configuration de la file d'attente
        Création d’un job
        Job Middleware
        Dispatching jobs
        Job Batching
        Conclusion

2. Présentation du concept de File d'Attente (Queue)

Les files d'attente permettent de traiter des tâches en arrière-plan, ce qui améliore la performance de votre application en ne bloquant pas les requêtes HTTP principales.

Mindmap des concepts avec Mermaid.js

mindmap
    root(File d'Attente (Queue))
        Concept
            Traitement asynchrone
            Amélioration de la performance
            Tâches longues
        Drivers
            Database
            Beanstalkd
            Amazon SQS
            Redis
            Null Queue

Graphique des concepts avec Mermaid.js

graph TD;
    A[Concept] --> B[Traitement asynchrone];
    A --> C[Amélioration de la performance];
    A --> D[Tâches longues];
    E[Drivers] --> F[Database];
    E --> G[Beanstalkd];
    E --> H[Amazon SQS];
    E --> I[Redis];
    E --> J[Null Queue];

3. Configuration de la file d'attente

Avant de commencer, configurez votre file d'attente dans le fichier .env et config/queue.php.

Configuration dans `.env`

QUEUE_CONNECTION=redis

Configuration dans `config/queue.php`

Assurez-vous que la configuration pour Redis est correcte :

'redis' => [
    'driver' => 'redis',
    'connection' => 'default',
],

Installation de Redis

Si vous utilisez Redis, installez-le sur votre machine et vérifiez que le service Redis est en cours d'exécution.

sudo apt-get install redis-server
sudo systemctl start redis-server
sudo systemctl enable redis-server

4. Création d’un job

Créez un job pour une tâche spécifique, par exemple, l'envoi d'un e-mail.

Création du job

php artisan make:job SendEmailJob

Implémentation du job

Editez le fichier app/Jobs/SendEmailJob.php :

namespace App\Jobs;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\Mail;
use App\Mail\WelcomeMail;

class SendEmailJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    protected $email;

    public function __construct($email)
    {
        $this->email = $email;
    }

    public function handle()
    {
        Mail::to($this->email)->send(new WelcomeMail());
    }
}

5. Job Middleware

Les middlewares pour les jobs permettent d'exécuter du code avant et après le traitement d'un job.

Création d'un middleware

php artisan make:middleware LogJob

Implémentation du middleware

Editez le fichier app/Jobs/Middleware/LogJob.php :

namespace App\Jobs\Middleware;

class LogJob
{
    public function handle($job, $next)
    {
        \Log::info("Job started: " . get_class($job));

        $next($job);

        \Log::info("Job finished: " . get_class($job));
    }
}

Application du middleware au job

Editez le fichier app/Jobs/SendEmailJob.php pour appliquer le middleware :

namespace App\Jobs;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\Middleware\WithoutOverlapping;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\Mail;
use App\Mail\WelcomeMail;
use App\Jobs\Middleware\LogJob;

class SendEmailJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    protected $email;

    public function __construct($email)
    {
        $this->email = $email;
    }

    public function middleware()
    {
        return [new LogJob];
    }

    public function handle()
    {
        Mail::to($this->email)->send(new WelcomeMail());
    }
}

6. Dispatching jobs

Vous pouvez dispatcher des jobs de différentes manières dans votre application.

Dispatching synchronement

use App\Jobs\SendEmailJob;

SendEmailJob::dispatch('example@example.com');

Dispatching avec délais

use App\Jobs\SendEmailJob;
use Illuminate\Support\Facades\Date;

SendEmailJob::dispatch('example@example.com')->delay(Date::now()->addMinutes(10));

Dispatching en fond de plan

use App\Jobs\SendEmailJob;

SendEmailJob::dispatch('example@example.com')->onQueue('emails');

7. Job Batching

Les batchs de jobs permettent de gérer plusieurs jobs en tant qu'unité unique.

Création d'un batch

use App\Jobs\SendEmailJob;
use Illuminate\Support\Facades\Bus;

$batch = Bus::batch([
    new SendEmailJob('example1@example.com'),
    new SendEmailJob('example2@example.com'),
    new SendEmailJob('example3@example.com'),
])->then(function () {
    // Tout a réussi...
})->catch(function (Batch $batch, Throwable $e) {
    // Un travail a échoué...
})->finally(function () {
    // Le batch est terminé...
})->dispatch();

Vérification de l'état du batch

use Illuminate\Bus\BatchRepository;
use Illuminate\Support\Facades\Bus;

$batch = Bus::findBatch($batchId);

if ($batch->finished()) {
    echo "Batch finished";
}

if ($batch->failed()) {
    echo "Batch failed";
}

8. Conclusion

Nous avons maintenant exploré les files d'attente dans Laravel, la création de jobs, l'utilisation de middlewares pour les jobs, le dispatching de jobs et le job batching. Les files d'attente sont un outil puissant pour gérer les tâches longues et améliorer la performance de votre application.

Mindmap finale avec Mermaid.js

mindmap
    root(Tutoriel Terminé)
        Introduction
        Présentation du concept de File d'Attente (Queue)
        Configuration de la file d'attente
        Création d’un job
        Job Middleware
        Dispatching jobs
        Job Batching
        Conclusion

Graphique final avec Mermaid.js

graph TD;
    A[Introduction] --> B[Présentation du concept de File d'Attente (Queue)];
    B --> C[Concept];
    B --> D[Drivers];
    C --> E[Traitement asynchrone];
    C --> F[Amélioration de la performance];
    C --> G[Tâches longues];
    D --> H[Database];
    D --> I[Beanstalkd];
    D --> J[Amazon SQS];
    D --> K[Redis];
    D --> L[Null Queue];
    M[Configuration de la file d'attente] --> N[Configurer .env];
    M --> O[Configurer queue.php];
    M --> P[Installer Redis];
    Q[Création d’un job] --> R[Créer le job];
    R --> S[Implémenter le job];
    T[Job Middleware] --> U[Créer le middleware];
    U --> V[Implémenter le middleware];
    T --> W[Appliquer le middleware];
    W --> X[Modifier le job];
    Y[Dispatching jobs] --> Z[Dispatching synchronement];
    Y --> AA[Dispatching avec délais];
    Y --> AB[Dispatching en fond de plan];
    AC[Job Batching] --> AD[Création d'un batch];
    AC --> AE[Vérification de l'état du batch];

J'espère que ce tutoriel vous a été utile ! N'hésitez pas à poser des questions si vous avez besoin de plus d'informations.