Erstellen Sie ein hochverfügbares System zur Planung geplanter Aufgaben auf Unternehmensebene basierend auf Swoole

Mit der kontinuierlichen Entwicklung der Internetbranche und der kontinuierlichen Weiterentwicklung der Technologie werden Systeme zur Planung geplanter Aufgaben in verschiedenen Anwendungsszenarien auf Unternehmensebene in großem Maßstab immer wichtiger. Unternehmen benötigen ein hochverfügbares und leicht skalierbares System zur Planung geplanter Aufgaben, um die täglichen Geschäftsprozesse wie Datensicherung, E-Mail-Versand, regelmäßige Statistiken usw. regelmäßig abzuwickeln und die Stabilität und Zuverlässigkeit des Systems sicherzustellen. In diesem Artikel wird erläutert, wie Sie ein hochverfügbares System zur Planung geplanter Aufgaben auf Unternehmensebene basierend auf dem Swoole-Framework erstellen.

Swoole ist eine auf der PHP-Sprache basierende Coroutine-Netzwerkkommunikations-Engine, mit der PHP-Programme über die gleichen hohen Parallelitäts- und Hochleistungsfunktionen wie Node.js verfügen können. Swoole bietet umfassende Netzwerkkommunikation und asynchrone E/A-Funktionen, die leistungsstarke Unterstützung für Anwendungen auf Unternehmensebene bieten können. Im Folgenden stellen wir detailliert vor, wie Sie mit Swoole ein hochverfügbares System zur Planung geplanter Aufgaben auf Unternehmensebene erstellen können.

1. Designideen

Beim Entwerfen eines geplanten Aufgabenplanungssystems müssen wir die folgenden Aspekte berücksichtigen:

1. Aufgabenverwaltung: Verantwortlich für die Verwaltung und Planung aller Aufgaben, einschließlich Aufgabenerstellung, Aufgabenänderung, Aufgabenlöschung Laufende Statusverwaltung usw.

2. Aufgabenausführung: Verantwortlich für die spezifische Aufgabenausführung, einschließlich des Aufrufs bestimmter Geschäftslogikcodes, der Aufzeichnung von Aufgabenausführungsprotokollen, der Behandlung von Aufgabenausnahmen usw.

3. Aufgabenplanung: Verantwortlich für die Zuweisung von Aufgaben an die entsprechenden Ausführenden gemäß vorgegebenen Zeitintervallen und Regeln.

4. Aufgabenüberwachung: Verantwortlich für die Überwachung des Ausführungsstatus aller Aufgaben, die rechtzeitige Erkennung und Behebung ungewöhnlicher Probleme sowie die Gewährleistung der Stabilität und Zuverlässigkeit des Systems.

Basierend auf den oben genannten Ideen können wir das gesamte System in die folgenden Schichten unterteilen:

Aufgabenplanungsschicht: Verantwortlich für die Planung und Verteilung von Aufgaben sowie die Zuweisung von Aufgaben an die entsprechenden Ausführenden.

Nachrichtenwarteschlangenschicht: Wird zum Speichern von Aufgabeninformationen und Ausführungsergebnissen verwendet, um die Verarbeitungsfähigkeiten und Stabilität des Systems zu verbessern.

Ausführungsschicht: Spezifischer Aufgabenausführer, verantwortlich für die Ausführung bestimmter Aufgaben und das Schreiben der Ergebnisse in die Nachrichtenwarteschlange.

Überwachungsschicht: Überwachen Sie den Betriebsstatus des gesamten Systems, erkennen und beheben Sie Anomalien rechtzeitig.

2. Technische Architektur

1. Aufgabenplanung

Die Aufgabenplanung ist der Kernbestandteil des gesamten Systems, und Aufgaben müssen nach vorgegebenen Regeln und Zeitintervallen geplant und zugewiesen werden. Wir können die Timer und Coroutinen von Swoole verwenden, um Aufgabenplanungsfunktionen zu implementieren. Zuerst müssen wir einen Swoole-Prozess starten, um die Planungslogik für geplante Aufgaben auszuführen:

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

$taskManager->assignTask();

}, '' , SWOOLE_TIMER_INTERVAL * 1000);

Unter diesen ist $taskManager das Aufgabenverwaltungsobjekt. In seiner Funktion „assignTask()“ können wir die entsprechende Aufgabe aus der Aufgabenliste auswählen und sie gemäß den vorgegebenen Regeln und der vorgegebenen Zeit der entsprechenden Aufgabe zuweisen Intervalle. Der Ausführende:

öffentliche Funktion „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);
    }
}

}

In der Funktion „executeTask()“ können wir die Aufgabeninformationen in die Nachrichtenwarteschlange stellen und darauf warten, dass der Ausführende Folgendes verarbeitet: „öffentliche Funktion „executeTask“. ($task)

{

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

}

2. Die Aufgabenausführung ist ein weiterer Kernbestandteil des gesamten Systems. Sie muss den entsprechenden Geschäftslogikcode auf der Grundlage der Aufgabeninformationen aufrufen und die Ausführungsergebnisse in das System schreiben Nachrichtenwarteschlange. Da während der Aufgabenausführung Ausnahmen auftreten können, muss während des Ausführungsprozesses eine Ausnahmebehandlung durchgeführt und Ausführungsprotokolle aufgezeichnet werden. Wir können die Coroutinen und asynchronen E/A-Funktionen von Swoole verwenden, um leistungsstarke Aufgabenausführungsfunktionen zu erreichen. Zuerst müssen wir mehrere Swoole-Unterprozesse als Task-Ausführer starten:

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();

}

In der Funktionexecute() können wir The Aufgabeninformationen rufen den entsprechenden Geschäftslogikcode auf und führen die Ausnahmebehandlung und Protokollierung durch:

public functionexecute($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. Nachrichtenwarteschlange

Die Nachrichtenwarteschlange ist der Kommunikationsknotenpunkt des gesamten Systems . Verwendung Es wird zum Speichern von Aufgabeninformationen und Ausführungsergebnissen sowie zur Verbesserung der Systemverarbeitungsfähigkeiten und -stabilität verwendet. Wir können die von Swoole bereitgestellten Coroutine- und asynchronen E/A-Funktionen verwenden, um leistungsstarke Nachrichtenwarteschlangenfunktionen zu implementieren. Zuerst müssen wir einen Swoole-Prozess als Nachrichtenwarteschlange starten:

$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();

Während der Ausführung des spezifischen Aufgabe: Wir können Aufgabeninformationen und Ausführungsergebnisse in die Nachrichtenwarteschlange schreiben und auf die Verarbeitung durch andere Komponenten warten:

// Aufgabeninformationen in die Nachrichtenwarteschlange stellen

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

4. Überwachungssystem

Das Überwachungssystem ist ein unverzichtbarer Bestandteil des gesamten Systems. Es dient dazu, den Betriebsstatus des gesamten Systems zu überwachen, ungewöhnliche Probleme rechtzeitig zu erkennen und zu beheben und die Stabilität und Zuverlässigkeit des Systems sicherzustellen System. Wir können die Prozessmanagement- und Signalverarbeitungsfunktionen von Swoole nutzen, um die Funktionen des Überwachungssystems zu implementieren. Wir können einen Swoole-Prozess als Überwachungsprozess starten:

$monitor = new Monitor();

$monitor->start();

In der start()-Funktion der Monitor-Klasse können wir die Prozessverwaltung von Swoole verwenden und Signalverarbeitungsfunktion zur Implementierung der Funktionen des Überwachungssystems:

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框架的应用和实践。

Das obige ist der detaillierte Inhalt vonErstellen Sie ein hochverfügbares System zur Planung geplanter Aufgaben auf Unternehmensebene basierend auf Swoole. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!