Créer un service gRPC avec C#

1. Présentation

gRPC est un framework et un ensemble d'outils d'appel de procédure à distance (RPC, Remote Procedure Call) indépendants du langage et de la plate-forme, développés chez Google. Il vous permet de définir un service à l'aide de Protocol Buffers, un langage et un ensemble d'outils de sérialisation binaire particulièrement puissants. Il vous permet ensuite de générer des stubs client et serveur idiomatiques à partir de la définition de votre service dans différents langages.

Dans cet atelier de programmation, vous allez apprendre à créer un service C# qui expose une API à l'aide du framework gRPC. Vous interagissez avec ce service à l'aide d'un client de console écrit en C# qui utilise la même description de service que le service.

Points abordés

  • Langage Protocol Buffers.
  • Comment implémenter un service gRPC à l'aide de C#.
  • Découvrez comment implémenter un client gRPC à l'aide de C#.
  • Mettre à jour un service gRPC

Prérequis

Comment allez-vous utiliser ce tutoriel ?

Je vais le lire uniquement Je vais le lire et effectuer les exercices

Quel est votre niveau d'expérience avec Google Cloud Platform ?

Débutant Intermédiaire Expert

2. Télécharger et compiler des exemples gRPC C#

Télécharger des exemples

Téléchargez le dépôt d'exemple gRPC C# sous forme de fichier ZIP et extrayez-le.

Vous pouvez également cloner son dépôt git.

git clone https://github.com/meteatamel/grpc-samples-dotnet.git

Dans les deux cas, vous devriez avoir un dossier grpc-samples-dotnet avec le contenu suivant :

d056832ff4ce0c8f.png

Créer la solution

Le dossier de l'exemple d'application contient GrpcSamples.sln, une solution Visual Studio. Double-cliquez pour ouvrir la solution dans Visual Studio. Vous devriez voir une solution avec un certain nombre de projets.

61da9ddc86c08019.png

Nous examinerons les projets plus en détail dans la section suivante, mais pour l'instant, créons simplement le projet. Accédez à Build > Build Solution ou Ctrl + Shift + B pour créer la solution. Toutes les dépendances seront téléchargées à partir de NuGet, puis l'application sera compilée.

À la fin, un message Build succeeded devrait s'afficher dans la sortie de la console Visual Studio.

3. Explorer l'exemple Greeter

Greeter est un exemple gRPC simple dans lequel un client envoie une requête avec un nom et le serveur répond avec un message suivi du nom. Il existe un projet Greeter qui inclut la définition de service commune (fichier proto) sur laquelle reposent le client et le serveur.

Projet Greeter

Il s'agit du projet commun partagé entre le client et le serveur. Il comporte un greeter.proto qui correspond à la définition du service gRPC utilisé par le client et le serveur. La définition du service définit un service gRPC appelé GreetingService. Il comporte une méthode greeting qui prend HelloRequest comme entrée et HelloResponse comme sortie.

service GreetingService {
    rpc greeting(HelloRequest) returns (HelloResponse);
}

Il s'agit d'une méthode unaire (c'est-à-dire sans flux continu) dans laquelle le client envoie une seule requête et reçoit une seule réponse du serveur. Vous pouvez explorer le reste du contenu de greeter.proto.. Ce projet comporte également un script appelé generate_protos.bat qui peut être utilisé pour générer des stubs de client et de serveur à partir du fichier proto. Le projet contient déjà des stubs de client et de serveur générés. Vous n'avez donc pas besoin de les générer vous-même. Toutefois, si vous modifiez le fichier de définition de service, vous devrez exécuter ce script pour régénérer les stubs.

Serveur Greeter

Il s'agit du projet pour le serveur gRPC. Program.cs est le point d'entrée principal où le port et l'implémentation du serveur sont configurés. La classe importante est GreeterServiceImpl.cs. Il dispose d'une méthode greeting dans laquelle la fonctionnalité réelle est implémentée.

public override Task<HelloResponse> greeting(HelloRequest request,
       ServerCallContext context)
{
    return Task.FromResult(new HelloResponse { 
          Greeting = "Hello " + request.Name });
}

Client Greeter

Il s'agit du côté client du service gRPC. Il comporte également Program.cs comme point d'entrée. Il crée un canal pour communiquer avec le serveur, puis crée un client avec le canal à partir du stub généré. Il crée ensuite une requête et l'envoie au serveur à l'aide du stub client.

4. Exécuter l'exemple Greeter

Commencez par démarrer le serveur Greeter. Ouvrez une invite de commande, accédez au dossier bin > Debug de Greeter Server, puis exécutez le fichier exécutable. Vous devriez voir le serveur écouter.

> C:\grpc-samples-dotnet\GreeterServer\bin\Debug>GreeterServer.exe
GreeterServer listening on port 50051
Press any key to stop the server...

Exécutez ensuite le client Greeter. Dans une invite de commande distincte, accédez au dossier bin > Debug de Greeter Server et exécutez le fichier exécutable. Vous devriez voir le client envoyer la requête et recevoir une réponse du serveur.

> C:\grpc-samples-dotnet\GreeterClient\bin\Debug>GreeterClient.exe
GreeterClient sending request
GreeterClient received response: Hello Mete - on C#
Press any key to exit...

5. Mettre à jour l'exemple Greeter

Voyons à quoi ressemble la mise à jour de notre service. Ajoute une nouvelle méthode à notre service gRPC appelée "goodbye" qui renvoie "goodbye" au lieu de "hello" au client.

La première étape consiste à mettre à jour le fichier de définition de service greeter.proto..

service GreetingService {
    rpc greeting(HelloRequest) returns (HelloResponse);
    
    rpc goodbye(HelloRequest) returns (HelloResponse);
}

Vous devez ensuite régénérer les bouchons client et serveur. Dans une invite de commande, exécutez generate_protos.bat. Une fois les stubs générés, vous devrez peut-être actualiser vos projets Visual Studio pour obtenir le code mis à jour.

Enfin, mettez à jour le code client et serveur pour profiter de la nouvelle méthode. Dans le service, mettez à jour GreeterServiceImpl.cs et ajoutez une méthode goodbye.

public override Task<HelloResponse> goodbye(HelloRequest request,
       ServerCallContext context)
{
    return Task.FromResult(new HelloResponse { 
          Greeting = "Goodbye " + request.Name });
}

Dans le client, appelez la méthode goodbye dans Program.cs..

response = client.goodbye(request);
Console.WriteLine("GreeterClient received response: " 
                       + response.Greeting);

Recompilez le projet, puis exécutez à nouveau le serveur et le client. Le client devrait maintenant recevoir un message d'au revoir.

> C:\grpc-samples-dotnet\GreeterClient\bin\Debug>GreeterClient.exe
GreeterClient sending request
GreeterClient received response: Hello Mete - on C#
GreeterClient received response: Goodbye Mete - on C#
Press any key to exit...

6. Explorer l'exemple Chat

La solution contient également des projets ChatServer et ChatWindowsClient. Comme son nom l'indique, il s'agit d'une paire client-serveur pour une application de chat simple. Le projet Chat contient le fichier de définition de service appelé chat.proto. Il définit un ChatService avec une méthode chat.

service ChatService {
 rpc chat(stream ChatMessage) returns (stream ChatMessageFromServer);
}

L'important ici est que les messages de chat entrants et sortants soient marqués avec le mot clé stream. Cela transforme essentiellement la connexion en flux bidirectionnel où le client et le serveur peuvent s'envoyer des messages à tout moment. C'est la solution idéale pour une application de chat.

Vous pouvez explorer l'exemple plus en détail, le compiler et l'exécuter pour voir comment il fonctionne.

7. Félicitations !

Points abordés

  • Langage Protocol Buffer.
  • Comment implémenter un service gRPC à l'aide de C#.
  • Découvrez comment implémenter un client gRPC à l'aide de C#.
  • Mettre à jour un service gRPC

Étapes suivantes