Optimiser les files d'attente dans Laravel - Brends

Dans le développement d’applications web, la gestion des tâches de fond est importante car il faut pouvoir garantir une expérience utilisateur à la fois fluide et agréable.

Cependant, l’utilisation des queues nécessite une configuration robuste ainsi qu’une gestion optimale pour garantir des performances élevées. Dans cet article, nous explorons les manières permettant de configurer, gérer et optimiser les files d’attente Laravel.

Comprendre les queues Laravel

photo developper ayant compris les queues pour laravel

Qu’est-ce qu’une queue dans Laravel ?

Une queue Laravel consiste en une structure pour gérer des tâches en les plaçant dans une file d’attente dans laquelle elles seront traitées par des workers en fond. Ainsi, plutôt que d’exécuter immédiatement une tâche coûteuse en temps ou en ressources comme l’envoi d’un e-mail après l’inscription d’un utilisateur, par exemple, Laravel permet de la “queue” (ajouter à la file d’attente) pour qu’elle soit exécutée prochainement pour libérer le flux principal à d’autres opérations courantes.

Ce système est notamment utile dans les applications web pour lesquelles les performances et la réactivité sont cruciales. Par exemple, une plateforme de commerce en ligne peut utiliser des files d’attentes pour traiter les commandes sans, pour autant, ralentir l’expérience d’achat des utilisateurs connectés.

Pour en apprendre plus sur les différentes collections Laravel, notre article vous guidera dans votre apprentissage !

Améliorer l’expérience perçue par l’utilisateur

Les tâches longues mettent quelques secondes ou minutes à s’exécuter peuvent être activées en fond. La durée de traitement perçue par l’utilisateur sera réduite, et améliorera l’expérience de ressentie globale, alors que le script sera toujours aussi.
Souvent, il est plus facile de mettre un script dans une file d’attente que d’améliorer les performances de ce dernier.

Meilleure allocation des ressources systèmes

En déplaçant les tâche lourdes en dehors du flux principal, on peut allouer les ressources système au mieux pour des opérations plus importantes ou délicates.

Meilleure gestion des erreurs

Lorsque nous mettons en place un script dans une file d’attente, nous avons tendance à mettre en place une gestion des erreurs plus robustes. nous pouvons même nous permettre d’allonger la durée du script pour mettre enregistrer ces erreurs et s’en resservir plus tard.

Meilleure scalabilité du code

Il est plus facile de scaler un code avec un système de file d’attente, car cela permet de manière horizontal en ajoutant plus de workers au moment des pics d’activités de manière automatique.

À travers ces exemples, nous avons pu voir que les queues sont devenus indispensables pour les applications à grande échelle dans lesquelles la gestion des tâches de fond est indispensable pour maintenir des performances élevées. Pour une meilleure gestion de ces processus backend, n’hésitez pas, non plus, à intégrer des outils comme Laravel Nova, par exemple.

Configurer les queues Laravel

Installer et configurer un driver de queue

Laravel supporte plusieurs drivers de file d’attente tels que Database, Redis, Beanstalkd ou encore Amazon SQS :

Redis : Il fonctionne en mémoire pour permettre un traitement très rapide des jobs. Très populaire au sein des applications web nécessitant une latence faible ainsi qu’une gestion rapide des files d’attente.
Database : Il utilise la base de données relationnelle d’une application pour gérer les files attente. Il est idéal pour les petites applications ou pour des environnements de développement pour lesquels la configuration doit rester simple. il a l’avantage d’être très simple à configurer
Beanstalkd : Il s’agit d’un système de message à hautes performances pour le traiter des jobs en asynchrone. C’est un choix judicieux pour les applications web nécessitant une disponibilité élevée des jobs.
Amazon SQS : Ce service cloud propose également une gestion simplifiée des queues dans des environnements distribués. Il est parfait pour les applications qui nécessitent une scalabilité extrême.

Pour configurer un driver de queue, nous devons d’abord installer le service requis avant de modifier le fichier .env pour spécifier le driver sélectionné. Par exemple, pour utiliser Redis :

QUEUE_CONNECTION=redis

Ensuite, nous devons configurer les paramètres du driver dans le fichier dédié config/queue.php. Le paramétrage du driver implique la définition de paramètres tels que:

Le délai d’expiration des jobs,
Le nombre de tentatives avant un échec,
Etc.

Configurer les options de queue dans le fichier .env

developpeuse heureuse d'avoir paramètrer queues fichier env

Le fichier .env permet de définir des stocker des variables d’environnement. Il est, donc, important dans la configuration des queues Laravel.

En effet, ce fichier va permettre de contrôler les différentes options sans avoir à modifier directement le code source PHP et manière sécurisée. Outre le choix du driver, nous pouvons ainsi configurer des paramètres essentiels comme :

QUEUE_CONNECTION : Le driver à utiliser (redis ou database, par exemple).
QUEUE_RETRY_AFTER : Le nombre de secondes après lesquelles un job échoué devra être retenté.
QUEUE_TIMEOUT : Le délai maximum (en secondes) durant lequel un worker peut traiter un job avant qu’il ne soit considéré comme échoué.

Voici un exemple de configuration de base du fichier .env avec le driver Redis :

QUEUE_CONNECTION=redis
REDIS_QUEUE=default
QUEUE_RETRY_AFTER=90
QUEUE_TIMEOUT=60

Ces quelques paramètres permettent d’adapter le comportement des queues en fonction des besoins de l’application. Pour des applications plus complexes qui nécessitent une sécurité renforcée, il faudra combiner ces réglages avec des pratiques robustes de validation des données dans Laravel.

Création et gestion des jobs

developpeur qui a mis en place un job queue sur laravel

Créer des jobs dans Laravel

Les jobs Laravel représentent des classes PHP encapsulant la logique des tâches à exécuter en tâche de fond. La création de jobs peut être facilité par Artisan. Avec cet outil, pour créer un job, nous utilisons la commande :

php artisan make:job ProcessPodcast.

Cette commande, plutôt simple, permet de générer une classe PHP dans le répertoire dédié app/Jobs. Cette classe inclut automatiquement la méthode handle() dans laquelle nous définirons la logique du job à construire.

Par exemple, un job qui est chargé de traiter un fichier audio pourrait inclure du code pour manipuler ce fichier et le stocker dans un répertoire choisi au préalable :

namespace App\Jobs;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Storage;

class ProcessPodcast implements ShouldQueue
{
    use InteractsWithQueue, Queueable, SerializesModels;

    protected $file;

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

public function handle()
{
    // La logique pour traiter le fichier audio…
    $path = Storage::put('podcasts', $this->file);
}
}

Les jobs peuvent être configurés pour être mis en file d’attente directement après leur création mais il est également possible de définir des conditions pour les dispatcher à un moment précis.

Dispatcher les jobs

Le dispatching des jobs perme d’envoyer un job donné dans une queue pour qu’il soit exécuté par un worker.

Il faut savoir que Laravel offre une grande flexibilité pour dispatcher les jobs, soit de manière immédiate, soit à une heure précise ou encore après un délai spécifique.

Pour dispatcher un job, on utilise la fonction dédiée dispatch() :

dispatch(new ProcessPodcast($file));

Nous pouvons également préciser la file d’attente au job dispatché :

dispatch(new ProcessPodcast($file))->onQueue('processing');

Enfin, il est possible de retarder l’exécution d’un job en utilisant la méthode delay()depuis une instance de ProcessPodcast :

dispatch(new ProcessPodcast($file))->delay(now()->addMinutes(10));

La possibilité de planifier et prioriser les jobs permet une gestion fine et précise des ressources et des performances de l’application web développée.

Par exemple, nous pouvons faire le choix de retarder les jobs moins critiques pendant les périodes de forte charge, afin de garantir que les ressources restent disponibles pour les tâches essentielles et importantes de l’application.

Pour les applications nécessitant une gestion complexe des e-mails, ces concepts peuvent être appliqués à des scénarios d’envoi d’emails massifs avec Laravel Mail.

Exécuter le worker de queue

Un worker de queue est un processus chargé d’écouter une file d’attente et d’exécuter les jobs une fois qu’ils sont disponibles. Pour démarrer un worker, il suffit de rentrer la commande php artisan queue:work.

Cette commande sert à démarrer le worker. Il commence à traiter les jobs dans la file. D’ailleurs, il est recommandé d’exécuter les workers en fond afin de garantir qu’ils fonctionnent en continu même après un redémarrage du serveur.

Pour une gestion avancée des workers, vous pouvez utiliser Supervisord ou Systemd pour gérer ces processus en production et ainsi assurer une disponibilité élevée.

Gérer les jobs échoués

Il est important de mettre en place une gestion de l’échec des jobs pour assurer la fiabilité de l’application. Laravel inclut de manière native un mécanisme intégré pour enregistrer les jobs qui échouent et permettre leur réexécution.

Pour créer la table des jobs échoués, on exécute les deux commandes suivantes :

php artisan queue:failed-table
php artisan migrate

Une fois la table SQL créée, les jobs échoués sont automatiquement stockés. Par la suite, vous pourrez les gérer grâce à des commandes Artisan comme queue:retry pour réessayer un job échoué ou encore queue:forget pour complètement supprimer un job échoué de la table.

Une gestion globale des jobs échoués est essentielle pour garantir la continuité des opérations exécutées par l’application. Au sein de d’une application laravel, la bonne pratique veut que nous intégrions une gestion efficace des échecs et des erreurs directement dans les processus, en passant par l’utilisation de routes Laravel.

Ces dernières permettent de rediriger les requêtes en fonction des résultats des jobs. Cette gestion des erreurs centralisée permet d’améliorer la robustesse de votre application.

Optimisation des performances des queues

Utiliser Laravel Horizon pour surveiller et gérer les queues

Laravel Horizon est un outil permettant de surveiller et gérer les files d’attentes pour les applications Laravel. L’outil utilise le driver Redis et fournit une interface utilisateur pour permettre de :

Surveiller les jobs en temps réel,
Gérer les workers
Configurer des alertes pour les jobs échoués ou les queues surchargées.

Pour installer Horizon, il suffit d’exécuter la commande Composer suivante :

composer require laravel/horizon

Une fois installé, vous pourrez configurer Horizon dans le fichier dédié config/horizon.php.

Vous pourrez accéder à l’interface visuelle depuis l’URL http://yourapp/horizon.

Horizon permet de visualiser l’état actuel des jobs, de définir des priorités et de surveiller les performances de vos queues. De plus, Il est possible de configurer des alertes pour être notifié si les niveaux d’attente devient trop important. Cette dernière fonctionnalité vous pour permettra de réagir de manière rapide et d’éviter toute dégradation des performances de l’application.

Horizon est plus adapté à dans les environnements à grande échelle pour lesquels la surveillance active des queues est nécessaire pour maintenir des performances élevées. Pour une gestion plus fine, vous pouvez explorer des solutions complémentaires comme Laravel Breeze.

Prioriser les jobs

La priorisation des jobs est le meilleur moyen de garantir que les tâches complexes ou critiques soient traitées en priorité. Dans Laravel, il est possible d’assigner des priorités en utilisant des queues distinctes pour les jobs critiques et non critiques.

Par exemple, les tâches à priorité élevée peuvent être placées dans une queue spécifique avec une priorité adéquate :

dispatch(new CriticalJob())->onQueue('high');
dispatch(new NonCriticalJob())->onQueue('low');

En configurant plusieurs queues avec des priorités différentes, il est possible d’allouer plus de ressources aux tâches les plus importantes et ainsi éviter que les jobs moins prioritaires ne bloquent les opérations plus longues.

Réessayer les jobs échoués

Laravel permet de réessayer automatiquement des jobs ayant échoués de manière native. Cette fonctionnalité permet d’assurer une meilleure fiabilité des opérations de fond. Pour configurer le nombre de tentative, il suffit de faire la commande suivante :

QUEUE_RETRIES=3

Dans cet exemple, nous avons définis le nombre de tentative à 3.

Cette bonne pratique est surtout recommandé dans les environnements dans lesquels une haute disponibilité est requise et dans lesquels les interruptions ne peuvent être tolérées !

Cette fonctionnalité s’avère intéressante pour les applications web traitant de grands volumes de transactions et dans lesquelles les erreurs peuvent survenir de différents facteurs comme des problèmes de réseau ou de charge sur le système. Pour une gestion encore plus proactive des échecs, explorez notre guide sur Laravel Herd et simplifiez votre environnement !

Optimiser les réglages des workers

Les workers sont au cœur du système de files d’attente de Laravel. Leur optimisation est cruciale pour améliorer les performances. Il est possible d’ajuster divers paramètres pour maximiser leur fonctionnement

Un nombre de workers peut être défini en fonction de la charge de travail de l’application. L’augmentation du nombre de workers permet ainsi de traiter plus de jobs en parallèle tout en réduisant ainsi le temps de traitement global.

Un temps d’exécution maximal peut également être configuré pour que les workers redémarre régulièrement afin de libérer de la mémoire et ainsi éviter les fuites de mémoire. Cela peut se faire en définissant le paramètre --max-time lors de l’exécution des workers.

La gestion des signaux Unix permet de contrôler les workers et les arrêter en douceur pour terminer les jobs en cours avant de redémarrer le worker.

Stratégies avancées d’optimisation

Utiliser les workers de queue et le scaling horizontal

Pour les applications à grande échelle, il peut être nécessaire de mettre en place une architecture de scaling horizontal. Cela implique de répartir la charge de travail sur plusieurs serveurs exécutant, chacun, un certain nombre de workers en parallèle.

Le scaling horizontal permet alors de traiter un grand nombre de jobs en même temps pour ainsi réduire le temps de traitement global du système. Pour mettre en œuvre une telle stratégie, il est possible e configurer plusieurs serveurs écoutant la même file ou des files distinctes selon la nature des jobs.

Voici quelques stratégies populaires pour un scaling horizontal :

Utiliser Redis en tant que système de stockage en mémoire. Cette stratégie est adaptée au scaling horizontal puisqu’elle permet de configurer plusieurs instances Redis pour gérer des queues distinctes ou de répartir la charge sur plusieurs serveurs à la fois.
Allouer des workers dynamiquement en fonction de la charge de travail en temps réel. En utilisans des outils comme AWS Auto Scaling, il est simple d’ajouter ou supprimer des serveurs en fonction des demandes reçues.
Surveiller de manière proactive les performances de chaque serveur avec Horizon et ajuster les configurations de queue en fonction de besoins spécifiques.

Ces quelques options de stratégie permettent de garantir à votre application une gestion d’un volume de travail croissant sans, pour autant, sacrifier ses performances ou sa fiabilité.

Implémenter une architecture basée sur les queues pour les microservices

Les queues sont, par ailleurs, un excellent outil pour découpler les services d’une architecture microservices. Dans une telle architecture, chaque microservice peut envoyer des messages à d’autres services en passant par les queues. Ce traitement permet une communication asynchrone améliorant la résilience globale du système.

Un service d’authentification pourrait alors envoyer un message à une queue lorsqu’un utilisateur se connecte et ainsi déclencher des actions dans d’autres services comme l’envoi de notifications ou la mise à jour des statistiques de connexion utilisateur.

Les queues permettent également une gestion flexible des dépendances entre les services. Cela rend l’architecture très modulaire et résiliente. Ainsi, en cas de surcharge ou de panne d’un service, les autres peuvent continuer leur fonctionnement standard puisque les messages sont traités une fois que le service problématique est de nouveau en ligne.

Pour plus d’informations sur la mise en place d’une architecture microservices avec Laravel, explorez notre article sur Laravel Passport pour l’authentification Laravel OAuth2.

Meilleures pratiques pour optimiser les performances et la fiabilité des queues

L’optimisation des performances et de la fiabilité des queues nécessite de suivre certaines des meilleures pratiques reconnues par la communauté Laravel :

Utiliser des queues dédiées pour séparer les tâches critiques des autres. Cette pratique vous permettra de prioriser les jobs essentiels sans qu’ils ne soient, pour autant, bloqués par des opérations moins importantes.
Limiter la durée de vie maximale des jobs pour éviter qu’ils ne bloquent la queue de manière indéfinie.
Configurer des alertes pour être informé rapidement en cas de problème comme une surcharge de la queue ou un nombre élevé de jobs échoués, par exemple.
Surveiller les ressources avec des outils de surveillance dédiés pour suivre l’utilisation des ressources par les workers et pouvoir ajuster le nombre de workers en fonction de la charge.

Ces quelques bonnes pratiques devraient vous aider à maintenir un système à la fois robuste, réactif et capable de gérer une charge de travail élevée sans avoir à sacrifier sa fiabilité.

Surveillance et gestion des queues

Configurer Supervisord pour exécuter les queues

Supervisord est un gestionnaire de processus utilisé pour surveiller et contrôler les processus en cours d’exécution sur un serveur donné. Il permet notamment d’y suivre les workers de queue Laravel. Il est notamment très utile dans les environnements de production pour garantir que les workers du système fonctionnent bien en continu et ce, même après un redémarrage total du serveur.

Pour configurer Supervisord, on créé un fichier de configuration supervisord.conf avant de définir les paramètres pour les workers de queue :

[program:laravel-worker]

process_name=%(program_name)s_%(process_num)02d

command=php /path/to/artisan queue:work –sleep=3 –tries=3

autostart=true

autorestart=true

user=www-data

numprocs=8

redirect_stderr=true

stdout_logfile=/path/to/your/logs/worker.log

Cette configuration de base assure le démarrage automatique des workers au lancement du serveur ainsi qu’un redémarrage en cas d’échec. Supervisord propose également des options avancées pour gérer les ressources, rediriger les logs et surveiller la santé des processus en cours.

Utiliser CRON pour gérer les queues

En plus de Supervisord, il est possible d’utiliser des tâches CRON d’Unix pour exécuter des jobs à des intervalles réguliers. Par exemple, nous pourrions vouloir exécuter un job à chaque heure pour nettoyer les anciennes données :

0 * * * * php /path/to/artisan queue:work

Les tâches CRON sont utiles pour gérer des jobs récurrents ou des tâches de maintenance ne nécessitant pas une exécution continue. Elles peuvent être configurées pour lancer des jobs à des moments précis et s’assurer que les tâches critiques sont exécutées selon un emploi du temps fixe.

Débogage et résolution des problèmes courants

Erreurs d’installation

Lors de l’installation des queues dans un système Laravel, vous pourrez rencontrer des erreurs éventuelles qui peuvent être liées à des dépendances manquantes ou encore à des configurations incorrectes. Pour résoudre ces problèmes connus, assurez-vous que toutes les extensions PHP nécessaires sont installées et que la configuration de votre driver est correcte.

Problèmes de configuration

Les problèmes de configuration des queues peuvent être également dus à des erreurs dans le fichier de configuration de l’environnement de développement, .env, ou dans les fichiers de configuration spécifiques aux drivers de queue. Il est important et essentiel de vérifier que toutes les options nécessaires sont correctement définies et que les services externes comme Redis ou SQS sont accessibles depuis le système.

Problèmes de performance

Si vos queues rencontrent des problèmes de performance, nous vous conseillons de surveiller l’utilisation des ressources et d’ajustez le nombre de workers ou les priorités des jobs en fonction de vos besoins. Utilisez également Horizon pour identifier les goulots d’étranglement et réajuster les réglages des workers si nécessaire.

La mise en place de tests automatisés avec Seeders et Factories peut également aider à identifier les problèmes de performance avant qu’ils n’affectent l’application en production. Pour plus de détails, consultez notre article sur Seed et Factory Laravel.

Exemples pratiques d’utilisation des queues Laravel

Intégration avec une application Vue.js

Les queues peuvent être utilisées pour gérer les tâches plus ou moins complexes dans une application Vue.js intégrée à Laravel. Par exemple, lorsqu’un utilisateur soumet un formulaire de données complexe, les données peuvent être envoyées à une queue pour être traitées en fond et ainsi éviter de bloquer l’interface utilisateur et améliorer son expérience globale.

En intégrant des queues pour les opérations lourdes, vous améliorerez la réactivité de l’application web frontend Vue.js et garantirez que les tâches les plus complexes et lourdes n’affectent pas la fluidité de l’expérience utilisateur.

Utilisation des queues dans une application mobile

Dans une application mobile connectée à une API Laravel, les queues peuvent être utilisées pour gérer les notifications push ou encore le traitement de données volumineuses. Ce traitement améliore la réactivité de l’application en assurant que les tâches les plus lourdes sont déportées en fond.

Par exemple, une application de fitness pourrait utiliser des queues pour traiter les données de suivi des utilisateurs et générer des rapports détaillés sans ralentir l’application mobile.

Implémentation de queues dans un microservice

Dans une architecture microservices, chaque service peut utiliser des queues pour communiquer avec les autres services. Par exemple, un service de facturation pourrait envoyer un message à une queue pour informer un service de gestion des stocks qu’une commande a été validée et ainsi déclencher une mise à jour des stocks de produits.

Ces quelques exemples pratiques de base montrent de quelle manière les queues peuvent être intégrées dans différents contextes et ainsi améliorer les performances et la scalabilité de vos applications web et mobile. Enfin, l’implémentation des queues dans un microservice garantit une communication asynchrone efficace ainsi qu’une gestion des tâches plus flexible et robuste.

L’optimisation des files d’attente dans Laravel est finalement purement essentielle pour assurer que votre application reste réactive et capable de gérer un grand nombre de tâches de fond sans, pour autant, sacrifier les performances ou la fiabilité de l’application. En suivant les bonnes pratiques que nous avons tâché de vous décrire dans cet article et en utilisant des outils comme Laravel Horizon et Supervisord, vous pourrez, sans problèmes, maximiser l’efficacité de vos files Laravel !

Découvrez d’autres articles sur Laravel :

Seed et Factory Laravel

Mail Laravel