Comment utiliser gRPC en PHP pour gérer les API à haute concurrence

Dans les applications réseau modernes, la gestion d'une concurrence élevée est un problème très important. Dans ce processus, l'utilisation de gRPC peut être un excellent moyen d'obtenir une communication client-serveur efficace via des appels de procédure à distance (RPC). Dans les applications PHP, nous pouvons utiliser gRPC pour gérer un nombre élevé de requêtes API simultanées. Cet article explique comment utiliser gRPC pour gérer les API à haute concurrence en PHP.

Qu'est-ce que gRPC ?

gRPC est un framework RPC hautes performances développé par Google. Il prend en charge plusieurs langues et peut être utilisé dans des applications basées sur plusieurs plates-formes. gRPC est basé sur le protocole HTTP/2 et peut transmettre de grandes quantités de données de manière rapide et fiable sur le réseau. Il prend également en charge le streaming bidirectionnel, permettant un véritable streaming entre le serveur et le client.

Utiliser gRPC en PHP

Pour utiliser gRPC en PHP, nous devons installer l'extension gRPC. Pour le processus d'installation, veuillez vous référer à la documentation gRPC (https://grpc.io/docs/linguals/php/quickstart/).

Une fois l'extension gRPC installée, nous pouvons commencer à écrire le service gRPC. Dans gRPC, les services sont définis via des fichiers prototypes. Le fichier proto décrit la structure des données et l'interface du service, et peut utiliser les outils fournis par gRPC pour générer le code correspondant à utiliser par PHP.

Dans cet article, nous utiliserons un exemple simple pour montrer comment utiliser gRPC en PHP pour gérer un nombre élevé de requêtes API simultanées. Dans cet exemple, nous allons implémenter une API pour créer et obtenir des utilisateurs. Nous devons définir un fichier proto pour décrire ce service :

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;
}

Dans ce fichier proto, nous définissons un service UserService, qui a deux méthodes getUser et createUser. La méthode getUser nécessite un objet GetUserRequest comme paramètre et renvoie un objet GetUserResponse ; la méthode createUser nécessite un objet CreateUserRequest comme paramètre et renvoie un objet CreateUserResponse. Nous pouvons utiliser les outils fournis par gRPC pour compiler ce fichier proto en code PHP :

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

Cette commande compile le fichier proto en code PHP et place le code généré dans le répertoire gen. Nous pouvons utiliser ces codes générés dans le code PHP pour implémenter les services 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');

Dans ce code PHP, nous implémentons une classe UserServiceImpl, qui hérite de la classe userUserServiceServer. Cette classe implémente les méthodes getUser et createUser et gère les requêtes. Pour chaque requête, gRPC crée une nouvelle instance UserServiceImpl et lui transmet le paramètre de contexte lors de l'appel de la méthode. Afin de démarrer le service gRPC, nous devons créer un nouvel objet Serveur, ajouter le service au serveur et lier le serveur à l'adresse et au port.

Utiliser gRPC avec un client PHP

Utiliser gRPC avec un client PHP est également simple. Nous pouvons utiliser le générateur de code fourni par gRPC pour générer du code PHP sur le client afin d'appeler les services gRPC. L'entrée requise par le générateur de code est un fichier .proto et l'indicateur --php_out.

Dans notre exemple, nous avons écrit le fichier .proto. Nous pouvons le générer sous forme de code PHP en utilisant la commande suivante :

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

Cette commande générera un répertoire utilisateur dans le répertoire gen qui contient les fichiers PHP nécessaires pour communiquer avec le service gRPC.

Importez ces fichiers dans notre client PHP et nous pouvons les utiliser pour appeler le service :

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

Dans ce code client PHP, nous créons un nouvel objet UserServiceClient et le lions à l'adresse et au port du serveur. Nous créons également un objet GetUserRequest, définissons l'ID utilisateur sur 123 et appelons la méthode getUser à l'aide de $client. Nous attendons la réponse et utilisons l'objet GetUserResponse renvoyé pour afficher le nom et l'adresse e-mail de l'utilisateur.

Résumé

Dans les applications PHP, les requêtes API concurrentes élevées peuvent être bien gérées à l'aide de gRPC. Nous pouvons utiliser les outils fournis par gRPC pour générer du code de service et créer des services et des clients en code PHP. Lorsque nous sommes confrontés à des applications réseau à forte charge, gRPC peut être un bon choix pour obtenir une communication rapide et fiable en utilisant un RPC efficace basé sur le protocole HTTP/2.

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!