gRPC 정리 - HTTP/2 기반 고성능 RPC 이해하기

sequenceDiagram
    participant Client
    participant Stub
    participant Server
    participant Handler
 
    Client->>Stub: getProduct() 호출
    Stub->>Stub: 메시지 직렬화
    Stub->>Server: HTTP/2 POST
    Server->>Handler: 라우팅
    Handler->>Handler: 역직렬화 + 비즈니스 로직
    Handler->>Server: 응답 생성
    Server->>Stub: HTTP/2 응답
    Stub->>Stub: 역직렬화
    Stub->>Client: 결과 반환

syntax = "proto3";
 
option csharp_namespace = "ChatService";
 
service Chat {
    rpc SystemChat (SystemChatRequest) returns (SystemChatResponse);
}

// 서버 스켈레톤
public abstract partial class ChatBase
{
    public virtual Task<SystemChatResponse> SystemChat(
        SystemChatRequest request, 
        ServerCallContext context)
    {
        throw new RpcException(new Status(StatusCode.Unimplemented, ""));
    }
}
 
// 클라이언트 스텁
public partial class ChatClient : ClientBase<ChatClient>
{
    public virtual AsyncUnaryCall<SystemChatResponse> SystemChatAsync(
        SystemChatRequest request,
        Metadata headers = null,
        DateTime? deadline = null,
        CancellationToken cancellationToken = default)
    {
        // ...
    }
}

public class ChatManager(Chat.ChatClient client)
{
    private async Task SendSystemChat()
    {
        await client.SystemChatAsync(new SystemChatRequest { ... });
    }
}

rpc PlaceOrder (OrderRequest) returns (OrderResponse);

// 서버
public override async Task<OrderResponse> PlaceOrder(
    OrderRequest request,
    ServerCallContext ctx)
{
    return new OrderResponse { Id = request.Id, Status = "ACCEPTED" };
}
 
// 클라이언트
var response = await client.PlaceOrderAsync(
    new OrderRequest { Id = "o-1", Item = "Potion", Qty = 3 });

rpc ListOrders (OrderQuery) returns (stream OrderResponse);

// 서버
public override async Task ListOrders(
    OrderQuery request,
    IServerStreamWriter<OrderResponse> responseStream,
    ServerCallContext ctx)
{
    foreach (var order in GetOrders(request.UserId))
    {
        await responseStream.WriteAsync(order);
    }
    // 메서드 리턴 시 스트림 자동 종료
}
 
// 클라이언트
using var call = client.ListOrders(new OrderQuery { UserId = "u-42" });
 
await foreach (var reply in call.ResponseStream.ReadAllAsync())
{
    Console.WriteLine($"{reply.Id} -> {reply.Status}");
}

rpc UploadOrders (stream OrderRequest) returns (UploadSummary);

// 서버
public override async Task<UploadSummary> UploadOrders(
    IAsyncStreamReader<OrderRequest> requestStream,
    ServerCallContext ctx)
{
    int count = 0;
    await foreach (var req in requestStream.ReadAllAsync(ctx.CancellationToken))
    {
        count++;
    }
    return new UploadSummary { Total = count };
}
 
// 클라이언트
using var call = client.UploadOrders();
 
foreach (var i in Enumerable.Range(1, 5))
{
    await call.RequestStream.WriteAsync(
        new OrderRequest { Id = $"o-{i}", Item = "Gem", Qty = i });
}
 
await call.RequestStream.CompleteAsync(); // 반드시 종료 명시
var summary = await call.ResponseAsync;

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

// 서버
public override async Task Chat(
    IAsyncStreamReader<ChatMessage> requestStream,
    IServerStreamWriter<ChatMessage> responseStream,
    ServerCallContext ctx)
{
    await foreach (var msg in requestStream.ReadAllAsync(ctx.CancellationToken))
    {
        await responseStream.WriteAsync(new ChatMessage {
            UserId = "server",
            Text = $"[echo] {msg.Text}"
        });
    }
}
 
// 클라이언트
using var call = client.Chat();
 
// 수신 태스크 (별도 스레드)
var readTask = Task.Run(async () =>
{
    await foreach (var msg in call.ResponseStream.ReadAllAsync())
    {
        Console.WriteLine($"<- {msg.Text}");
    }
});
 
// 송신
await call.RequestStream.WriteAsync(new ChatMessage { UserId = "u-1", Text = "Hi!" });
await call.RequestStream.WriteAsync(new ChatMessage { UserId = "u-1", Text = "How are you?" });
 
await call.RequestStream.CompleteAsync();
await readTask;

flowchart LR
    subgraph HTTP_1["HTTP/1.1"]
        A[요청1] --> B[응답1]
        B --> C[요청2]
        C --> D[응답2]
    end
    
    subgraph HTTP_2["HTTP/2"]
        E[요청1] --> F[응답1]
        E --> G[요청2]
        G --> H[응답2]
    end

public class MetricsInterceptor : Interceptor
{
    public override async Task<TResponse> UnaryServerHandler<TRequest, TResponse>(
        TRequest request,
        ServerCallContext context,
        UnaryServerMethod<TRequest, TResponse> continuation)
    {
        var stopwatch = Stopwatch.StartNew();
        try
        {
            var response = await continuation(request, context);
            stopwatch.Stop();
            
            GrpcDuration.WithLabels(context.Method, "OK")
                .Observe(stopwatch.Elapsed.TotalSeconds);
            
            return response;
        }
        catch (Exception ex)
        {
            stopwatch.Stop();
            GrpcDuration.WithLabels(context.Method, "ERROR")
                .Observe(stopwatch.Elapsed.TotalSeconds);
            throw;
        }
    }
}

sequenceDiagram
    participant Client
    participant ProductMgt
    participant Inventory
 
    Client->>ProductMgt: Deadline: 50ms
    Note over ProductMgt: 처리 20ms
    ProductMgt->>Inventory: 남은 Deadline: 30ms
    Note over Inventory: 처리 40ms (초과!)
    Inventory-->>ProductMgt: DEADLINE_EXCEEDED
    ProductMgt-->>Client: DEADLINE_EXCEEDED

using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
 
await client.SystemChatAsync(
    new SystemChatRequest { ... },
    cancellationToken: cts.Token);

// 클라이언트 - 요청 헤더
var headers = new Metadata {
    { "authorization", $"Bearer {token}" },
    { "x-trace-id", traceId }
};
 
var call = client.PlaceOrderAsync(request, headers: headers);
 
// 서버 - 헤더 읽기
var auth = ctx.RequestHeaders.FirstOrDefault(h => h.Key == "authorization")?.Value;
 
// 서버 - 응답 헤더/트레일러 추가
await ctx.WriteResponseHeadersAsync(new Metadata { { "x-server", "ordersvc" } });
ctx.ResponseTrailers.Add("x-quota-remaining", "42");

protected override async ValueTask<RPGBossFirstClearRes> HandleMethod(
    RPGBossFirstClearReq request, IUserIdentity userIdentity)
{
    var battle = await GetBattle(request.BattleIndex);
    
    if (battle.IsCleared)
    {
        var trailers = new Metadata
        {
            { "app-error-code", "E001_ALREADY_CLEARED" },
            { "app-user-message", "이미 클리어한 인덱스입니다." }
        };
 
        throw new RpcException(
            new Status(StatusCode.AlreadyExists, "Cleared Index"),
            trailers);
    }
    
    // 정상 로직...
}

try
{
    var reply = await client.RPGBossFirstClearAsync(request);
}
catch (RpcException ex)
{
    switch (ex.StatusCode)
    {
        case StatusCode.AlreadyExists:
            var userMsg = ex.Trailers.GetValue("app-user-message");
            ShowToast(userMsg);
            break;
 
        case StatusCode.Unavailable:
        case StatusCode.DeadlineExceeded:
            EnqueueRetry("잠시 후 다시 시도해주세요.");
            break;
 
        default:
            ShowToast("알 수 없는 오류가 발생했습니다.");
            break;
    }
}