gRPC

🚀 gRPC: The Super-Fast Messenger

The Story of Two Friends Who Needed to Talk REALLY Fast

Imagine you have two best friends who live in different houses. They need to send messages to each other ALL THE TIME. But regular letters are too slow! They need something super fast and super organized.

That’s exactly what gRPC does for computers!

🎯 What is gRPC?

gRPC is like having a super-powered walkie-talkie between computers.

Regular API (REST):
📝 Write letter → 📮 Mail it → ⏰ Wait → 📬 Get reply

gRPC:
📞 Call directly → 💬 Talk instantly → ✅ Done!

gRPC stands for “Google Remote Procedure Call”. Google made it to help their computers talk to each other really, really fast!

Why is gRPC Special?

📦 Protocol Buffers: The Secret Language

Imagine you and your friend invented a secret code where:

• Instead of writing “Hello my name is John” (21 letters)
• You write “H-J” (2 letters!)

That’s what Protocol Buffers (or “protobuf”) does!

How It Works

You write a “recipe” that tells computers how to pack messages:

// This is a .proto file
syntax = "proto3";

message Person {
  string name = 1;
  int32 age = 2;
  string email = 3;
}

What does this mean?

• message Person = “I’m describing a person”
• string name = 1 = “First piece: their name”
• int32 age = 2 = “Second piece: their age (a number)”
• email = 3 = “Third piece: their email”

The Magic Transformation

BEFORE (JSON - 50 bytes):
{"name":"Emma","age":10,"email":"emma@mail.com"}

AFTER (Protobuf - 15 bytes):
[Binary data - tiny!]

70% smaller! That means messages fly through the internet 3x faster!

🛠️ gRPC Services: The Helper Robots

A gRPC Service is like a robot helper that knows how to do specific tasks.

Creating a Service

service Greeter {
  // This robot knows how to say hello!
  rpc SayHello (HelloRequest)
      returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

In plain English:

• “I have a helper called Greeter”
• “It can SayHello”
• “You tell it your name”
• “It sends back a greeting message”

Building the Service in C#

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

What’s happening?

1. Someone calls SayHello with their name
2. The service creates a reply: “Hello, [name]!”
3. It sends the reply back instantly!

📱 gRPC Clients: The Message Senders

A client is the one who asks for help from the service.

Think of it like this:

• Service = Pizza shop 🍕
• Client = You ordering pizza 📞

Creating a Client in C#

// Create a connection to the service
var channel = GrpcChannel.ForAddress(
    "https://localhost:5001"
);

// Create a client
var client = new Greeter.GreeterClient(channel);

// Ask the service to say hello
var reply = await client.SayHelloAsync(
    new HelloRequest { Name = "Emma" }
);

Console.WriteLine(reply.Message);
// Output: "Hello, Emma!"

The Flow

graph TD
    A["👧 Client: Emma"] -->|"SayHello Emma"| B["🤖 Greeter Service"]
    B -->|"Hello Emma!"| A

🌊 gRPC Streaming: The Flowing River

Sometimes you don’t want just ONE message. You want messages to keep flowing like a river!

4 Types of Streaming

graph TD
    A["Streaming Types"] --> B["Unary"]
    A --> C["Server Stream"]
    A --> D["Client Stream"]
    A --> E["Bidirectional"]

    B -->|"1 request → 1 response"| F["🎯 Simple"]
    C -->|"1 request → many responses"| G["📺 Like Netflix"]
    D -->|"Many requests → 1 response"| H["📤 Upload"]
    E -->|"Many ↔ Many"| I["💬 Chat"]

1. Unary (One-to-One)

rpc GetUser (UserRequest) returns (User);

You ask once, get one answer.

2. Server Streaming (One-to-Many)

rpc GetUpdates (Request)
    returns (stream Update);

You ask once, get many answers flowing back!

Example in C#:

// Server sends many updates
public override async Task GetUpdates(
    Request request,
    IServerStreamWriter<Update> responseStream,
    ServerCallContext context)
{
    for (int i = 0; i < 10; i++)
    {
        await responseStream.WriteAsync(
            new Update { Message = quot;Update {i}" }
        );
        await Task.Delay(1000); // Wait 1 second
    }
}

3. Client Streaming (Many-to-One)

rpc UploadPhotos (stream Photo)
    returns (UploadResult);

You send many photos, get one “Upload complete!”

4. Bidirectional (Chat Mode!)

rpc Chat (stream ChatMessage)
    returns (stream ChatMessage);

Both sides can send and receive anytime!

// Real-time chat example
public override async Task Chat(
    IAsyncStreamReader<ChatMessage> requestStream,
    IServerStreamWriter<ChatMessage> responseStream,
    ServerCallContext context)
{
    await foreach (var message in
        requestStream.ReadAllAsync())
    {
        // Echo back the message
        await responseStream.WriteAsync(
            new ChatMessage
            {
                Text = quot;You said: {message.Text}"
            }
        );
    }
}

🔐 gRPC Authentication: The Security Guard

Imagine a secret clubhouse. You need a special badge to get in!

Ways to Prove Who You Are

graph TD
    A["Authentication Methods"] --> B["🎫 Token/JWT"]
    A --> C["📜 Certificate"]
    A --> D["🔑 API Key"]

Using JWT Tokens

Step 1: Client sends token with request

// Add your "badge" to every message
var headers = new Metadata
{
    { "Authorization", "Bearer YOUR_TOKEN_HERE" }
};

var reply = await client.SayHelloAsync(
    request,
    headers
);

Step 2: Server checks the token

public override Task<HelloReply> SayHello(
    HelloRequest request,
    ServerCallContext context)
{
    // Get the token from headers
    var token = context.RequestHeaders
        .GetValue("authorization");

    // Check if valid (simplified)
    if (token == null || !IsValidToken(token))
    {
        throw new RpcException(
            new Status(StatusCode.Unauthenticated,
            "Bad badge! Go away!")
        );
    }

    return Task.FromResult(new HelloReply
    {
        Message = "Welcome, verified friend!"
    });
}

Using SSL/TLS (The Secure Tunnel)

// Server setup with certificate
builder.WebHost.ConfigureKestrel(options =>
{
    options.Listen(IPAddress.Any, 5001,
        listenOptions =>
        {
            listenOptions.UseHttps("cert.pfx", "password");
        });
});

⚠️ gRPC Error Handling: When Things Go Wrong

Even best friends sometimes misunderstand each other! gRPC has special error codes to explain what went wrong.

Common Error Codes

Throwing Errors (Server Side)

public override Task<User> GetUser(
    UserRequest request,
    ServerCallContext context)
{
    if (string.IsNullOrEmpty(request.UserId))
    {
        throw new RpcException(new Status(
            StatusCode.InvalidArgument,
            "You forgot to tell me the user ID!"
        ));
    }

    var user = FindUser(request.UserId);

    if (user == null)
    {
        throw new RpcException(new Status(
            StatusCode.NotFound,
            "I looked everywhere but couldn't find them!"
        ));
    }

    return Task.FromResult(user);
}

Catching Errors (Client Side)

try
{
    var user = await client.GetUserAsync(
        new UserRequest { UserId = "123" }
    );
}
catch (RpcException ex)
{
    switch (ex.StatusCode)
    {
        case StatusCode.NotFound:
            Console.WriteLine("User doesn't exist!");
            break;
        case StatusCode.Unavailable:
            Console.WriteLine("Server is down. Try later!");
            break;
        default:
            Console.WriteLine(quot;Oops: {ex.Message}");
            break;
    }
}

The Complete Error Flow

graph TD
    A["Client Makes Request"] --> B{Server Checks}
    B -->|Valid| C["Process & Return ✅"]
    B -->|Invalid| D["Throw RpcException"]
    D --> E["Client Catches Error"]
    E --> F["Show Friendly Message"]

🎮 Putting It All Together

Here’s a complete mini-example of a Score Service for a game:

The Proto File:

service ScoreService {
  rpc GetScore (PlayerRequest)
      returns (ScoreReply);

  rpc WatchScores (PlayerRequest)
      returns (stream ScoreUpdate);
}

The Service:

public class ScoreService : ScoreService.ScoreServiceBase
{
    public override async Task WatchScores(
        PlayerRequest request,
        IServerStreamWriter<ScoreUpdate> stream,
        ServerCallContext context)
    {
        // Send score updates every second
        while (!context.CancellationToken
            .IsCancellationRequested)
        {
            await stream.WriteAsync(
                new ScoreUpdate { Score = GetCurrentScore() }
            );
            await Task.Delay(1000);
        }
    }
}

🌟 Quick Summary

🎉 You Did It!

You now understand gRPC! It’s just like learning a new way for computers to be best friends - they talk faster, understand each other better, and always know when something goes wrong.

Remember: gRPC = Fast + Organized + Reliable communication between computers!