Utilisation du traitement en arrière-plan pour accélérer les temps de chargement de la page

Points de base

• Le traitement en arrière-plan améliore considérablement la vitesse de chargement des pages: Transférer des tâches lourdes vers le traitement en arrière-plan, libère les ressources du thread principal et se concentre sur le chargement des pages, améliorant ainsi l'expérience de navigation des utilisateurs.
• Les deux composantes centrales du traitement d'arrière-plan: Fitre de tâche et processus de travail. L'application crée des tâches en attente, tandis que le travailleur traite les tâches d'extraire une par une de la file d'attente pour le traitement. Plusieurs processus de travailleurs peuvent être traités en parallèle pour accélérer.
• Sélection de pile technique: Utilisez la file d'attente de tâches BeanStalkd pour stocker les tâches, le composant de console Symfony pour implémenter les processus de travail (en tant que commandes de console) et le superviseur gère les processus de travail.
• Optimisation de la bibliothèque d'images: Évitez la mise à l'échelle de l'image sur la première demande (qui augmente la charge de charge initiale), mais rendez plutôt les miniatures de manière asynchrone après la création de la galerie. Cette tâche peut être déplacée vers l'arrière-plan pour améliorer l'expérience et l'évolutivité des utilisateurs.
• Défis et réponses potentiels: Assurez-vous que les tâches sont terminées avec succès dans le bon ordre et que les erreurs dans les tâches d'arrière-plan sont correctement gérées. Cela peut être atténué en utilisant des files d'attente de tâches et des mécanismes de gestion des erreurs et de journalisation robustes.

Cet article fait partie d'une série d'articles sur la création d'applications d'échantillons (blog multi-images) pour l'analyse comparative et l'optimisation des performances. (Affichez la base de code ici)

Dans les articles précédents, nous avons ajouté la fonction de mise à l'échelle de l'image à la demande. Les images sont mises à l'échelle et mises en cache pour une utilisation ultérieure lorsqu'ils sont demandés pour la première fois. Cela est pratique, mais augmente également la surcharge du premier chargement;

La solution d'optimisation consiste à rendre les miniatures après avoir créé la galerie. Vous pensez peut-être: "D'accord, mais cela bloquera l'utilisateur qui a créé la galerie?" Les utilisateurs seront confus quant aux temps de chargement plus longs, ou pire, si l'image est trop grande pour être traitée, vous rencontrerez un délai d'attente et / ou une erreur. La meilleure solution consiste à déplacer ces tâches lourdes vers l'arrière-plan.

Tâches d'arrière-plan

Les tâches d'arrière-plan sont le meilleur moyen de gérer toutes les tâches lourdes. Nous pouvons immédiatement informer l'utilisateur que nous avons reçu sa demande et que nous organisons le traitement. Il en va de même pour YouTube pour télécharger des vidéos: la vidéo n'est pas accessible après le téléchargement. Les utilisateurs doivent attendre que la vidéo soit entièrement traitée avant de prévisualiser ou de partager.

Le traitement ou la génération de fichiers, l'envoi d'e-mails ou toute autre tâche non critique doivent être effectués en arrière-plan.

Comment travailler dans le traitement du backend

La méthode de traitement d'arrière-plan a deux composantes clés: la file d'attente des tâches et le processus de travail. L'application crée des tâches qui doivent être traitées, tandis que le travailleur attend et obtient une tâche de la file d'attente à la fois.

Vous pouvez créer plusieurs processus de travailleurs (processus) pour accélérer le traitement, décomposer de grandes tâches en morceaux plus petits et les traiter simultanément. Vous pouvez organiser et gérer le traitement du backend en fonction de vos besoins, mais sachez que le traitement parallèle n'est pas une tâche facile: vous devez prêter attention aux conditions de course potentielles et gérer les tâches défaillantes avec élégance.

Notre pile technologique

Nous utilisons la file d'attente de tâches BeanStalkd pour stocker les tâches, utilisons le composant de console Symfony pour implémenter le processus de travail en tant que commande de console et utiliser le superviseur pour gérer le processus de travail.

Si vous utilisez Homestead Amélioré, BeanStalkd et Superviseur sont installés, vous pouvez donc ignorer les instructions d'installation ci-dessous.

Instalkd

BeanStalkd est une file d'attente de travail rapide avec une interface commune qui a été initialement conçue pour réduire la latence dans la navigation de page dans des applications Web à haut trafic en exécutant des tâches longues de manière asynchrone.

Vous pouvez utiliser de nombreuses bibliothèques clients disponibles. Dans notre projet, nous utilisons Pheanstalk.

Pour installer BeanStalkd sur votre serveur Ubuntu ou Debian, exécutez simplement sudo apt-get install beanstalkd. Consultez la page de téléchargement officielle pour savoir comment installer BeanStalkd sur d'autres systèmes d'exploitation.

Après l'installation, BeanStalkd commence comme un démon, attendant que le client se connecte et crée (ou traite) le travail:

<code>/etc/init.d/beanstalkd
Usage: /etc/init.d/beanstalkd {start|stop|force-stop|restart|force-reload|status}</code>

Installez PheanStalk en tant que dépendance en exécutant composer require pda/pheanstalk.

La file d'attente sera utilisée pour créer et récupérer des travaux, nous centralisons donc la création d'emplois dans un service d'usine: JobQueueFactory

<?php
namespace App\Service;

use Pheanstalk\Pheanstalk;

class JobQueueFactory
{
    private $host = 'localhost';
    private $port = '11300';

    const QUEUE_IMAGE_RESIZE = 'resize';

    public function createQueue(): Pheanstalk
    {
        return new Pheanstalk($this->host, $this->port);
    }
}

Maintenant, nous pouvons injecter des services d'usine au besoin pour interagir avec la file d'attente BeanStalkd. Nous définissons le nom de la file d'attente comme une constante et le référons lors de la mise en place du travail dans la file d'attente ou de la surveillance de la file d'attente dans le processus des travailleurs.

Installation du superviseur

Selon la page officielle, le superviseur est un système client / serveur qui permet à ses utilisateurs de surveiller et de contrôler de nombreux processus sur le système d'exploitation UNIX.

Nous l'utiliserons pour démarrer, redémarrer, développer et surveiller les processus de travailleurs.

Installez le superviseur sur votre serveur Ubuntu / Debian en exécutant

. Après l'installation, le superviseur fonctionnera en arrière-plan en tant que démon. Utilisez sudo apt-get install supervisor pour contrôler le processus de superviseur: supervisorctl

<code>$ sudo supervisorctl help

default commands (type help <topic>):
</topic>=====================================
add    exit      open  reload  restart   start   tail
avail  fg        pid   remove  shutdown  status  update
clear  maintail  quit  reread  signal    stop    version</code>

Pour utiliser le superviseur pour contrôler un processus, nous devons d'abord écrire un fichier de configuration et décrire comment nous voulons contrôler notre processus. La configuration est stockée dans

. Une configuration de superviseur simple pour le redimensionnement des processus de travailleurs est la suivante: /etc/supervisor/conf.d/

<code>[program:resize-worker]
process_name=%(program_name)s_%(process_num)02d
command=php PATH-TO-YOUR-APP/bin/console app:resize-image-worker
autostart=true
autorestart=true
numprocs=5
stderr_logfile = PATH-TO-YOUR-APP/var/log/resize-worker-stderr.log
stdout_logfile = PATH-TO-YOUR-APP/var/log/resize-worker-stdout.log</code>

Nous disons au superviseur comment nommer le processus généré, le chemin d'accès aux commandes à exécuter, le processus a automatiquement démarré et redémarré, combien de processus nous voulons et où enregistrer la sortie. En savoir plus sur la configuration du superviseur ici.

redimensionner l'image en arrière-plan

Une fois notre infrastructure configurée (c.-à-d. BeanStalkd et superviseur sont installés), nous pouvons modifier notre application pour redimensionner l'image en arrière-plan après avoir créé la galerie. Pour ce faire, nous avons besoin:

• Mettez à jour la logique du service d'image dans ImageController
Implémentez le processus de travailleur redimensionné en tant que commande de console
Créer une configuration de superviseur pour notre processus de travail
Mettez à jour l'appareil et redimensionnez l'image dans la classe de périphérique.

Logique de service d'image de mise à jour

Jusqu'à présent, nous avons redimensionné l'image sur la première demande: si le fichier d'image demandé n'existe pas, il sera créé dynamiquement.

ImageController Nous allons maintenant modifier

pour retourner la réponse d'image demandée uniquement si le fichier d'image redimensionné existe (c'est-à-dire que l'image a été redimensionnée).

S'il n'existe pas, l'application renverra une réponse d'image d'image d'espace réservée commune indiquant que l'image est redimensionnée. Notez que la réponse de l'image de placement a différents en-têtes de contrôle de cache car nous ne voulons pas mettre en cache l'image de l'espace réservé;

GalleryCreatedEvent Nous créerons un événement simple appelé UploadController avec la charge utile comme ID de galerie. Une fois la galerie créée avec succès, cet événement sera expédié dans

:

<code>/etc/init.d/beanstalkd
Usage: /etc/init.d/beanstalkd {start|stop|force-stop|restart|force-reload|status}</code>

De plus, nous mettrons à jour le message Flash à l'aide de "Les images sont maintenant en cours de traitement."

afin que les utilisateurs sachent que nous devons effectuer un traitement sur leurs images avant d'être prêt.

GalleryEventSubscriber Nous créerons GalleryCreatedEvent abonné à l'événement, qui réagira à

et demanderons des travaux de redimensionnement pour chaque image de la galerie nouvellement créée:

<?php
namespace App\Service;

use Pheanstalk\Pheanstalk;

class JobQueueFactory
{
    private $host = 'localhost';
    private $port = '11300';

    const QUEUE_IMAGE_RESIZE = 'resize';

    public function createQueue(): Pheanstalk
    {
        return new Pheanstalk($this->host, $this->port);
    }
}

Maintenant, lorsque l'utilisateur crée avec succès la galerie, l'application rendra la page de la galerie, mais les miniatures de certaines images ne sont toujours pas prêtes, elles ne seront donc pas affichées:

Une fois le processus de travail terminé le redimensionnement, la page complète de la galerie doit être rendue à la prochaine rafraîchissement.

Implémentez le processus de travailleur redimensionné en tant que commande de console

$queue->reserve() Le processus des travailleurs est un processus simple qui effectue le même travail pour chaque travail prélevé dans la file d'attente. L'exécution du processus du travailleur est bloquée lors de l'appel

jusqu'à ce que le travailleur conserve l'emploi, ou un délai d'expiration se produit.

Un seul processus de travailleur peut obtenir et traiter des emplois. Les travaux contiennent généralement des charges utiles, telles que des chaînes ou des tableaux / objets sérialisés. Dans notre exemple, ce sera l'UUID de la galerie créée.

Un travailleur simple ressemble à ceci: <🎜>

<code>/etc/init.d/beanstalkd
Usage: /etc/init.d/beanstalkd {start|stop|force-stop|restart|force-reload|status}</code>

Vous avez peut-être remarqué que le processus des travailleurs quittera après un délai défini ou après le traitement d'un travail. Nous pouvons envelopper la logique de processus des travailleurs dans une boucle infinie et la faire répéter indéfiniment ses travaux, mais cela peut entraîner des problèmes tels que le délai de connexion de la base de données après une longue inactivité et rendre le déploiement plus difficile. Pour éviter cela, notre cycle de vie des processus de travail se terminera une fois une seule tâche terminée. Le superviseur redémarre ensuite le processus des travailleurs en tant que nouveau processus.

Voir ResizeImageWorkerCommand pour comprendre la structure des commandes des travailleurs. Les processus de travail mis en œuvre de cette manière peuvent également être démarrés manuellement comme la commande de la console Symfony: ./bin/console app:resize-image-worker.

Créer la configuration du superviseur

Nous voulons que notre processus de travailleur commence automatiquement, nous allons donc définir la directive autostart=true dans la configuration. Étant donné que le processus de travailleur doit être redémarré après un délai d'expiration ou un traitement de tâches réussi, nous définirons également la directive autorestart=true.

La meilleure partie du traitement backend est la facilité de traitement parallèle. Nous pouvons définir la directive numprocs=5 et le superviseur générera cinq instances de processus de travail. Ils attendront des emplois et les traiteront indépendamment, ce qui nous permettrait de faire évoluer facilement le système. Au fur et à mesure que le système évolue, vous devrez peut-être augmenter le nombre de processus. Étant donné que nous aurons plusieurs processus en cours d'exécution, nous devons définir la structure du nom du processus, nous définissons donc la directive process_name=%(program_name)s_%(process_num)02d.

Enfin, nous voulons stocker la sortie des processus de travail afin qu'ils puissent être analysés et débogués lorsque des problèmes surviennent. Nous définirons les chemins stderr_logfile et stdout_logfile.

La configuration complète du superviseur pour notre processus de redimensionnement des travailleurs est la suivante:

<?php
namespace App\Service;

use Pheanstalk\Pheanstalk;

class JobQueueFactory
{
    private $host = 'localhost';
    private $port = '11300';

    const QUEUE_IMAGE_RESIZE = 'resize';

    public function createQueue(): Pheanstalk
    {
        return new Pheanstalk($this->host, $this->port);
    }
}

Après avoir créé (ou mise à jour) un fichier de configuration situé dans le répertoire /etc/supervisor/conf.d/, vous devez dire au superviseur de relier et de mettre à jour sa configuration en exécutant la commande suivante:

<code>$ sudo supervisorctl help

default commands (type help <topic>):
</topic>=====================================
add    exit      open  reload  restart   start   tail
avail  fg        pid   remove  shutdown  status  update
clear  maintail  quit  reread  signal    stop    version</code>

Si vous utilisez Homestead Amélioré (vous devez utiliser!), Vous pouvez utiliser scripts/setup-supervisor.sh pour générer une configuration de superviseur pour le projet: sudo ./scripts/setup-supervisor.sh.

Mettre à jour le périphérique

Les vignettes de l'image ne seront plus rendues sur la première demande, donc lorsque nous chargeons l'appareil dans la classe de périphérique LoadGalleriesData, nous devons demander explicitement le rendu pour chaque image:

<code>[program:resize-worker]
process_name=%(program_name)s_%(process_num)02d
command=php PATH-TO-YOUR-APP/bin/console app:resize-image-worker
autostart=true
autorestart=true
numprocs=5
stderr_logfile = PATH-TO-YOUR-APP/var/log/resize-worker-stderr.log
stdout_logfile = PATH-TO-YOUR-APP/var/log/resize-worker-stdout.log</code>

Maintenant, vous devriez sentir l'appareil se charger plus lentement, c'est pourquoi nous l'avons déplacé vers l'arrière-plan au lieu de forcer l'utilisateur à attendre qu'il se termine!

Conseils et conseils

Le processus des travailleurs s'exécute en arrière-plan, donc même si vous déployez une nouvelle version de l'application, vous aurez toujours un processus de travailleur obsolète avant le premier redémarrage.

Dans notre cas, nous devons attendre que tous les processus de travailleurs terminent leurs tâches ou leur temps de sortie (5 minutes) jusqu'à ce que nous soyons sûrs que tous les processus de travailleurs ont été mis à jour. Soyez conscient de cela lors de la création du processus de déploiement!

FAQs sur l'utilisation du traitement en arrière-plan pour accélérer le temps de chargement de la page (FAQ)

Quel rôle joue le traitement en arrière-plan pour accélérer le chargement de la page?

Le traitement en arrière-plan joue un rôle crucial dans l'amélioration de la vitesse de chargement des pages. Il permet de réaliser certaines tâches en arrière-plan, libérant ainsi les ressources du thread principal et se concentrant sur le chargement de la page. Cela signifie que les utilisateurs n'ont pas à attendre que ces tâches se terminent pour charger la page, ce qui entraîne une expérience de navigation plus rapide et plus fluide.

Comment les composants du processus Symfony aident-ils au traitement des antécédents?

Le composant Symfony Process est un outil puissant qui vous permet d'exécuter des commandes dans les processus enfants. Il fournit une API simple orientée objet pour exécuter les commandes système et gérer sa sortie. Ceci est particulièrement utile pour le traitement en arrière-plan, car il vous permet d'exécuter des tâches dans des processus séparés sans bloquer le thread principal.

Quels sont les cas d'utilisation courants pour le traitement du backend?

Le traitement d'arrière-plan est généralement utilisé dans les situations où les tâches peuvent être exécutées sans tenir compte du fil principal. Cela comprend des tâches telles que l'envoi d'e-mails, le traitement des images, l'exécution de calculs complexes, etc. En exécutant ces tâches en arrière-plan, vous pouvez améliorer les performances de votre application et offrir une meilleure expérience utilisateur.

Comment exécuter les processus d'arrière-plan dans PHP?

La fonction exec() peut être utilisée pour exécuter des processus d'arrière-plan en php. Cette fonction vous permet d'exécuter des commandes dans un processus enfant, puis de continuer à exécuter le reste du script sans attendre que la commande se termine. Voici un exemple simple:

exec("php background_task.php > /dev/null &");

Dans cet exemple, background_task.php est le script que vous souhaitez exécuter en arrière-plan.

Quel est le composant Symfony Messenger et qu'est-ce que cela a à voir avec le traitement en arrière-plan?

Le composant Symfony Messenger est un système de bus de messages qui peut être utilisé pour envoyer des messages de manière asynchrone aux gestionnaires. Cela signifie que vous pouvez envoyer des messages dans le bus, puis continuer à exécuter le script sans attendre que le message soit traité. Il s'agit d'une forme de traitement en arrière-plan, car le traitement des messages peut être effectué dans un processus distinct.

Comment utiliser le traitement du backend pour améliorer les performances de votre site Web?

En déchargeant la tâche à l'arrière-plan, vous pouvez libérer la ressource du thread principal et vous concentrer sur le chargement de la page. Cela peut considérablement améliorer les performances de votre site Web, surtout si vous avez des tâches longues ou à forte intensité de ressources. Certaines tâches courantes qui peuvent être déchargées sur l'arrière-plan comprennent l'envoi d'e-mails, le traitement des images et l'exécution de calculs complexes.

Quels sont les défis potentiels du traitement du backend et comment atténuer ces défis?

L'un des principaux défis du traitement du backend est de s'assurer que les tâches sont réussies et complétées dans le bon ordre. Cela peut être atténué en utilisant une file d'attente de tâches, ce qui garantit que les tâches sont exécutées dans l'ordre où elles sont ajoutées. Un autre défi consiste à gérer les erreurs dans les tâches de fond. Cela peut être résolu en implémentant des mécanismes de gestion des erreurs et de journalisation robustes.

Le traitement de fond peut-il être utilisé en combinaison avec d'autres techniques d'optimisation des performances?

Oui, le traitement de fond peut être utilisé en conjonction avec d'autres techniques d'optimisation des performances. Par exemple, vous pouvez utiliser des caches pour stocker les résultats des opérations coûteuses, puis utiliser le traitement d'arrière-plan pour mettre à jour le cache périodiquement. Cela vous permet de fournir les dernières données sans ralentir l'application.

Comment surveiller la progression des tâches de fond?

Une variété d'outils et de techniques peuvent être utilisés pour surveiller la progression des tâches backend. Une approche commune consiste à utiliser la journalisation pour enregistrer l'état de chaque tâche. Vous pouvez également utiliser des outils comme le composant Messenger de Symfony, qui fournit une prise en charge intégrée pour la surveillance et le débogage des tâches backend.

Y a-t-il des précautions de sécurité lors de l'utilisation du traitement en arrière-plan?

Oui, il y a certaines précautions de sécurité lors de l'utilisation du traitement d'arrière-plan. Par exemple, vous devez vous assurer que les tâches d'arrière-plan ne divulguent pas d'informations sensibles et ne sont pas soumises à des attaques d'injection. Vous devez également vous assurer que vos tâches se déroulent dans un environnement sécurisé et qu'ils n'ont pas plus d'autorisations qu'ils n'ont besoin de faire leur travail.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!