Comment utiliser Workerman pour implémenter un système informatique distribué

Un système informatique distribué fait référence à un modèle informatique qui traite un groupe d'ordinateurs comme un système unique pour effectuer des tâches informatiques de manière collaborative. En pratique, les systèmes informatiques distribués peuvent augmenter la vitesse de calcul en augmentant le nombre d'ordinateurs, tout en résolvant le problème du traitement de grandes quantités de données. Workerman est un framework qui peut implémenter des systèmes informatiques distribués à l'aide du langage PHP. Cet article explique comment utiliser Workerman pour implémenter un système informatique distribué simple et fournit des exemples de code.

1. Installer Workerman

Tout d'abord, nous devons installer Workerman. Il peut être installé via Composer. La commande spécifique est la suivante :

composer require workerman/workerman

2. Créez un programme serveur

Créons un programme serveur nommé server.php En exécutant ce programme, le client peut soumettre des tâches informatiques côté serveur. est chargé d'attribuer les tâches aux nœuds de calcul pour le calcul et de renvoyer les résultats finaux au client. Voici un exemple de code de server.php :

<?php
use WorkermanWorker;

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

$worker = new Worker('text://0.0.0.0:2346');

$worker->count = 4;

$worker->onMessage = function($connection, $data){
    $params = json_decode($data, true);

    $worker_num = $params['worker_num'];
    $task_data = $params['task_data'];

    $task_id = md5($task_data);

    $task_worker = new Task($task_id);
    $task_worker->send([
        'worker_num' => $worker_num,
        'task_data' => $task_data
    ]);
  
    $connection->send(json_encode([
        'task_id' => $task_id
    ]));
};

class Task{
    protected $task_id;
  
    protected $worker_num;

    protected $task_data;

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

    public function send($data){
        $task_data = json_encode([
            'task_id' => $this->task_id,
            'data' => $data
        ]);

        $worker_num = $data['worker_num'];
        $socket_name = "tcp://127.0.0.1:".(2347 + $worker_num);

        $client = stream_socket_client($socket_name, $errno, $errstr);
  
        fwrite($client, $task_data);
        fclose($client);
    }
}

Worker::runAll();

Dans le code ci-dessus, nous utilisons le port d'écoute du serveur pour attendre que le client soumette une tâche. Lorsque le serveur reçoit la tâche soumise par le client, le serveur attribuera la tâche à un nœud informatique pour le calcul et renverra les résultats au client.

Dans l'instance de la classe Worker, nous configurons 4 processus pour gérer les demandes des clients. Dans le rappel de l'événement onMessage, nous obtenons d'abord worker_num et task_data à partir des données JSON soumises par le client, puis créons une nouvelle instance de Task, envoyons la tâche au nœud informatique et attendons que le résultat du calcul soit renvoyé.

Dans la classe Task, nous stockons l'ID de la tâche (task_id), le numéro de nœud à calculer (worker_num) et les données à calculer (task_data). La méthode send() est utilisée pour envoyer des tâches au nœud informatique spécifié. Ici, nous utilisons la fonction stream_socket_client() pour implémenter un client socket TCP pour communiquer avec le nœud informatique spécifié.

3. Créer un programme de nœud informatique

Ensuite, créons un programme de nœud informatique nommé worker.php. Le programme effectuera des calculs une fois que le serveur lui aura attribué les tâches de calcul et renverra les résultats au serveur. Voici un exemple de code pour worker.php :

<?php
use WorkermanWorker;

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

$worker_num = intval($argv[1]);

$worker = new Worker("tcp://0.0.0.0:". (2347 + $worker_num));

$worker->onMessage = function($connection, $data){
    $params = json_decode($data, true);
    $task_id = $params['task_id'];

    $task_data = $params['data'];

    $result = strlen($task_data);

    $connection->send(json_encode([
        'task_id' => $task_id,
        'result' => $result
    ]));
};

Worker::runAll();

Dans le code ci-dessus, nous utilisons un socket TCP pour écouter un port et attendre que le serveur attribue des tâches informatiques. Lorsqu'une tâche informatique doit être traitée, nous obtenons les données à traiter à partir des données de la tâche, effectuons des calculs et envoyons les résultats au serveur.

4. Créer un programme client

Enfin, nous devons créer un programme client nommé client.php pour soumettre les tâches de calcul au serveur et obtenir les résultats des calculs. Voici l'exemple de code pour client.php :

<?php
use WorkermanWorker;

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

$client = stream_socket_client("tcp://127.0.0.1:2346", $errno, $errstr);

$data = [
    'worker_num' => 1,
    'task_data' => 'Workerman is a high-performance PHP socket framework'
];

$json_data = json_encode($data);

fwrite($client, $json_data);
$result = fread($client, 8192);

fclose($client);

$result_data = json_decode($result, true);

$task_id = $result_data['task_id'];

foreach(range(0,3) as $worker_num){
    $worker_client = stream_socket_client("tcp://127.0.0.1:". (2347 + $worker_num), $errno, $errstr);

    fwrite($worker_client, json_encode([
        'task_id' => $task_id,
        'worker_num' => $worker_num
    ]));

    $worker_result = fread($worker_client, 8192);

    $worker_result_data = json_decode($worker_result, true);

    if($worker_result_data['task_id'] == $task_id){
        echo "Result: " . $worker_result_data['result'] . PHP_EOL;
        break;
    }
}

Dans le code ci-dessus, nous créons d'abord un client socket TCP pour nous connecter au nœud de calcul. La fonction fread() est utilisée ici pour obtenir les résultats de retour de la tâche de calcul depuis le serveur. Ensuite, nous envoyons task_id en paramètre à tous les nœuds informatiques et attendons que les résultats soient renvoyés. Sur la base de l'ID de tâche (task_id), nous pouvons identifier quel nœud informatique a renvoyé le résultat du calcul. Enfin, nous pouvons afficher les résultats du calcul.

Résumé

Ci-dessus sont les étapes détaillées sur la façon d'utiliser Workerman pour implémenter un système informatique distribué, y compris la création de programmes serveur, de programmes de nœuds informatiques et de programmes clients, et en fournissant des exemples de code spécifiques. Il convient de mentionner que les exemples fournis dans cet article démontrent uniquement les idées de base sur la façon d'utiliser Workerman pour implémenter des systèmes informatiques distribués. Certains problèmes subsistent dans les applications pratiques, telles que l'équilibrage de charge, les stratégies d'allocation de tâches, etc. Mais tous ces problèmes peuvent être résolus en étudiant attentivement le framework Workerman et en ajustant le code.

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!