Cara menggunakan gRPC dalam PHP untuk mengendalikan API konkurensi tinggi

Dalam aplikasi rangkaian moden, pengendalian konkurensi tinggi adalah isu yang sangat penting. Dalam proses ini, menggunakan gRPC boleh menjadi cara terbaik untuk mencapai komunikasi pelanggan-pelayan yang cekap melalui panggilan prosedur jauh (RPC). Dalam aplikasi PHP, kami boleh menggunakan gRPC untuk mengendalikan permintaan API serentak yang tinggi. Artikel ini akan memperkenalkan cara menggunakan gRPC untuk mengendalikan API konkurensi tinggi dalam PHP.

Apakah itu gRPC?

gRPC ialah rangka kerja RPC berprestasi tinggi yang dibangunkan oleh Google. Ia menyokong berbilang bahasa dan boleh digunakan dalam aplikasi berdasarkan berbilang platform. gRPC adalah berdasarkan protokol HTTP/2 dan boleh menghantar sejumlah besar data dengan cepat dan boleh dipercayai melalui rangkaian. Ia juga menyokong penstriman dua arah, membolehkan penstriman benar antara pelayan dan pelanggan.

Menggunakan gRPC dalam PHP

Untuk menggunakan gRPC dalam PHP, kami perlu memasang sambungan gRPC. Untuk proses pemasangan, sila rujuk dokumentasi gRPC (https://grpc.io/docs/languages/php/quickstart/).

Setelah sambungan gRPC dipasang, kami boleh mula menulis perkhidmatan gRPC. Dalam gRPC, perkhidmatan ditakrifkan melalui fail proto. Fail proto menerangkan struktur data dan antara muka perkhidmatan, dan boleh menggunakan alatan yang disediakan oleh gRPC untuk menjana kod yang sepadan untuk digunakan oleh PHP.

Dalam artikel ini, kami akan menggunakan contoh mudah untuk menunjukkan cara menggunakan gRPC dalam PHP untuk mengendalikan permintaan API serentak yang tinggi. Dalam contoh ini, kami akan melaksanakan API untuk mencipta dan mendapatkan pengguna. Kami perlu mentakrifkan fail proto untuk menerangkan perkhidmatan ini:

syntax = "proto3";
package user;

service UserService {
    rpc getUser(GetUserRequest) returns (GetUserResponse);
    rpc createUser(CreateUserRequest) returns (CreateUserResponse);
}

message GetUserRequest {
    string userId = 1;
}

message GetUserResponse {
    string name = 1;
    string email = 2;
}

message CreateUserRequest {
    string name = 1;
    string email = 2;
}

message CreateUserResponse {
    string userId = 1;
}

Dalam fail proto ini, kami mentakrifkan perkhidmatan UserService, yang mempunyai dua kaedah getUser dan createUser. Kaedah getUser memerlukan objek GetUserRequest sebagai parameter dan mengembalikan objek GetUserResponse kaedah createUser memerlukan objek CreateUserRequest sebagai parameter dan mengembalikan objek CreateUserResponse. Kita boleh menggunakan alatan yang disediakan oleh gRPC untuk menyusun fail proto ini ke dalam kod PHP:

protoc --php_out=./gen --grpc_out=./gen --plugin=protoc-gen-grpc=/usr/local/bin/grpc_php_plugin user.proto

Perintah ini menyusun fail proto ke dalam kod PHP dan meletakkan kod yang dijana dalam direktori gen. Kami boleh menggunakan kod yang dijana ini dalam kod PHP untuk melaksanakan perkhidmatan gRPC:

require_once 'vendor/autoload.php';

class UserServiceImpl extends userUserServiceServer {
    public function getUser(userGetUserRequest $request, $context) {
        // ...
    }

    public function createUser(userCreateUserRequest $request, $context) {
        // ...
    }
}

$server = new GrpcServer();
$server->addService(userUserService::class, new UserServiceImpl());
$server->listen('127.0.0.1:50051');

Dalam kod PHP ini, kami melaksanakan kelas UserServiceImpl, yang mewarisi daripada kelas userUserServiceServer. Kelas ini melaksanakan kaedah getUser dan createUser serta mengendalikan permintaan. Untuk setiap permintaan, gRPC mencipta contoh UserServiceImpl baharu dan memberikannya parameter konteks apabila memanggil kaedah tersebut. Untuk memulakan perkhidmatan gRPC, kita perlu mencipta objek Pelayan baharu, menambah perkhidmatan pada pelayan dan mengikat pelayan ke alamat dan port.

Menggunakan gRPC dengan klien PHP

Menggunakan gRPC dengan klien PHP juga mudah. Kami boleh menggunakan penjana kod yang disediakan oleh gRPC untuk menjana kod PHP pada klien untuk memanggil perkhidmatan gRPC. Input yang diperlukan oleh penjana kod ialah fail .proto dan bendera --php_out.

Dalam contoh kami, kami telah menulis fail .proto. Kita boleh menjananya sebagai kod PHP menggunakan arahan berikut:

protoc --php_out=./gen --grpc_out=./gen --plugin=protoc-gen-grpc=/usr/local/bin/grpc_php_plugin user.proto

Perintah ini akan menjana direktori pengguna dalam direktori gen yang mengandungi fail PHP yang diperlukan untuk berkomunikasi dengan perkhidmatan gRPC.

Import fail ini ke dalam klien PHP kami dan kami boleh menggunakannya untuk memanggil perkhidmatan:

require_once 'vendor/autoload.php';

$client = new userUserServiceClient('127.0.0.1:50051', [
    'credentials' => GrpcChannelCredentials::createInsecure(),
]);

$getuser_request = new userGetUserRequest();
$getuser_request->setUserId('123');

$user = $client->getUser($getuser_request)->wait();
echo $user->getName() . "
";
echo $user->getEmail() . "
";

Dalam kod klien PHP ini, kami mencipta objek UserServiceClient baharu dan mengikatnya pada alamat pelayan dan pelabuhan. Kami juga mencipta objek GetUserRequest, menetapkan ID pengguna kepada 123 dan memanggil kaedah getUser menggunakan $client. Kami menunggu respons dan menggunakan objek GetUserResponse yang dikembalikan untuk mengeluarkan nama dan alamat e-mel pengguna.

Ringkasan

Dalam aplikasi PHP, permintaan API serentak yang tinggi boleh dikendalikan dengan baik menggunakan gRPC. Kami boleh menggunakan alatan yang disediakan oleh gRPC untuk menjana kod perkhidmatan dan mencipta perkhidmatan serta pelanggan dalam kod PHP. Apabila kami menghadapi aplikasi rangkaian beban tinggi, gRPC boleh menjadi pilihan yang baik untuk mencapai komunikasi yang pantas dan boleh dipercayai dengan menggunakan RPC yang cekap berdasarkan protokol HTTP/2.

Atas ialah kandungan terperinci Cara menggunakan gRPC dalam PHP untuk mengendalikan API konkurensi tinggi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!