Optimisez la performance de votre application Laravel avec l'exécution asynchrone de tâches longues
Gérer les tâches longues en asynchrone avec Laravel
Laravel est un framework PHP très populaire utilisé pour le développement d'applications web. Il dispose de nombreuses fonctionnalités pour simplifier la création d'applications web robustes et évolutives. L'une des fonctionnalités clés de Laravel est la gestion des tâches longues ou asynchrones. Dans cet article, nous allons explorer comment gérer les tâches longues en asynchrone dans Laravel.
Qu'est-ce qu'une tâche longue en asynchrone?
Une tâche longue est une opération qui prend beaucoup de temps à s'exécuter. Par exemple, une tâche de génération de rapport peut prendre plusieurs minutes, voire plusieurs heures, pour se terminer. Lorsque ces tâches sont exécutées de manière synchrone, elles bloquent l'exécution de l'application, ce qui peut entraîner une expérience utilisateur lente et insatisfaisante.
En revanche, une tâche longue en asynchrone est exécutée en arrière-plan, sans bloquer l'exécution de l'application. Cela permet à l'utilisateur de continuer à utiliser l'application pendant que la tâche s'exécute en arrière-plan.
Comment gérer les tâches longues en asynchrone dans Laravel?
Laravel fournit plusieurs façons de gérer les tâches longues en asynchrone. Dans cet article, nous allons explorer deux façons courantes de gérer les tâches longues en asynchrone dans Laravel.
1. Les jobs
Laravel fournit un système de jobs qui permet d'exécuter des tâches longues en arrière-plan. Les jobs sont des classes PHP qui représentent une tâche à exécuter. Vous pouvez créer des jobs pour effectuer toutes sortes de tâches, telles que l'envoi de courriels, la génération de rapports, etc.
Pour créer un job, utilisez la commande artisan make:job. Par exemple, pour créer un job d'envoi de courriel, utilisez la commande suivante:
php artisan make:job SendEmailUne fois que vous avez créé le job, vous pouvez l'ajouter à la file d'attente des jobs en utilisant la méthode dispatch:
SendEmail::dispatch($user, $message);Le job sera alors exécuté en arrière-plan, sans bloquer l'exécution de l'application. Vous pouvez surveiller l'état d'exécution du
2. Les tâches planifiées
Laravel fournit également un système de tâches planifiées qui permet d'exécuter des tâches à des moments précis ou à des intervalles réguliers. Les tâches planifiées peuvent être utilisées pour effectuer des tâches telles que la génération de rapports quotidiens, la suppression de fichiers obsolètes, etc.
Pour créer une tâche planifiée, utilisez la commande artisan make:schedule. Par exemple, pour créer une tâche planifiée qui exécute une commande artisan toutes les heures, utilisez la commande suivante:
php artisan make:schedule HourlyTaskVous pouvez ensuite ajouter votre tâche planifiée à la liste des tâches planifiées dans le fichier app/Console/Kernel.php:
$schedule->command('command:name')->hourly();Votre tâche planifiée sera alors exécutée à intervalles réguliers, sans bloquer l'exécution de l'application.
3. Exemple :
Pour exécuter la méthode storeSmartPlan de manière asynchrone, nous pouvons utiliser la classe Job de Laravel. Cette classe nous permet d'envoyer une tâche à exécuter en arrière-plan, tout en permettant à l'application de continuer à fonctionner normalement. Voici comment nous pouvons modifier la méthode storeSmartPlan pour l'exécuter en arrière-plan à l'aide d'un job:
<?php
use App\Jobs\ProcessSmartPlan;
public function storeSmartPlan(GoogleApiService $googleApi, StoreSmartPlanRequest $request)
{
// Validation de la requête et récupération des données
$data = $request->validated();
// Création d'une nouvelle tâche à exécuter en arrière-plan
ProcessSmartPlan::dispatch($googleApi, $data);
// Retourne une réponse immédiate à l'utilisateur
return response()->json(['message' => 'Le traitement du plan intelligent a commencé en arrière-plan.']);
}
Ici, nous avons remplacé le traitement des données dans la méthode storeSmartPlan par l'envoi d'une tâche à exécuter en arrière-plan à l'aide de la méthode dispatch() de la classe ProcessSmartPlan. Cette classe est un job qui va traiter les données en arrière-plan. La méthode dispatch() envoie la tâche à la file d'attente des jobs, où elle sera exécutée par un worker.
La classe ProcessSmartPlan peut ressembler à ceci :
namespace App\Jobs;
use App\Services\GoogleApiService;
use App\Http\Requests\StoreSmartPlanRequest;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
class ProcessSmartPlan implements ShouldQueue
{
use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
protected $googleApi;
protected $data;
public function __construct(GoogleApiService $googleApi, array $data)
{
$this->googleApi = $googleApi;
$this->data = $data;
}
public function handle()
{
// Traitement des données
$this->googleApi->createSheet($this->data['name'], $this->data['rows'], $this->data['columns']);
}
}
La classe ProcessSmartPlan est un job qui implémente l'interface ShouldQueue. Cette interface indique à Laravel que ce job doit être exécuté en arrière-plan. La méthode handle() est la méthode qui sera exécutée en arrière-plan et qui effectuera le traitement des données. Dans cet exemple, nous avons utilisé la méthode createSheet() du service GoogleApiService pour créer une nouvelle feuille de calcul Google.
En utilisant cette approche, le traitement des données sera effectué en arrière-plan, ce qui permettra à l'application de continuer à fonctionner normalement, même si le traitement prend beaucoup de temps. De plus, les jobs peuvent être exécutés de manière distribuée sur plusieurs serveurs, ce qui permet de traiter les tâches plus rapidement et d'améliorer la scalabilité de l'application.
En résumé, pour exécuter des opérations longues de manière asynchrone dans Laravel, nous pouvons utiliser la classe Job de Laravel. Cette approche nous permet d'envoyer une tâche à exécuter en arrière-plan, ce qui permet à l'application de continuer à fonctionner normalement et améliore la scalabilité de l'application. En utilisant cette approche, nous pouvons améliorer la performance et la fiabilité de notre application.
