Comment implémenter l'allocation et la planification distribuées des tâches dans les microservices PHP

Comment implémenter l'allocation et la planification distribuées des tâches dans les microservices PHP
L'allocation et la planification distribuées des tâches sont une exigence courante lors de la création d'applications à grande échelle. En tant que langage de développement Web couramment utilisé, PHP peut également être utilisé pour créer une architecture de microservices et mettre en œuvre une allocation et une planification distribuées des tâches. Cet article présentera comment implémenter l'allocation et la planification distribuées des tâches dans les microservices PHP, et fournira des exemples de code spécifiques.

1. Allocation de tâches distribuée
Dans l'allocation de tâches distribuée, il existe un éditeur de tâches qui publie les tâches dans la file d'attente des tâches, puis plusieurs consommateurs de tâches traitent ces tâches. En PHP, les files d'attente peuvent être utilisées pour implémenter la distribution des tâches. Les services de file d'attente couramment utilisés incluent RabbitMQ et Redis.

1. Utilisez RabbitMQ pour implémenter la file d'attente des tâches
   RabbitMQ est un puissant middleware de messages qui peut implémenter des fonctions de file d'attente des tâches. Tout d’abord, installez RabbitMQ et démarrez le service. Ensuite, utilisez la bibliothèque client de RabbitMQ en code PHP pour publier des tâches et recevoir des tâches.

Exemple de code de tâche de publication :

<?php
require_once __DIR__ . '/vendor/autoload.php';

use PhpAmqpLibConnectionAMQPStreamConnection;
use PhpAmqpLibMessageAMQPMessage;

$connection = new AMQPStreamConnection('localhost', 5672, 'guest', 'guest');
$channel = $connection->channel();

$channel->queue_declare('task_queue', false, true, false, false);

$data = implode(' ', array_slice($argv, 1));
if (empty($data)) {
    $data = "Hello World!";
}

$msg = new AMQPMessage($data, ['delivery_mode' => AMQPMessage::DELIVERY_MODE_PERSISTENT]);

$channel->basic_publish($msg, '', 'task_queue');

echo " [x] Sent $data
";

$channel->close();
$connection->close();
?>

Exemple de code de tâche de réception :

<?php
require_once __DIR__ . '/vendor/autoload.php';

use PhpAmqpLibConnectionAMQPStreamConnection;

$connection = new AMQPStreamConnection('localhost', 5672, 'guest', 'guest');
$channel = $connection->channel();

$channel->queue_declare('task_queue', false, true, false, false);

echo " [*] Waiting for messages. To exit, press CTRL+C
";

$callback = function ($msg) {
    echo ' [x] Received ', $msg->body, "
";
    sleep(substr_count($msg->body, '.'));

    echo " [x] Done
";
    $msg->delivery_info['channel']->basic_ack($msg->delivery_info['delivery_tag']);
};

$channel->basic_qos(null, 1, null);
$channel->basic_consume('task_queue', '', false, false, false, false, $callback);

while ($channel->is_consuming()) {
    $channel->wait();
}

$channel->close();
$connection->close();
?>

2. Utilisez Redis pour implémenter la file d'attente des tâches
   Redis est également un service de file d'attente couramment utilisé. Après avoir installé et démarré le service Redis, vous pouvez utiliser l'extension Redis de PHP pour implémenter la publication et la réception de tâches.

Exemple de code de tâche de publication :

<?php
$redis = new Redis();
$redis->connect('127.0.0.1', 6379);

$data = implode(' ', array_slice($argv, 1));
if (empty($data)) {
    $data = "Hello World!";
}

$redis->lPush('task_queue', $data);

echo " [x] Sent $data
";
?>

Exemple de code de tâche de réception :

<?php
$redis = new Redis();
$redis->connect('127.0.0.1', 6379);

echo " [*] Waiting for messages. To exit, press CTRL+C
";

while (true) {
    $data = $redis->brPop('task_queue', 0);

    echo ' [x] Received ', $data[1], "
";
    sleep(substr_count($data[1], '.'));

    echo " [x] Done
";
}
?>

L'exemple de code ci-dessus peut publier des tâches dans la file d'attente, puis traiter ces tâches par plusieurs consommateurs. Le nombre de consommateurs peut être augmenté en fonction des besoins réels pour réaliser un traitement de tâches distribué.

2. Planification des tâches distribuées
La planification des tâches distribuées signifie que dans un système distribué, les tâches sont assignées aux nœuds appropriés pour être exécutées selon les règles spécifiques de la tâche. En PHP, vous pouvez utiliser le planificateur de tâches pour implémenter la planification distribuée des tâches. Les planificateurs de tâches couramment utilisés incluent le planificateur de tâches de Laravel et Cron.

1. Utilisation du planificateur de tâches de Laravel
   Laravel est un framework PHP populaire qui offre de puissantes capacités de planification de tâches. Tout d’abord, installez et configurez le projet Laravel. Ensuite, définissez la tâche dans le planificateur de tâches de Laravel et spécifiez la fréquence d'exécution et la commande d'exécution de la tâche.

Exemple de définition de code de tâche :

<?php

namespace AppConsoleCommands;

use IlluminateConsoleCommand;

class ProcessTask extends Command
{
    protected $signature = 'task:process';
    protected $description = 'Process tasks';

    public function __construct()
    {
        parent::__construct();
    }

    public function handle()
    {
        // 处理任务的代码
    }
}

Définissez la fréquence d'exécution de la tâche dans le planificateur de tâches :

<?php

namespace AppConsole;

use IlluminateConsoleSchedulingSchedule;
use IlluminateFoundationConsoleKernel as ConsoleKernel;

class Kernel extends ConsoleKernel
{
    protected $commands = [
        CommandsProcessTask::class,
    ];

    protected function schedule(Schedule $schedule)
    {
        $schedule->command('task:process')->everyMinute();
    }

    protected function commands()
    {
        $this->load(__DIR__.'/Commands');

        require base_path('routes/console.php');
    }
}

2. Utilisez Cron pour implémenter la planification des tâches
   Cron est un outil de système d'exploitation de type Unix permettant d'exécuter des tâches régulièrement. La planification des tâches peut être réalisée en définissant le temps d'exécution de la tâche dans une expression Cron. En PHP, vous pouvez utiliser des scripts shell pour effectuer des tâches PHP.

Écrivez le fichier de script :

#!/bin/bash

php /path/to/task.php

Définissez l'expression Cron :

* * * * * /path/to/script.sh

L'exemple de code ci-dessus peut exécuter des tâches régulièrement et attribuer les tâches aux nœuds correspondants pour exécution en fonction du temps d'exécution de la tâche.

En résumé, en utilisant les services de file d'attente et les planificateurs de tâches dans les microservices PHP, il est possible de réaliser une allocation et une planification distribuées des tâches. Les développeurs peuvent choisir le service de file d'attente et le planificateur de tâches appropriés en fonction des besoins réels, puis configurer et développer en fonction de l'exemple de code. Grâce à l'allocation et à la planification distribuées des tâches, les capacités de traitement simultané du système et l'efficacité de l'exécution des tâches peuvent être améliorées.

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!