Implémentation d'une file d'attente de tâches hautement disponible à l'aide des services RPC construits avec ThinkPHP6 et Swoole

Utilisation des services RPC construits avec ThinkPHP6 et Swoole pour implémenter des files d'attente de tâches à haute disponibilité

[Introduction]
Les files d'attente de tâches jouent un rôle important dans le développement moderne. Elles peuvent séparer les tâches fastidieuses du processus principal et améliorer la réponse. la vitesse du système peut garantir la fiabilité et la haute disponibilité des tâches en cas de panne du système ou d'interruption du réseau. Dans cet article, nous présenterons comment utiliser ThinkPHP6 et Swoole pour créer une file d'attente de tâches hautement disponible afin de mettre en œuvre un traitement de tâches asynchrone, tout en fournissant des services RPC pour la gestion de la file d'attente de tâches.

【Préparation de l'environnement】
Avant de commencer, nous devons préparer certains environnements de développement, notamment :

1. Environnement PHP, il est recommandé d'utiliser PHP 7.4 et supérieur
2. Installer Composer pour gérer les dépendances du projet ; Base de données, utilisée pour stocker les informations relatives aux tâches ;
3. Installer Redis, utilisée pour implémenter la notification et la surveillance en temps réel des files d'attente de tâches ;
4. Installer l'extension Swoole, utilisée pour implémenter des services RPC hautes performances et le traitement des tâches asynchrones.
5. 【Construction de projet】

Créer un projet

Utilisez Composer pour créer un nouveau projet ThinkPHP6.
1. 
   

   composer create-project topthink/think hello-think

Ajouter des dépendances

Ajoutez les dépendances de Swoole et Swoole-ide-helper dans le fichier composer.json dans le répertoire racine du projet.
2. 
   

   "require": {
       "swoole/swoole": "4.6.7",
       "swoole/ide-helper": "4.6.7"
   }

Ensuite, exécutez la commande

pour installer les dépendances.

composer update

Configurez le service RPC de Swoole et les tâches planifiées

Créez le fichier de configuration swoole.php dans le répertoire de configuration sous le répertoire racine du projet et ajoutez le contenu suivant :
3. 
   

   return [
       'rpc' => [
           'listen_ip' => '0.0.0.0',
           'listen_port' => 9501,
           'worker_num' => 4,
           'task_worker_num' => 4,
       ],
       'task' => [
           'task_ip' => '127.0.0.1',
           'task_port' => 9502,
       ],
       'timer' => [
           'interval' => 1000,
       ],
   ];

Créez le serveur RPC

Créez-le dans le répertoire de l'application du projet Un répertoire rpc et créez le répertoire du serveur dans le répertoire rpc. Créez ensuite un fichier TaskServer.php et ajoutez le contenu suivant :
4. 
   

   namespace apppcserver;
   
   use SwooleServer;
   use thinkRpcServer;
   use thinkacadeConfig;
   
   class TaskServer
   {
       protected $server;
   
       public function start()
       {
           $this->server = new Server(Config::get('swoole.rpc.listen_ip'), Config::get('swoole.rpc.listen_port'));
   
           $rpcServer = new RpcServer($this->server);
   
           $rpcServer->classMap([
               'apppcserviceTaskService',
           ]);
   
           $rpcServer->start();
       }
     
   }

Créer un service RPC

Créez un répertoire de service dans le répertoire rpc et créez un fichier TaskService.php dans le répertoire de service. Dans le fichier TaskService.php, nous définissons certaines méthodes RPC spécifiques, telles que addTask et getTask.
5. 
   

   namespace apppcservice;
   
   class TaskService
   {
       public function addTask($data)
       {
           // 处理添加任务的逻辑，将任务添加到任务队列中
       }
   
       public function getTask($id)
       {
           // 处理获取任务的逻辑，从任务队列中获取相关任务信息
       }
   
       // 其他RPC方法...
   }

[Implémentation de la file d'attente des tâches]

Créer une table de file d'attente des tâches

Créez une table des tâches dans la base de données MySQL pour stocker les informations relatives aux tâches.
1. 
   

   CREATE TABLE `task` (
     `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
     `task_name` varchar(255) DEFAULT NULL,
     `task_data` text,
     `task_status` tinyint(1) DEFAULT NULL,
     `create_time` int(11) DEFAULT NULL,
     `update_time` int(11) DEFAULT NULL,
     PRIMARY KEY (`id`),
     KEY `task_status` (`task_status`)
   ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

Créer un modèle de tâche

Créez un fichier Task.php dans le répertoire appmodel et ajoutez le contenu suivant :
2. 
   

   namespace appmodel;
   
   use thinkModel;
   
   class Task extends Model
   {
       protected $autoWriteTimestamp = true;
       protected $dateFormat = 'Y-m-d H:i:s';
   }

Créez une logique de traitement des tâches

Créez un fichier TaskService.php dans le répertoire appservice et ajoutez le contenu suivant :
3. 
   

   namespace appservice;
   
   use appmodelTask;
   
   class TaskService
   {
       public function addTask($data)
       {
           $task = new Task;
           $task->task_name = $data['task_name'];
           $task->task_data = $data['task_data'];
           $task->task_status = 0;
           $task->save();
   
           // TODO: 将任务添加到任务队列中
       }
   
       public function getTask($id)
       {
           return Task::find($id);
       }
   
       // 其他任务处理逻辑...
   }

Le serveur RPC appelle la logique de traitement des tâches

Dans la méthode addTask de TaskService.php, nous gérerons la logique d'ajout de tâches, telles que le stockage des tâches dans la base de données, puis l'ajout de tâches à la file d'attente des tâches.
4. 
   
[Implémentation des tâches planifiées]

Créer une logique de traitement des tâches planifiées

Créez un fichier TimerService.php dans le répertoire appservice et ajoutez le contenu suivant :
1. 
   

   namespace appservice;
   
   use appmodelTask;
   use SwooleTimer;
   
   class TimerService
   {
       public function start()
       {
           Timer::tick(config('swoole.timer.interval'), function() {
               // TODO: 定时检查任务队列，处理待执行的任务
           });
       }
     
       // 其他定时任务处理逻辑...
   }

Ajouter des tâches planifiées dans TaskServer.php

Dans TaskServer In la méthode de démarrage de .php, ajoutez la logique de démarrage de la tâche planifiée.
2. 
   

   public function start()
   {
       $this->server = new Server(Config::get('swoole.rpc.listen_ip'), Config::get('swoole.rpc.listen_port'));
   
       $rpcServer = new RpcServer($this->server);
   
       $rpcServer->classMap([
           'apppcserviceTaskService',
       ]);
   
       $timerService = new TimerService();
       $timerService->start();
   
       $rpcServer->start();
   }

【Démarrer le service RPC et la file d'attente des tâches】

Exécutez la commande suivante dans le répertoire racine du projet pour démarrer le service RPC et la file d'attente des tâches.

php think swoole:rpc start

【Exemple d'appel RPC】

Un exemple d'utilisation de RPC pour appeler une file d'attente de tâches dans une application.

class Index extends Controller
{
    public function index()
    {
        $taskService = new pppcserviceTaskService();
        $taskService->addTask([
            'task_name' => '任务名称',
            'task_data' => '任务数据',
        ]);
    }
}

【Résumé】

En utilisant ThinkPHP6 et l'extension Swoole, nous pouvons créer un système de file d'attente de tâches hautement disponible. Utilisez les services RPC pour gérer les files d'attente de tâches, fournir des interfaces pour ajouter et obtenir des tâches, réaliser un traitement asynchrone des tâches et améliorer la vitesse de réponse et la disponibilité du système. Dans le même temps, grâce à la fonction de tâches planifiées de Swoole, vous pouvez vérifier régulièrement la file d'attente des tâches et traiter les tâches en attente en temps opportun. Une telle architecture système peut non seulement améliorer les capacités de traitement du système, mais présente également une bonne évolutivité et une bonne tolérance aux pannes.

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!