gRPC không phải “REST nhanh hơn”. Nó là một mô hình giao tiếp khác: hợp đồng nhị phân, sinh code từ .proto, chạy trên HTTP/2, và được thiết kế cho service-to-service. Nếu bạn dùng nó cho một API công khai mà client là trình duyệt hoặc đối tác bên ngoài, bạn sẽ gặp những vấn đề mà REST không có — và không có nghĩa là bạn đang làm sai, chỉ là bạn đang dùng sai công cụ.
Bài này cập nhật phần gRPC trong lộ trình .NET 2026: dựng server và client với Grpc.AspNetCore 2.85 trên .NET 10, xử lý deadline/cancellation, streaming, lỗi, và tiêu chí chọn gRPC thay vì REST/GraphQL.
Mục lục
Cập nhật 2026: gRPC trong .NET đã ổn định
- Grpc.AspNetCore 2.85 là package server chính thức;
Grpc.Net.Clientcho client .NET;Grpc.Toolssinh code từ proto lúc build. - .NET 10 hỗ trợ đầy đủ HTTP/2, TLS, và các API
ServerCallContext/RpcException. Không còn lý do dùng thư viện cũ hay tự viết HTTP/2 framing. - Trình duyệt vẫn không gọi gRPC thuần được. Cần gRPC-Web (
Grpc.AspNetCore.Web) hoặc Connect (Buf). Đây là giới hạn của nền tảng, không phải của .NET.
gRPC hoạt động như thế nào?
Ba thành phần:
- Protocol Buffers: định nghĩa message và service trong file
.proto; dữ liệu truyền dạng nhị phân, có schema, có versioning. - HTTP/2: multiplexing nhiều request trên một kết nối, header nén HPACK, streaming hai chiều.
- Code generation: từ
.proto, tool sinh class client/server ở cả C#, Java, Go, Python… nên hợp đồng giữa các service là một nguồn duy nhất.
So với REST JSON: payload nhỏ hơn, parse nhanh hơn, contract chặt hơn, nhưng khó đọc bằng mắt và không cache theo URL. So với GraphQL: gRPC không cho client chọn field tùy ý; hợp đồng cố định theo proto, đổi schema cần versioning rõ ràng.
Bốn kiểu gọi
| Kiểu | Mô tả | Ví dụ |
|---|---|---|
| Unary | 1 request, 1 response | Lấy chi tiết đơn hàng |
| Server streaming | 1 request, nhiều response | Đẩy log/sự kiện, feed dữ liệu lớn |
| Client streaming | Nhiều request, 1 response | Upload file, gửi batch telemetry |
| Bidirectional | Nhiều request, nhiều response | Chat, đồng bộ trạng thái real-time |
Đừng chọn streaming chỉ vì nó tồn tại. Streaming khó debug, khó retry, khó rate limit và khó quan sát hơn unary. Nếu bạn chỉ cần lấy một danh sách, unary với phân trang vẫn là lựa chọn đúng.
Dựng server trong ASP.NET Core 10
dotnet add package Grpc.AspNetCore --version 2.85.0
// File: Protos/orders.proto
syntax = "proto3";
option csharp_namespace = "Shop.Api.Grpc";
package orders;
service Orders {
rpc GetOrder (GetOrderRequest) returns (OrderReply);
rpc WatchOrders (WatchOrdersRequest) returns (stream OrderEvent);
}
message GetOrderRequest {
int32 id = 1;
}
message OrderReply {
int32 id = 1;
string code = 2;
string status = 3;
double total = 4;
}
message WatchOrdersRequest {
string tenant_id = 1;
}
message OrderEvent {
int32 id = 1;
string status = 2;
}
Trong .csproj, khai báo proto để sinh code:
<ItemGroup>
<Protobuf Include="Protos/orders.proto" GrpcServices="Server" />
</ItemGroup>
Service implementation:
// File: Services/OrdersGrpcService.cs
using Grpc.Core;
public sealed class OrdersGrpcService : Orders.OrdersBase
{
private readonly OrderService _orders;
public OrdersGrpcService(OrderService orders) => _orders = orders;
public override async Task<OrderReply> GetOrder(
GetOrderRequest request, ServerCallContext context)
{
var order = await _orders.FindAsync(request.Id, context.CancellationToken);
if (order is null)
{
throw new RpcException(new Status(StatusCode.NotFound, "Order not found"));
}
return new OrderReply
{
Id = order.Id,
Code = order.Code,
Status = order.Status,
Total = (double)order.Total
};
}
public override async Task WatchOrders(
WatchOrdersRequest request,
IServerStreamWriter<OrderEvent> responseStream,
ServerCallContext context)
{
await foreach (var evt in _orders.WatchAsync(request.TenantId, context.CancellationToken))
{
await responseStream.WriteAsync(new OrderEvent { Id = evt.Id, Status = evt.Status });
}
}
}
// File: Program.cs
builder.Services.AddGrpc();
builder.Services.AddScoped<OrderService>();
var app = builder.Build();
app.MapGrpcService<OrdersGrpcService>();
Client: deadline và cancellation
// File: Client.cs
using Grpc.Net.Client;
var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new Orders.OrdersClient(channel);
try
{
var reply = await client.GetOrderAsync(
new GetOrderRequest { Id = 42 },
deadline: DateTime.UtcNow.AddSeconds(5),
cancellationToken: ct);
Console.WriteLine($"{reply.Code}: {reply.Status}");
}
catch (RpcException ex) when (ex.StatusCode == StatusCode.NotFound)
{
Console.WriteLine("Không tìm thấy đơn hàng.");
}
Deadline là bắt buộc trong production. Không có deadline, một service bị treo có thể giữ request vô hạn và làm cạn connection pool. Deadline được truyền qua grpc-timeout và cả server lẫn client đều tôn trọng. ServerCallContext.CancellationToken sẽ được hủy khi hết deadline hoặc client hủy — hãy truyền nó xuống EF Core/HTTP call.
Với ASP.NET Core, dùng Grpc.Net.ClientFactory để đăng ký typed client qua DI, có handler và deadline mặc định:
builder.Services
.AddGrpcClient<Orders.OrdersClient>(o => o.Address = new Uri("https://orders:5001"))
.ConfigurePrimaryHttpMessageHandler(() => new SocketsHttpHandler
{
PooledConnectionIdleTimeout = Timeout.InfiniteTimeSpan,
KeepAlivePingDelay = TimeSpan.FromSeconds(60),
KeepAlivePingTimeout = TimeSpan.FromSeconds(20),
EnableMultipleHttp2Connections = true
});
Lỗi: dùng status code, đừng chỉ dùng message
gRPC có bộ status code riêng: InvalidArgument, NotFound, PermissionDenied, Unauthenticated, FailedPrecondition, ResourceExhausted, Unavailable, DeadlineExceeded. Client nên xử lý theo code, không parse message.
throw new RpcException(new Status(StatusCode.InvalidArgument, "id phải lớn hơn 0"));
Với lỗi validation phức tạp, dùng rich error model (google.rpc.Status + BadRequest details) thay vì nhồi chuỗi JSON vào message. Điều này cho client đọc được field lỗi mà không phải parse text.
Đừng trả Internal cho lỗi nghiệp vụ. Nó làm client tưởng server hỏng và retry — trong khi lỗi thực ra là input sai. Ngược lại, đừng trả InvalidArgument cho lỗi hệ thống, vì client sẽ không retry khi cần retry.
Bảo mật và vận hành
- TLS bắt buộc ngoài mạng nội bộ tin cậy; gRPC không có CORS/CSP như HTTP API thông thường.
- Auth: gửi token qua metadata (
Authorization) và validate ở interceptor; không tin fielduserIdtrong message. - Interceptors cho logging, tracing, auth, rate limiting. Chúng chạy ở cả client và server; đừng nhồi business logic vào interceptor.
- Kích thước message: đặt
MaxReceiveMessageSize/MaxSendMessageSizephù hợp. Message quá lớn là lỗi thiết kế, không phải vấn đề cấu hình. - Reflection: bật
Grpc.Reflectionở môi trường dev để tool nhưgrpcurlkhám phá service; tắt ở production nếu không cần. - Health checks: dùng
Grpc.AspNetCore.HealthChecksđể orchestration biết service còn sống.
Khi nào không nên dùng gRPC?
- Client là trình duyệt. Cần gRPC-Web/Connect, hoặc đơn giản là dùng REST/GraphQL. Thêm một tầng proxy chỉ để gọi service là chi phí không cần thiết.
- API công khai cho đối tác. Hợp đồng proto khó versioning hơn OpenAPI, và đối tác khó debug hơn.
- Cần HTTP caching/CDN. gRPC dùng POST và binary, cache theo URL không hoạt động.
- CRUD đơn giản, ít service. REST + OpenAPI đủ tốt; gRPC thêm codegen và tooling mà không mang lại lợi ích rõ ràng.
- Team chưa quen HTTP/2, deadline, streaming. gRPC lỗi trong production thường khó chẩn đoán hơn REST; cần người hiểu nó.
So sánh nhanh
| Tiêu chí | REST/JSON | gRPC |
|---|---|---|
| Hợp đồng | OpenAPI (tùy chọn) | .proto (bắt buộc, sinh code) |
| Payload | Text, lớn hơn | Binary, nhỏ hơn |
| Streaming | SSE/WebSocket thủ công | Có sẵn 4 kiểu |
| Browser | Hỗ trợ trực tiếp | Cần gRPC-Web/Connect |
| Cache/CDN | Tốt | Không |
| Debug | curl/JSON dễ | Cần grpcurl/reflection |
| Phù hợp | API công khai, CRUD | Service nội bộ, hiệu năng, streaming |
Kết luận thực dụng: dùng gRPC cho giao tiếp nội bộ giữa các service .NET khi bạn kiểm soát cả hai đầu; dùng REST cho API công khai và client browser; dùng GraphQL khi cần client tự chọn field. Đừng biến lựa chọn giao thức thành tranh luận tôn giáo — hãy chọn theo ràng buộc của client và team vận hành.
gRPC có thực sự nhanh hơn REST không?
Câu trả lời ngắn: nhanh hơn trong nhiều trường hợp nội bộ, nhưng không phải lúc nào cũng đáng kể. Lợi ích đến từ ba nguồn:
- Payload nhỏ hơn: protobuf nén tốt hơn JSON, đặc biệt với message nhiều field và số lượng lớn.
- Ít round-trip hơn: HTTP/2 multiplexing và streaming giảm chi phí mở kết nối.
- Parse nhanh hơn: binary decoding rẻ hơn JSON parsing, nhất là ở throughput cao.
Nhưng nếu endpoint của bạn trả về 10KB JSON mỗi lần, gọi 5 request/phút, chênh lệch vài mili-giây không đáng để đổi toàn bộ tooling. Nếu bạn gọi 50.000 request/giây giữa các service, hoặc truyền luồng dữ liệu lớn, gRPC có thể là khoản đầu tư đúng. Hãy đo bằng benchmark trên workload thật, không dựa vào benchmark blog.
Một điểm ít được nói: gRPC thường nhanh hơn ở tầng serialization, nhưng chậm hơn ở khâu vận hành nếu team không quen. Debug lỗi HTTP/2, cấu hình keep-alive, deadline và streaming phức tạp hơn nhiều so với đọc JSON. Tổng chi phí sở hữu mới là thứ quyết định.
Versioning proto đúng cách
Proto có quy tắc versioning riêng, và vi phạm chúng là cách nhanh nhất để làm client cũ hiểu sai dữ liệu:
- Không tái sử dụng field number. Field number là hợp đồng; xóa field phải đánh dấu
reserved, không dùng lại số đó cho field mới. - Không đổi kiểu field (int32 → string) trong cùng một số. Tạo field mới thay vì tái sử dụng.
- Thêm field optional là tương thích; client cũ bỏ qua field lạ. Xóa field cũng tương thích nếu đã
reserved. - Version theo package/service (
orders.v1,orders.v2) khi thay đổi ngữ nghĩa, không chỉ thêm field. - Kiểm tra tương thích trong CI bằng tool so sánh proto (buf breaking change detection).
Observability cho gRPC
Log HTTP status không đủ. Hãy log theo method và status code gRPC, kèm deadline còn lại, thời gian xử lý, kích thước message và trace ID:
- Metric: request rate, error rate theo
StatusCode, p95/p99 latency theo method. - Trace: truyền
traceparentqua metadata để nối client → server → DB. - Log: không log toàn bộ message (có thể chứa PII); log ID và trường cần thiết.
- Alert:
UnavailablevàDeadlineExceededtăng đột biến thường là dấu hiệu saturation hoặc network, không phải lỗi logic.
Checklist triển khai
- Proto có versioning rõ ràng; không tái sử dụng field number đã xóa.
- Mọi call có deadline; cancellation token được truyền xuống I/O.
- Lỗi dùng đúng
StatusCode, không lộ stack trace. - Auth qua metadata + interceptor; kiểm tra tenant/user trong service.
- Giới hạn message size, bật health checks, có metric latency/error theo method.
- Có test cho deadline, cancellation và lỗi NotFound/PermissionDenied.
Bài liên quan: RESTful API best practices, GraphQL với HotChocolate, và HTTP/HTTPS để hiểu nền tảng HTTP/2 mà gRPC dựa vào.



