Comment utiliser PHP pour la conception de base de planification de tâches distribuées

À mesure que les applications Internet modernes deviennent de plus en plus complexes, les systèmes distribués sont devenus une technologie essentielle pour créer des applications à haute disponibilité et hautes performances. La planification distribuée des tâches en constitue également un élément important. Elle peut disperser les tâches sur différents nœuds pour leur exécution, améliorant ainsi l'efficacité et la vitesse d'exécution des tâches. Dans cet article, nous présenterons comment utiliser PHP pour la conception de base de planification de tâches distribuées.

1. Comprendre le concept de planification distribuée des tâches

Dans un système distribué, afin de distribuer les tâches à différents nœuds pour exécution, il est généralement nécessaire de concevoir une planification des tâches système . Ce système peut attribuer des tâches aux nœuds inactifs pour exécution et ajuster dynamiquement l'allocation des tâches en fonction de la charge des nœuds. De cette façon, vous pouvez profiter du système distribué pour exécuter des tâches sur plusieurs nœuds simultanément, améliorant ainsi l'efficacité d'exécution et la vitesse de réponse.

2. Concevoir un framework pour la planification distribuée des tâches

En PHP, divers frameworks peuvent être utilisés pour concevoir un système de planification distribuée des tâches. Parmi eux, les frameworks les plus couramment utilisés sont Symfony et Laravel. Les deux frameworks fournissent des composants et des extensions associés pour la planification distribuée des tâches, qui peuvent rapidement créer un système de planification des tâches stable et efficace.

1. Utilisez le framework Symfony

Dans le framework Symfony, vous pouvez utiliser le composant Messenger pour implémenter la planification distribuée des tâches. Messenger est un composant de messagerie asynchrone qui peut envoyer des messages à différentes files d'attente, retirer des messages de la file d'attente et les transmettre aux travailleurs pour traitement. Ce composant est très adapté aux scénarios tels que la planification de tâches et les tâches asynchrones dans les systèmes distribués.

Tout d'abord, vous devez installer le composant Messenger dans le projet :

composer require symfony/messenger

Ensuite, définissez une classe de message dans l'application :

// src/Message/ExampleMessage.php

namespace AppMessage;

final class ExampleMessage
{
    private $text;

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

    public function getText(): string
    {
        return $this->text;
    }
}

This la classe représente une tâche à traiter, contenant un attribut de texte.

Ensuite, vous devez écrire un gestionnaire de messages pour traiter ces messages :

// src/MessageHandler/ExampleMessageHandler.php

namespace AppMessageHandler;

use AppMessageExampleMessage;

final class ExampleMessageHandler
{
    public function __invoke(ExampleMessage $message)
    {
        // 处理任务逻辑
    }
}

Enfin, créez un producteur de messages pour envoyer le message à la file d'attente des messages : #🎜🎜 #

// src/Controller/ExampleController.php

namespace AppController;

use SymfonyComponentHttpFoundationResponse;
use SymfonyComponentMessengerMessageBusInterface;
use AppMessageExampleMessage;

final class ExampleController
{
    public function index(MessageBusInterface $bus): Response
    {
        $bus->dispatch(new ExampleMessage('hello'));

        return new Response('Task scheduled');
    }
}

En utilisant le framework Symfony et les composants Messenger, vous pouvez rapidement créer un système de planification de tâches distribué. Il vous suffit de définir des classes de messages, des gestionnaires de messages et des producteurs de messages, et les tâches peuvent être affectées à différents nœuds pour exécution.

2. Utilisez le framework Laravel

Dans le framework Laravel, vous pouvez utiliser l'extension Horizon pour implémenter la planification distribuée des tâches. Horizon est le gestionnaire de planification de tâches officiel de Laravel. Il peut allouer des tâches à différentes files d'attente et ajuster dynamiquement l'allocation des tâches en fonction de la charge de la file d'attente. Horizon fournit également un ensemble d'outils de surveillance puissants qui peuvent aider les développeurs à suivre les résultats d'exécution et la planification des tâches en temps réel.

Pour utiliser l'extension Horizon, vous devez d'abord installer cette extension :

composer require laravel/horizon

Ensuite, vous devez définir la file d'attente et le pilote de file d'attente à utiliser dans le fichier de configuration :

// config/queue.php

return [
    'default' => env('QUEUE_CONNECTION', 'redis'),

    'connections' => [
        'redis' => [
            'driver' => 'redis',
            'connection' => 'default',
            'queue' => ['default', 'high', 'low'],
            'retry_after' => 90,
            'block_for' => null,
        ],
    ],
];

Ensuite, vous devez démarrer le gestionnaire Horizon dans la console :

php artisan horizon

Maintenant, vous pouvez définir une classe de tâches dans l'application et envoyer la tâche vers la file d'attente spécifiée :

// app/Jobs/ExampleJob.php

namespace AppJobs;

use IlluminateBusQueueable;
use IlluminateContractsQueueShouldQueue;
use IlluminateFoundationBusDispatchable;
use IlluminateQueueInteractsWithQueue;
use IlluminateQueueSerializesModels;

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

    protected $text;

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

    public function handle()
    {
        // 处理任务逻辑
    }
}

Vous pouvez envoyer des tâches à la file d'attente spécifiée dans le contrôleur :

// app/Http/Controllers/ExampleController.php

namespace AppHttpControllers;

use AppJobsExampleJob;

class ExampleController extends Controller
{
    public function index()
    {
        ExampleJob::dispatch('hello')->onQueue('default');

        return 'Task scheduled';
    }
}

En utilisant le framework Laravel et l'extension Horizon, vous pouvez rapidement créer un système de planification de tâches distribué. Il vous suffit de définir la classe de tâches et d'envoyer la tâche à la file d'attente spécifiée, et la tâche peut être affectée à différents nœuds pour être exécutée.

3. Résumé

Cet article explique comment utiliser Php pour la conception de base de planification de tâches distribuées. Dans les applications réelles, il est également nécessaire de sélectionner les composants et outils de système distribué appropriés en fonction de scénarios et de besoins commerciaux spécifiques, et de concevoir un système de planification de tâches distribuées stable, efficace et évolutif.

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!