GraphQL vs. gRPC: Chọn mô hình API phù hợp vào năm 2026

Trong hơn mười lăm năm, REST đã thống trị như một giao thức mặc định cho các API web. Tuy nhiên, khi các hệ thống phân tán mở rộng thành các mạng lưới microservice phức tạp và hệ sinh thái đa khách hàng (web, di động, TV thông minh, IoT), những thiếu sót về cấu trúc của REST—lấy quá nhiều dữ liệu (over-fetching), lấy thiếu dữ liệu (under-fetching), các chuyến đi khứ hồi xếp tầng (cascading roundtrips), và việc thực thi schema lỏng lẻo—đã trở thành những nút thắt cổ chai rõ ràng.

Trong các kiến trúc doanh nghiệp hiện đại, cuộc thảo luận về kiến trúc đã tập trung vào hai lựa chọn thay thế hiệu suất cao: GraphQL và gRPC.

Mặc dù cả hai đều giải quyết những thiếu sót của REST, chúng lại xuất phát từ những triết lý kỹ thuật cơ bản khác nhau:

• GraphQL lấy khách hàng làm trung tâm, tối ưu hóa cho việc tổng hợp dữ liệu linh hoạt và tốc độ phát triển của frontend.
• gRPC lấy mạng làm trung tâm, tối ưu hóa cho giao tiếp giữa các máy với độ trễ thấp, thông lượng cao.

Hướng dẫn này cung cấp một so sánh kỹ thuật toàn diện về GraphQL và gRPC, đánh giá việc tuần tự hóa nhị phân, các mô hình streaming, an toàn hợp đồng, và cách kết hợp chúng thành một kiến trúc lai tối ưu.

Các đối thủ: Nền tảng triết lý

GraphQL: Đồ thị dữ liệu do client điều khiển

Được phát triển bởi Facebook và được quản lý bởi GraphQL Foundation, GraphQL cung cấp một ngôn ngữ truy vấn khai báo và công cụ thực thi runtime. Thay vì gọi nhiều endpoint REST chuyên biệt (/users/1, /users/1/orders, /users/1/loyalty), client gửi một tài liệu truy vấn duy nhất đến một endpoint /graphql thống nhất mô tả chính xác hình dạng của phản hồi mong muốn:

# Client Query Document
query GetUserProfile($userId: ID!) {
  user(id: $userId) {
    id
    fullName
    orders(limit: 3) {
      id
      totalAmount
      status
    }
  }
}

Máy chủ giải quyết yêu cầu và trả về một payload JSON phản ánh chính xác hình dạng của truy vấn.

gRPC: Giao thức RPC nhị phân của Google

Được phát triển bởi Google và được CNCF lưu trữ, gRPC là một framework Remote Procedure Call (RPC) mã nguồn mở, ưu tiên hợp đồng. Nó dựa vào Protocol Buffers (Protobuf) làm Ngôn ngữ Định nghĩa Giao diện (IDL) và định dạng truyền tải, hoạt động nghiêm ngặt trên HTTP/2:

// user_service.proto
syntax = "proto3";

package billing.v1;

option go_package = "github.com/company/billing/gen/v1;billingv1";

service UserService {
  rpc GetUser (GetUserRequest) returns (UserResponse);
  rpc StreamTransactions (StreamTransactionsRequest) returns (stream TransactionEvent);
}

message GetUserRequest {
  string user_id = 1;
}

message UserResponse {
  string id = 1;
  string full_name = 2;
  repeated Order orders = 3;
}

message Order {
  string id = 1;
  double total_amount = 2;
  string status = 3;
}

message StreamTransactionsRequest {
  string user_id = 1;
}

message TransactionEvent {
  string transaction_id = 1;
  int64 timestamp = 2;
  double amount = 3;
}

Các trình biên dịch gRPC (protoc) tự động tạo các stub client được định kiểu mạnh và giao diện máy chủ trên hàng chục ngôn ngữ (Go, Java, C++, Python, Rust, TypeScript).

So sánh kiến trúc theo 5 khía cạnh

1. Tuần tự hóa & Hiệu quả đường truyền: Protobuf so với JSON

Sự khác biệt lớn nhất giữa gRPC và GraphQL nằm ở cách mã hóa payload:

• gRPC (Protobuf nhị phân): Các trường thông báo được xác định bằng các thẻ trường số (ví dụ: thẻ trường 1 cho user_id). Các khóa không bao giờ được gửi qua đường truyền. Số nguyên sử dụng mã hóa zig-zag có độ dài thay đổi (varint), và số dấu phẩy động chiếm các byte nhị phân cố định.
• GraphQL (JSON văn bản): Mọi phản hồi đều truyền các khóa chuỗi đầy đủ ("fullName", "totalAmount") qua đường truyền lặp đi lặp lại cho mỗi mục trong danh sách.

So sánh: Payload 100.000 bản ghi người dùng phức tạp

Vì Protobuf tránh phân tích chuỗi và thoát ký tự, chi phí CPU trên các microservice thông lượng cao giảm đáng kể.

2. Giao thức truyền tải & Streaming

• gRPC yêu cầu HTTP/2. Nó hỗ trợ bốn mô hình streaming một cách tự nhiên:
  1. Unary RPC: Yêu cầu-phản hồi tiêu chuẩn.
  2. Server Streaming: Client gửi một yêu cầu, máy chủ truyền nhiều thông báo trở lại (ví dụ: thu thập nhật ký thời gian thực).
  3. Client Streaming: Client truyền dữ liệu đến máy chủ (ví dụ: tải lên các phần lớn của tệp).
  4. Bidirectional Streaming: Giao tiếp song công hoàn toàn trên một kết nối TCP duy nhất.
• GraphQL truyền thống hoạt động trên HTTP/1.1 hoặc HTTP/2. Mặc dù nó hỗ trợ GraphQL Subscriptions cho các sự kiện thời gian thực, các subscription yêu cầu một giao thức trạng thái riêng biệt (như WebSockets hoặc Server-Sent Events / SSE) với việc quản lý kết nối và xác thực phức tạp.

3. An toàn hợp đồng & Thay đổi gây lỗi

• gRPC: Đảm bảo khả năng tương thích ngược và xuôi thông qua các quy tắc Protobuf:
  • Bạn không bao giờ thay đổi số trường (1, 2, 3).
  • Các trường có thể bị đánh dấu là không dùng nữa (deprecated), nhưng không bao giờ bị xóa khỏi lịch sử schema.
  • Các trường mới sẽ tự động bị bỏ qua bởi các phiên bản client cũ hơn mà không gây lỗi.
• GraphQL: Thực thi xác thực schema mạnh mẽ thông qua SDL của nó. Các trường bị đánh dấu là không dùng nữa được chú thích bằng @deprecated(reason: "..."), cho phép người dùng frontend di chuyển trước khi bị xóa.

4. Khả năng sử dụng trên trình duyệt & Frontend

Ở đây, GraphQL có một lợi thế áp đảo:

• GraphQL trong Web Clients: Trình duyệt web nói JSON gốc. Các nhà phát triển frontend có thể kiểm tra truy vấn một cách tương tác trong GraphiQL hoặc Apollo Studio, kiểm tra ngay lập tức cây phản hồi trực tiếp. Các thư viện client như Apollo Client hoặc urql cung cấp bộ nhớ đệm chuẩn hóa tích hợp.
• gRPC trong Web Clients: Trình duyệt không hiển thị các nguyên thủy khung HTTP/2 cấp thấp cho JavaScript. Do đó, các client trình duyệt gốc không thể giao tiếp trực tiếp bằng gRPC tiêu chuẩn; chúng phải giao tiếp thông qua gRPC-Web qua một proxy Envoy, điều này làm giảm tính tiện dụng.

Tiêu chuẩn doanh nghiệp: Kiến trúc BFF lai

Trong các hệ thống sản xuất quy mô lớn, việc lựa chọn giữa GraphQL và gRPC không phải là một quyết định hoặc/hoặc. Mô hình đã được chứng minh trong ngành vào năm 2026 là Kiến trúc BFF (Backend-for-Frontend) lai:

[ Web Browser ]    [ Mobile App (iOS / Android) ]
        \                 /
         \               /  GraphQL (JSON over HTTPS)
          ▼             ▼
    ┌───────────────────────────────┐
    │     GraphQL API Gateway       │  <-- Acts as Backend-for-Frontend (BFF)
    │   (Apollo Router / Yoga)      │      Translates client queries to RPCs
    └───────────────────────────────┘
          /        |         \
         /         |          \  gRPC (Binary Protobuf over HTTP/2)
        ▼          ▼           ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Auth Service │ │ Order Engine │ │ Payment Mesh │  <-- Internal Microservice Mesh
│    (Go)      │ │   (Rust)     │ │   (Java)     │
└──────────────┘ └──────────────┘ └──────────────┘

1. Lưu lượng Bắc-Nam (Client-to-Gateway): Sử dụng GraphQL. Các nhà phát triển di động và web có toàn quyền linh hoạt yêu cầu các hình dạng dữ liệu tùy chỉnh, giảm thiểu các chuyến đi khứ hồi qua mạng di động và nhanh chóng tạo mẫu các giao diện mới mà không cần thay đổi backend.
2. Lưu lượng Đông-Tây (Service-to-Service): Sử dụng gRPC. Các microservice nội bộ giao tiếp qua các kết nối Protobuf nhị phân cực nhanh với chi phí CPU tối thiểu, mTLS đầu cuối và đồng bộ hóa hợp đồng được đảm bảo.

Ví dụ mã: Lớp dịch thuật lai

Đây là cách một GraphQL resolver bằng TypeScript hoạt động như một gRPC client gọi một dịch vụ Go nội bộ:

// gateway/resolvers/userResolver.ts
import { userGrpcClient } from '@/lib/grpc/userClient';
import type { Resolvers } from '@/generated/graphql-types';

export const resolvers: Resolvers = {
  Query: {
    user: async (_parent, { id }, context) => {
      // 1. Client invokes GraphQL query
      // 2. Gateway delegates to internal Go gRPC service
      return new Promise((resolve, reject) => {
        userGrpcClient.GetUser({ userId: id }, (err, response) => {
          if (err) {
            return reject(new Error(`gRPC error: ${err.message}`));
          }
          resolve({
            id: response.id,
            fullName: response.fullName,
            orders: response.orders.map((o) => ({
              id: o.id,
              totalAmount: o.totalAmount,
              status: o.status,
            })),
          });
        });
      });
    },
  },
};

Ma trận quyết định kiến trúc

Các câu hỏi thường gặp

Kết luận

GraphQL và gRPC không phải là đối thủ cạnh tranh; chúng là những công cụ bổ sung được thiết kế cho các phân đoạn khác nhau của ngăn xếp mạng.

Sử dụng GraphQL khi sự linh hoạt của nhà phát triển, tính tiện dụng phong phú của client và việc định hình dữ liệu động chiếm ưu thế. Sử dụng gRPC khi độ trễ mạng, tiết kiệm CPU, định kiểu nghiêm ngặt và streaming tần số cao là yếu tố quyết định. Kết hợp chúng thông qua kiến trúc Backend-for-Frontend (BFF) mang lại những điều tốt nhất của cả hai thế giới.

Bạn cũng có thể thích

• Liên kết GraphQL nâng cao
• Các mẫu TypeScript nâng cao cho ứng dụng doanh nghiệp
• TypeScript Generics: Các mẫu nâng cao cho API an toàn kiểu
• Xây dựng một Monorepo TypeScript hiện đại