Photo par Emile Perron on Unsplash
PHP (Hypertext Preprocessor) est un langage de script open-source qui a été conçu avec des capacités de développement web intégrées. Il est largement utilisé dans le développement web depuis plus de 20 ans. Même s'il équipe actuellement près de 80 % des sites web, PHP présente quelques faiblesses importantes. Le fait qu'il soit monotâche est l'une d'entre elles.
PHP n'a pas de fonction par défaut pour créer des threads supplémentaires pour les processus d'arrière-plan. En raison de la conception monotâche du langage, vous aurez du mal à construire ne serait-ce qu'une simple application web qui doit envoyer des courriels. L'envoi d'un courriel est un processus coûteux et long qui peut bloquer le thread unique de PHP.
Les frameworks PHP s'attaquent au problème
PHP dispose d'un grand nombre de frameworks open-source. Leur objectif principal est de réduire le temps de développement des applications web complexes en appliquant des concepts prédéfinis. Ils aident les [développeurs PHP] (https://proxify.io/hire-php-developers) à automatiser des tâches, à travailler efficacement avec différents types de bases de données, à protéger les applications contre des vulnérabilités bien connues et à effectuer des tests. Les frameworks les plus populaires sont Laravel, Zend, Symfony et Phalcon. Chacun d'entre eux présente ses propres avantages et une vaste communauté contribue à la base de code open-source.
Chaque framework offre un moyen de contourner le problème du multithreading en PHP. Si vous voulez avoir un processus qui tourne en arrière-plan, le concept général est le suivant : l'information sur une tâche est envoyée à un gestionnaire de file d'attente/bus de messages pendant que le serveur vérifie constamment la liste des tâches pour voir s'il y a quelque chose à exécuter.
Gestion des files d'attente de messages dans Laravel
Laravel dispose d'une API de mise en file d'attente unifiée qui vous permet de choisir parmi diverses technologies telles que Redis, Amazon SQS, Beanstalkd, ou même un système de base de données relationnelle à l'ancienne. Voyons comment Laravel fonctionne avec Redis, une structure de stockage de données en mémoire open-source.
Quelle est l'utilité de Redis dans Laravel ? Conceptuellement, vous envoyez une tâche (ou "dispatching a job", comme on l'appelle dans l'écosystème Laravel) dans la file d'attente Redis où elle attend d'être récupérée et traitée. Pour traiter les files d'attente, vous devez avoir des travailleurs qui tournent sans arrêt. Sur les serveurs de production, vous devez disposer d'un superviseur, un moniteur de processus couramment utilisé dans les environnements Linux.
Supposons que vous ayez un modèle Utilisateur, dont une instance doit être créée pour chaque nouvel enregistrement. Il n'existe pas de méthode par défaut pour y parvenir : tout est question de préférences. Pour l'implémenter simplement, vous aurez besoin d'un observateur et d'un travail en file d'attente :
L'observateur est déclenché lorsqu'une instance du modèle est créée.
L'observateur envoie le travail dans la file d'attente.
Le superviseur fait tourner queue:work pour le projet. Dès qu'un nouveau travail est envoyé, il est traité par le gestionnaire de file d'attente de Laravel.
Voyons un exemple de code.
Tout d'abord, vous devez créer un observateur pour le modèle User et un job :
``php
php artisan make:observer UserObserver --model=User
php artisan make:job SendRegistrationEmail
Ensuite, vous devez introduire ce que vous venez de créer dans l'application. Vous pouvez le faire en enregistrant un observateur dans le `EventServiceProvider` comme suit :
```php
namespace App\Providers ;
class EventServiceProvider extends ServiceProvider
{
public function boot()
{
User::observe(UserObserver::class) ;
}
}
Votre application a maintenant la définition de ce qu'elle doit observer, et vous devez la configurer pour faire le travail. UserObserver doit réagir lorsqu'une instance du modèle User est créée. Vous pouvez y parvenir en mettant à jour la méthode created de l'observateur pour le modèle correspondant. Faisons en sorte qu'il envoie un email 10 secondes après la création de l'instance du modèle pour voir comment cela fonctionne en pratique.
namespace App\Observers ;
class UserObserver
{
public function created(User $user)
{
SendRegistrationEmail::dispatch($user->email)->delay(now()->addSeconds(10)) ;
}
}
Chaque fois qu'un Utilisateur est créé, le job SendRegistrationEmail sera envoyé par l'observateur.
namespace App\Jobs ;
class SendRegistrationEmail implements ShouldQueue
{
public $email;
public function __construct($email)
{
$this->email = $email;
}
public function handle()
{
$email = $this->email;
Mail ::send([], [], function ($message) use ($email)
{
$message
->to($email)
->subject('Hello, world !')
->setBody('Bienvenue dans l'application!') ;
}) ;
}
}
Voici comment vous implémentez le flux. Maintenant, l'application envoie un email à un nouvel utilisateur lors de son inscription.
Pour que cela fonctionne via les files d'attente, vous devez mettre à jour les configurations pour utiliser le pilote Redis. Après avoir installé Redis sur votre machine, il suffit de mettre à jour le fichier .env une fois :
QUEUE_CONNECTION=redis
Ensuite, n'oubliez pas de mettre à jour vos configurations : php artisan config:cache. Pour démarrer le gestionnaire de file d'attente de Laravel, vous devez lancer php artisan queue:work.
Résoudre les problèmes avec les travailleurs de file d'attente de Laravel
Les environnements de production requièrent que les travailleurs tournent en permanence. La commande queue:work elle-même peut échouer pour de nombreuses raisons, comme le dépassement du délai maximum. Vérifier manuellement le serveur pour s'assurer que le travailleur de la file d'attente est opérationnel n'est pas une option. A la place, vous utiliserez Supervisor, un moniteur de processus pour les environnements Linux.
Après avoir installé le Supervisor sur le serveur, vous devez lui donner un fichier de configuration pour interagir avec les travailleurs de file d'attente de Laravel. Créons un fichier laravel-worker.conf qui gère le processus queue:work.
[program:laravel-worker]
nom_du_processus=%(program_name)s_%(process_num)02d
command=php /home/projet/artisan queue :work --sleep=3 --tries=3 --max-time=3600
autostart=true
autorestart=true
stopasgroup=true
killasgroup=true
user=root
numprocs=4
redirect_stderr=true
stdout_logfile=/home/project/logs/worker.log
stopwaitsecs=3600
Dans cette configuration, vous devez dire au Superviseur de redémarrer les travailleurs automatiquement et d'avoir 4 processus parallèles en cours d'exécution. Démarrons les processus :
sudo supervisorctl reread
sudo supervisorctl update
sudo supervisorctl start laravel-worker:*
En conclusion, c'est aussi simple que vous le lisez. Le superviseur s'occupe de faire fonctionner les travailleurs. Chaque fois que la file d'attente reçoit un travail, les travailleurs le choisissent et l'exécutent. De cette façon, vous vous assurez que l'utilisateur n'a pas à attendre que PHP traite la tâche d'envoi d'un courriel et passe à la page suivante en déplaçant ce travail fastidieux vers des threads 'parallèles'.
English
Deutsch
