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) indépendants du langage et de la plate-forme, développés par Google. Il vous permet de définir un service à l'aide de Protocol Buffers, un ensemble d'outils et un langage de sérialisation binaires particulièrement puissants. Il vous permet ensuite de générer des bouchons de client et de serveur idiomatiques à partir de la définition de votre service dans plusieurs 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#, dont la description est identique à celle du service.

Points abordés

  • Langage du tampon de protocole.
  • Mettre en œuvre un service gRPC à l'aide de C#.
  • 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 ?

<ph type="x-smartling-placeholder"></ph> Débutant Intermédiaire Expert .

2. Télécharger et créer 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, puis extrayez-le.

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

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

Dans tous les 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. Une solution avec plusieurs projets doit s'afficher.

61da9ddc86c08019.png

Nous examinerons les projets plus en détail dans la section suivante, mais commençons par créer le projet. Accédez à Build > Build Solution ou Ctrl + Shift + B pour créer la solution. Toutes les dépendances sont alors téléchargées depuis NuGet, puis l'application est compilée.

À la fin, le message Build succeeded doit 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 par un message suivi du nom. Il existe un projet Greeter qui inclut la définition de service commune (fichier proto) sur laquelle le client et le serveur sont basés.

Projet Greeter

Il s'agit du projet commun partagé entre le client et le serveur. Il possède un greeter.proto, qui correspond à la définition de service gRPC que le client et le serveur utilisent. La définition de service définit un service gRPC appelé GreetingService et dispose d'une méthode greeting qui utilise 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) dans laquelle le client envoie une seule requête et obtient une seule réponse du serveur. Vous pouvez explorer le reste du contenu de greeter.proto.. Ce projet contient également un script appelé generate_protos.bat qui permet de générer des bouchons de client et de serveur à partir du fichier proto. Le projet contient déjà des bouchons 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 générer à nouveau les bouchons.

Serveur d'accueil

Il s'agit du projet du serveur gRPC. Program.cs est le principal point d'entrée où l'implémentation du port et du serveur est configurée. 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 });
}

Greeter Client

Il s'agit du côté client du service gRPC. Il a également Program.cs comme point d'entrée. Il crée un canal pour communiquer avec le serveur, puis crée un client avec ce canal à partir du bouchon généré. Il crée ensuite une requête et l'envoie au serveur à l'aide du bouchon 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 et exécutez l'exécutable. Vous devriez voir le serveur à l'écoute.

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

Ensuite, exécutez le client Greeter. Dans une invite de commande distincte, accédez au dossier bin > Debug de Greeter Server et exécutez l'exécutable. Le client doit envoyer la requête et recevoir la 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. Ajoutez 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 générer à nouveau les bouchons de client et de serveur. Dans une invite de commande, exécutez generate_protos.bat. Une fois les bouchons 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 le code serveur afin de tirer parti 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 doit maintenant recevoir un message d'adieu.

> 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

Il existe également des projets ChatServer et ChatWindowsClient dans la solution. 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. Elle définit un ChatService avec une méthode chat.

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

Il est important de noter que les messages de chat entrants et sortants sont signalés à l'aide du mot clé stream. Cela transforme la connexion en un flux bidirectionnel dans lequel le client et le serveur peuvent s'envoyer des messages à tout moment. la solution idéale pour une application de chat.

Vous pouvez explorer l'exemple plus en détail, le créer et l'exécuter pour voir comment cela fonctionne sous la forme d'un exercice.

7. Félicitations !

Points abordés

  • Langage de tampon de protocole.
  • Mettre en œuvre un service gRPC à l'aide de C#.
  • Implémenter un client gRPC à l'aide de C#
  • Mettre à jour un service gRPC

Étapes suivantes