gRPC

---

🔗 Qu’est-ce que gRPC ?

📘 Définition :

gRPC (Google Remote Procedure Call) est un framework open-source créé par Google qui permet à deux applications (ou microservices) de communiquer entre elles de manière rapide, efficace et structurée, via des appels de fonctions distantes (RPC = Remote Procedure Call).

---

🧠 En gros :

Tu écris une méthode comme GetUser(), mais elle est exécutée sur un autre serveur à distance, comme si elle était locale.

---

🔧 Techniquement :

• Utilise HTTP/2 (plus rapide que HTTP/1.1)

• Utilise Protocol Buffers (protobuf) comme format d’échange (compact et binaire)

• Multi-langages : gRPC fonctionne avec C#, Java, Go, Python, Node.js, etc.

• Très utilisé dans les microservices

---

🧩 Pourquoi utiliser gRPC (vs REST API) ?

📌	REST (API Web classique)	gRPC
🔄 Format	JSON (texte)	Protobuf (binaire)
⚡ Vitesse	Plus lent	Très rapide
📥 Poids	Messages plus lourds	Très léger
🧬 Typage	Moins strict	Fortement typé
📡 Protocol	HTTP/1.1	HTTP/2
🔁 Streaming	Compliqué	Géré nativement (bidirectionnel)

---

🚧 Exemple simple avec gRPC

1. Définir un contrat (fichier .proto)

syntax = "proto3";

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

2. gRPC génère du code (C#, Java, etc.) à partir du .proto

3. Utilisation côté C# :

🔹 Côté serveur :

public class GreeterService : Greeter.GreeterBase
{
    public override Task<HelloReply> SayHello(HelloRequest request, ServerCallContext context)
    {
        return Task.FromResult(new HelloReply
        {
            Message = $"Hello, {request.Name}"
        });
    }
}

🔹 Côté client :

var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new Greeter.GreeterClient(channel);

var reply = await client.SayHelloAsync(new HelloRequest { Name = "Alice" });
Console.WriteLine(reply.Message);

---

🧪 Scénarios d’utilisation idéaux :

• Microservices (communication interne très rapide)

• Jeux en temps réel

• IoT

• Streaming (voix, vidéo, capteurs)

• Mobile-to-backend quand la bande passante est limitée

---

---

🛠️ Étapes du projet

1. Créer la solution et les projets

2. Définir le fichier .proto

3. Implémenter le serveur gRPC

4. Implémenter le client gRPC

5. Lancer et tester

---

🔧 Prérequis

• .NET SDK 6 ou 7+

• Visual Studio 2022+ ou VS Code

---

🧪 Étape 1 : Créer la solution

Ouvre ton terminal ou PowerShell et tape :

dotnet new sln -n HelloGrpcApp
cd HelloGrpcApp

dotnet new grpc -n HelloGrpcServer
dotnet new console -n HelloGrpcClient

dotnet sln add HelloGrpcServer/HelloGrpcServer.csproj
dotnet sln add HelloGrpcClient/HelloGrpcClient.csproj

---

📁 Étape 2 : Le fichier .proto

Dans HelloGrpcServer/Protos/greet.proto (existant par défaut), mets :

syntax = "proto3";

option csharp_namespace = "HelloGrpc";

package greet;

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

---

🔧 Étape 3 : Implémenter le Serveur

Dans HelloGrpcServer/Services/GreeterService.cs :

using Grpc.Core;
using HelloGrpc;

namespace HelloGrpcServer.Services;

public class GreeterService : Greeter.GreeterBase
{
    public override Task<HelloReply> SayHello(HelloRequest request, ServerCallContext context)
    {
        var message = $"👋 Bonjour {request.Name}, bienvenue dans gRPC !";
        return Task.FromResult(new HelloReply { Message = message });
    }
}

Ce projet est déjà prêt à être lancé. Tu peux tester avec Swagger ou créer le client 👇

---

🧑‍💻 Étape 4 : Créer le Client

Ajoute le package gRPC et les fichiers .proto dans le client :

cd HelloGrpcClient
dotnet add package Grpc.Net.Client
dotnet add package Google.Protobuf
dotnet add package Grpc.Tools

Dans HelloGrpcClient.csproj, ajoute :

<ItemGroup>
  <Protobuf Include="../HelloGrpcServer/Protos/greet.proto" GrpcServices="Client" />
</ItemGroup>

Puis dans Program.cs :

using Grpc.Net.Client;
using HelloGrpc;

var channel = GrpcChannel.ForAddress("https://localhost:7116"); // vérifie le port dans le serveur
var client = new Greeter.GreeterClient(channel);

Console.Write("Entrez votre nom : ");
var name = Console.ReadLine();

var reply = await client.SayHelloAsync(new HelloRequest { Name = name });
Console.WriteLine("Réponse du serveur : " + reply.Message);

---

🚀 Étape 5 : Lancer le projet

1. Lance d'abord le serveur :

dotnet run --project HelloGrpcServer

2. Puis lance le client dans un autre terminal :

dotnet run --project HelloGrpcClient

---

Comparer gRPC à une API REST  en C# .NET 7, dans deux projets :

✨ Exemple : dire bonjour à un utilisateur (SayHello)

---

🧪 Contexte commun :

• Méthode : SayHello(string name)

• Réponse : "Hello, <name>!"

---

⚖️ COMPARAISON CÔTÉ CODE

---

1️⃣ REST API (ASP.NET Core Web API)

✅ Contrat (Pas besoin de .proto)

// Controller: HelloController.cs
[ApiController]
[Route("api/[controller]")]
public class HelloController : ControllerBase
{
    [HttpGet("{name}")]
    public IActionResult SayHello(string name)
    {
        return Ok($"Hello, {name}!");
    }
}

📡 Appel REST (ex : avec HttpClient)

var httpClient = new HttpClient();
var response = await httpClient.GetStringAsync("https://localhost:5001/api/hello/Alice");
Console.WriteLine(response);  // "Hello, Alice!"

---

2️⃣ gRPC (ASP.NET Core gRPC)

✅ Contrat via .proto

syntax = "proto3";

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

✅ Implémentation (GreeterService.cs)

public class GreeterService : Greeter.GreeterBase
{
    public override Task<HelloReply> SayHello(HelloRequest request, ServerCallContext context)
    {
        return Task.FromResult(new HelloReply
        {
            Message = $"Hello, {request.Name}!"
        });
    }
}

📡 Appel gRPC (avec Grpc.Net.Client)

var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new Greeter.GreeterClient(channel);
var reply = await client.SayHelloAsync(new HelloRequest { Name = "Alice" });
Console.WriteLine(reply.Message);  // "Hello, Alice!"

---

🧠 Résumé des différences clés

✅ Critère	🌐 REST	⚡ gRPC
Format	JSON (texte)	Protobuf (binaire)
Vitesse	Moins rapide	Très rapide
Typage	Faible (pas de contrat formel)	Fort (via .proto)
Facilité d'appel	Facile avec un navigateur	Nécessite client gRPC
Streaming	Compliqué	Natif (unidirectionnel/bidi)
HTTP	HTTP/1.1	HTTP/2
Découverte (Swagger)	Oui	Non (mais tooling proto)
Idéal pour	Frontend, navigateurs	Microservices, perf, RPC

---

🤔 Lequel choisir ?

• REST API : Parfait pour une API publique, une app web, ou pour interagir avec un navigateur.

• gRPC : Idéal pour des communications internes rapides entre services, des systèmes distribués, ou des environnements mobiles/IoT.

---