Créer un système de planification de tâches planifiées hautement disponible au niveau de l'entreprise basé sur Swoole

Avec le développement continu de l'industrie Internet et les progrès continus de la technologie, les systèmes de planification de tâches planifiées deviennent de plus en plus importants dans divers scénarios d'applications à grande échelle au niveau de l'entreprise. Les entreprises ont besoin d'un système de planification de tâches planifiées hautement disponible et facilement évolutif pour gérer régulièrement les processus commerciaux quotidiens, tels que la sauvegarde des données, l'envoi d'e-mails, les statistiques régulières, etc., afin de garantir la stabilité et la fiabilité du système. Cet article explique comment créer un système de planification de tâches planifiées hautement disponible au niveau de l'entreprise, basé sur le framework Swoole.

Swoole est un moteur de communication réseau coroutine basé sur le langage PHP, qui peut permettre aux programmes PHP d'avoir les mêmes fonctionnalités de concurrence élevée et de hautes performances que Node.js. Swoole fournit une communication réseau riche et des fonctions d'E/S asynchrones, qui peuvent fournir une prise en charge puissante pour les applications de niveau entreprise. Ci-dessous, nous présenterons en détail comment utiliser Swoole pour créer un système de planification de tâches planifiées hautement disponible au niveau de l'entreprise.

1. Idées de conception

Lors de la conception d'un système de planification de tâches planifiées, nous devons prendre en compte les aspects suivants :

1. Gestion des tâches : responsable de la gestion et de la planification de toutes les tâches, y compris la création de tâches, la modification de tâches, la suppression de tâches. gestion de l'état d'exécution, etc.

2. Exécution des tâches : responsable de l'exécution de tâches spécifiques, y compris l'appel du code de logique métier spécifié, l'enregistrement des journaux d'exécution des tâches, la gestion des exceptions de tâches, etc.

3. Planification des tâches : responsable de l'attribution des tâches aux exécuteurs testamentaires correspondants selon des intervalles de temps et des règles prédéterminés.

4. Surveillance des tâches : responsable de la surveillance de l'état d'exécution de toutes les tâches, de la découverte et du traitement des problèmes anormaux en temps opportun et de la garantie de la stabilité et de la fiabilité du système.

Sur la base des idées ci-dessus, nous pouvons diviser l'ensemble du système en les couches suivantes :

Couche de planification des tâches : responsable de la planification et de la répartition des tâches, et de l'attribution des tâches aux exécuteurs correspondants.

Couche de file d'attente de messages : utilisée pour stocker les informations sur les tâches et les résultats d'exécution afin d'améliorer les capacités de traitement et la stabilité du système.

Couche d'exécution : l'exécuteur de tâches spécifique est responsable de l'exécution des tâches spécifiées et de l'écriture des résultats dans la file d'attente des messages.

Couche de surveillance : surveillez l'état de fonctionnement de l'ensemble du système, détectez et gérez les anomalies en temps opportun.

2. Architecture technique

1. Planification des tâches

La planification des tâches est la partie centrale de l'ensemble du système, et les tâches doivent être planifiées et allouées selon des règles et des intervalles de temps prédéterminés. Nous pouvons utiliser les minuteries et les coroutines de Swoole pour implémenter des fonctions de planification de tâches. Tout d'abord, nous devons démarrer un processus Swoole pour exécuter la logique de planification des tâches planifiées :

$scheduler = new Scheduler();
$scheduler->add(function () use ($taskManager) {

$taskManager->assignTask();

}, '' , SWOOLE_TIMER_INTERVAL * 1000);

Parmi eux, $taskManager est l'objet de gestion des tâches. Dans sa fonction assignTask(), nous pouvons sélectionner la tâche appropriée dans la liste des tâches et l'attribuer à la tâche correspondante selon les règles et le temps prédéterminés. intervalles. L'exécuteur :

fonction publique assignTask()
{

$now = time();
foreach ($this->tasks as $task) {
    if ($task->nextExecTime == 0) {
        $task->nextExecTime = strtotime($task->cron);
    }
    if ($task->nextExecTime <= $now) {
        $task->nextExecTime = strtotime($task->cron, $now);
        $this->executeTask($task);
    }
}

}

Dans la fonction exécuterTask(), nous pouvons mettre les informations sur la tâche dans la file d'attente des messages et attendre que l'exécuteur traite :

fonction publique exécuterTask ($task)
{

// 将任务信息放入消息队列中
$this->queue->push($task);

}

2. Exécution des tâches

L'exécution des tâches est une autre partie essentielle de l'ensemble du système. Elle doit appeler le code de logique métier correspondant en fonction des informations sur la tâche et écrire les résultats de l'exécution dans le fichier. file d'attente des messages. Étant donné que des exceptions peuvent survenir lors de l'exécution d'une tâche, la gestion des exceptions doit être effectuée pendant le processus d'exécution et les journaux d'exécution doivent être enregistrés. Nous pouvons utiliser les coroutines et les fonctions d'E/S asynchrones de Swoole pour obtenir des fonctions d'exécution de tâches hautes performances. Tout d'abord, nous devons démarrer plusieurs sous-processus Swoole en tant qu'exécuteurs de tâches :

for ($i = 0; $i < SWOOLE_PROCESS_NUM; $i++) {

$worker = new Worker();
$worker->onWorkerStart = function ($worker) use ($queue) {
    while (true) {
        // 从消息队列中获取任务信息
        $task = $queue->pop();
        if (!$task) continue;
        // 执行任务
        $result = $this->execute($task);
        // 将执行结果写入消息队列中
        $this->queue->push($result);
    }
};
$worker->listen();

}

Dans la fonctionexecute(), nous pouvons les informations sur la tâche appellent le code de logique métier correspondant et effectuent la gestion et la journalisation des exceptions :

public function perform ($task)
{

// 调用业务逻辑代码
try {
    $result = $this->doTask($task);
    return $result;
} catch (Exception $e) {
    // 异常处理
    $errMsg = sprintf("Task failed: %s, error message: %s", $task->name, $e->getMessage());
    $this->log($errMsg);
    return false;
}

}

3. . Utilisation Il est utilisé pour stocker les informations sur les tâches et les résultats d'exécution, et pour améliorer les capacités de traitement et la stabilité du système. Nous pouvons utiliser les fonctions coroutine et IO asynchrones fournies par Swoole pour implémenter des fonctions de file d'attente de messages hautes performances. Tout d'abord, nous devons démarrer un processus Swoole en tant que file d'attente de messages :

$queue = new Channel();

$server = new Server('0.0.0.0', 9501, SWOOLE_PROCESS, SWOOLE_SOCK_TCP);

$server-> on( 'receive', function ($server, $fd, $from_id, $data) use ($queue) {

// 将消息放入消息队列中
$queue->push($data);

});

$server->start();

Pendant le processus d'exécution de tâche spécifique , Nous pouvons écrire les informations sur la tâche et les résultats d'exécution dans la file d'attente des messages et attendre que d'autres composants soient traités :

// Mettre les informations sur la tâche dans la file d'attente des messages

$this->queue->push($task);

4. Système de surveillance

Le système de surveillance est un élément indispensable de l'ensemble du système. Il est utilisé pour surveiller l'état de fonctionnement de l'ensemble du système, détecter et gérer les problèmes anormaux en temps opportun et assurer la stabilité et la fiabilité du système. . Nous pouvons utiliser les fonctions de gestion de processus et de traitement du signal de Swoole pour mettre en œuvre les fonctions du système de surveillance. Nous pouvons démarrer un processus Swoole en tant que processus de surveillance :

$monitor = new Monitor();

$monitor->start();

Dans la fonction start() de la classe Monitor, nous pouvons utiliser la gestion des processus de Swoole. et Fonction de traitement du signal pour mettre en œuvre les fonctions du système de surveillance :

public function start()

{

// 注册信号处理函数
pcntl_signal(SIGUSR1, array($this, 'handleSignal'));
while (true) {
    $cpuUsage = $this->getCpuUsage();
    $memUsage = $this->getMemUsage();
    $this->log(sprintf('CPU usage: %.2f%%, Memory usage: %.2fMB', $cpuUsage, $memUsage));
    sleep(MONITOR_INTERVAL);
}

}

其中，getCpuUsage()函数用于获取当前进程的CPU使用率，getMemUsage()函数用于获取当前进程的内存使用情况，handleSignal()函数用于处理信号并进行相应的处理。

三、系统部署

在系统部署方面，我们可以使用Docker容器化的方式，来实现系统的快速部署和迁移。首先，我们需要构建一组Docker镜像：

docker build -t task-scheduler:latest .
docker build -t task-executor:latest .
docker build -t task-queue:latest .
docker build -t task-monitor:latest .

其中，task-scheduler镜像用于运行任务调度进程，task-executor镜像用于运行任务执行进程，task-queue镜像用于运行消息队列进程，task-monitor镜像用于运行监控进程。

接着，我们可以使用docker-compose来启动和管理整个系统：

version: '3'
services:
scheduler:

image: task-scheduler:latest
restart: always

executor:

image: task-executor:latest
restart: always
scale: 5

queue:

image: task-queue:latest
restart: always

monitor:

image: task-monitor:latest
restart: always

其中，scheduler服务用于启动任务调度进程，executor服务用于启动任务执行进程，queue服务用于启动消息队列进程，monitor服务用于启动监控进程。可以根据实际情况，调整服务的数量和启动参数。

四、总结

本文介绍了如何基于Swoole框架构建一套高可用的企业级定时任务调度系统，其中涵盖了任务调度、任务执行、消息队列和监控等方面。Swoole的高性能和异步IO特性，为企业级应用提供了强大的支持，能够满足各种大规模应用的需求。通过本文的介绍，相信读者可以更好地了解Swoole框架的应用和实践。

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!