Kaedah pelaksanaan kluster pelayan dalam dokumentasi Workerman

Workerman ialah rangka kerja Soket PHP berprestasi tinggi yang membolehkan PHP mengendalikan komunikasi rangkaian tak segerak dengan lebih cekap. Dalam dokumentasi Workerman, terdapat arahan terperinci dan contoh kod tentang cara melaksanakan kluster pelayan.

Untuk melaksanakan kluster pelayan, kita perlu menjelaskan konsep kluster pelayan terlebih dahulu. Kelompok pelayan menghubungkan berbilang pelayan ke rangkaian untuk meningkatkan prestasi sistem, kebolehpercayaan dan kebolehskalaan dengan berkongsi beban dan sumber. Dalam Workerman, pengelompokan pelayan boleh dilaksanakan dalam dua cara: menggunakan pengimbang beban pusat dan menggunakan memori kongsi teragih.

1. Gunakan pengimbang beban pusat (Load Balancer)
   Pengimbang beban pusat ialah salah satu komponen utama dalam sistem teragih. Ia menerima permintaan daripada pelanggan dan mengedarkannya kepada pelbagai pelayan dalam kluster. Dalam Workerman, fungsi ini boleh dicapai dengan mencipta skrip PHP berasingan yang bertindak sebagai pengimbang beban pusat.

Pertama, kita perlu memasang Workerman. Anda boleh memasangnya melalui Komposer, atau memuat turun kod sumber terus dan memperkenalkan fail Autoloader.php. Seterusnya, cipta skrip PHP bernama balancer.php. Dalam skrip, kita perlu memperkenalkan fail Autoloader Workerman terlebih dahulu dan memuatkan perpustakaan kelas yang berkaitan.

<?php
require_once '/path/to/your/workerman/Autoloader.php';
use WorkermanWorker;
use WorkermanProtocolsHttp;

Seterusnya, buat contoh Pekerja untuk mendengar permintaan pelanggan dan mengedarkan permintaan kepada pelayan dalam kelompok.

$balancer = new Worker('tcp://0.0.0.0:8080');
$balancer->name = 'LoadBalancer';
$balancer->count = 4;

$balancer->onConnect = function($connection) {
    // 连接到达时，选择一个服务器进行负载均衡
    $servers = array('tcp://server1.com:8888', 'tcp://server2.com:8888', 'tcp://server3.com:8888');
    $connection->backendConnection = new Connection($servers[array_rand($servers)]);
};

$balancer->onMessage = function($connection, $data) {
    // 接收到消息时，将消息发送给后端服务器
    $connection->backendConnection->send($data);
};

$balancer->onClose = function($connection) {
    // 连接关闭时，关闭后端服务器的连接
    $connection->backendConnection->close();
};

Kod di atas mencipta contoh Pekerja bernama LoadBalancer, mendengar pada port 8080. Apabila setiap sambungan tiba, sambungan diedarkan kepada pelayan bahagian belakang dengan memilih pelayan secara rawak. Apabila mesej diterima, mesej dihantar ke pelayan bahagian belakang. Apabila sambungan ditutup, tutup sambungan ke pelayan bahagian belakang.

Akhir sekali, jalankan skrip balancer.php dan laksanakan arahan berikut dalam terminal:

php balancer.php start

Selepas memulakan pengimbang beban, anda boleh mengedarkan permintaan pelanggan kepada pelbagai pelayan dalam kelompok.

2. Menggunakan Memori Dikongsi Teragih

Memori kongsi teragih ialah teknologi yang menyimpan data yang dikongsi antara berbilang pelayan. Dalam Workerman, anda boleh menggunakan Redis sebagai memori kongsi yang diedarkan. Redis ialah pangkalan data dalam memori sumber terbuka yang menyokong storan berterusan dan menyediakan struktur data yang kaya dan arahan operasi.

Untuk menggunakan memori kongsi yang diedarkan, anda perlu memasang dan mengkonfigurasi pelayan Redis terlebih dahulu. Kemudian, dalam skrip Workerman, anda boleh menggunakan sambungan Redis untuk berkongsi data.

<?php
require_once '/path/to/your/workerman/Autoloader.php';
use WorkermanWorker;
use WorkermanProtocolsHttp;
use WorkermanConnectionAsyncTcpConnection;

$worker = new Worker('tcp://0.0.0.0:8888');
$worker->name = 'Server';
$worker->onWorkerStart = function($worker) {
    // 连接Redis服务器
    $redis_connection = new AsyncTcpConnection('tcp://redis.server:6379');
    $redis_connection->connect();
    
    // 将服务器的信息保存到Redis
    $worker->addListener = function($connection) use($redis_connection) {
        $redis_connection->lPush('servers', $connection->getRemoteAddress());
    };
    
    // 从Redis获取服务器列表，用于负载均衡
    $worker->onMessage = function($connection, $data) use($redis_connection) {
        $redis_connection->lRange('servers', 0, -1, function($result) use($connection, $data) {
            // 根据负载均衡策略选择一个服务器
            $server = $result[array_rand($result)];
            
            // 将消息发送给选定的服务器
            $backend_connection = new AsyncTcpConnection('tcp://' . $server);
            $backend_connection->send($data);
            
            // 接收后端服务器的响应，并发送给客户端
            $backend_connection->onMessage = function($connection, $backend_data) use($connection) {
                $connection->send($backend_data);
            };
            
            // 关闭后端服务器的连接
            $backend_connection->onClose = function($connection) {
                $connection->close();
            };
        });
    };
    
    // 在服务器关闭时，从Redis中移除服务器的信息
    $worker->onClose = function($connection) use($redis_connection) {
        $remote_address = $connection->getRemoteAddress();
        $redis_connection->lRem('servers', $remote_address, 1);
    };
};

Kod di atas mencipta contoh Pekerja bernama Pelayan dan mendengar port 8888. Dalam fungsi panggil balik onWorkerStart bagi contoh Worker, mula-mula sambung ke pelayan Redis, dan kemudian setiap kali permintaan pelanggan didengar, senarai pelayan diperoleh melalui sambungan Redis, pelayan dipilih mengikut dasar pengimbangan beban dan permintaan dimajukan kepada pelayan. Selepas menerima respons daripada pelayan bahagian belakang, kembalikan respons kepada klien. Apabila pelayan ditutup, alih keluar maklumat pelayan daripada Redis.

Akhir sekali, jalankan skrip server.php dan laksanakan arahan berikut dalam terminal:

php server.php start

Selepas memulakan pelayan, anda boleh menyambung ke pelayan melalui klien dan mencapai pengimbangan beban.

Melalui dua kaedah di atas, kita boleh menggunakan rangka kerja Workerman untuk melaksanakan kluster pelayan. Sama ada menggunakan pengimbang beban pusat atau memori kongsi yang diedarkan, prestasi dan kebolehpercayaan sistem boleh dipertingkatkan untuk memenuhi keperluan aplikasi berskala besar. Sudah tentu, dalam aplikasi sebenar, kami boleh mengoptimumkan dan mengembangkan lagi pelaksanaan kluster pelayan berdasarkan senario dan keperluan tertentu.

Atas ialah kandungan terperinci Kaedah pelaksanaan kluster pelayan dalam dokumentasi Workerman. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!