2 Perbandingan gRPC dengan REST dan GraphQL

Di era modern pengembangan sistem terdistribusi dan microservices, kebutuhan untuk komunikasi antarlayanan semakin krusial. Tiga pendekatan yang cukup populer adalah REST, GraphQL, dan gRPC. Masing-masing punya filosofi, kelebihan, dan kekurangan tersendiri. Dalam artikel ini saya akan membedah ketiganya secara teknis dengan perbandingan performa, skenario penggunaannya, juga contoh kode sederhana agar kita bisa memilih yang paling cocok sesuai kebutuhan.

Sekilas Tentang REST, GraphQL, & gRPC

REST (Representational State Transfer) telah menjadi andalan API development selama bertahun-tahun. Konsep resource, HTTP verbs, dan statelessness membuat REST sangat mudah dipahami dan diimplementasikan.

GraphQL adalah query language alternatif dari Facebook yang membuka fleksibilitas tinggi bagi klien untuk memilih data yang memang mereka butuhkan.

gRPC adalah framework komunikasi Remote Procedure Call (RPC) buatan Google using Protocol Buffers sebagai format serialization. gRPC mendukung streaming dan performa yang jauh lebih efisien berkat binary protocol.

Tabel Perbandingan: REST vs GraphQL vs gRPC

Diagram Alur: Request-Response Model

Mari kita visualisasikan alur data sederhana antar client dan service untuk masing-masing teknologi:

flowchart LR
    subgraph REST
        A[Client] -->|HTTP GET/POST| B[REST API]
        B -->|JSON Response| A
    end

    subgraph GraphQL
        C[Client] -->|Query / Mutation| D[GraphQL Server]
        D -->|JSON Response| C
    end

    subgraph gRPC
        E[Client Stub] -->|Proto
 Request Message | F[gRPC Server]
        F -->|Proto
Response Message | E
    end

Kapan Pakai REST, GraphQL, atau gRPC?

REST cocok:

• Aplikasi web publik/API third-party
• Dokumentasi dan tooling besar
• Prototyping cepat

GraphQL cocok:

• Client mobile/web dengan kebutuhan data dinamis/minimal payload
• Agregasi berbagai sumber data (API gateway)
• Relasi kompleks antar resource

gRPC cocok:

• Komunikasi internal antar microservices
• Kebutuhan performa tinggi (low latency, high throughput)
• Sistem real-time & streaming data

Contoh Kode: REST vs GraphQL vs gRPC

1. REST (Express.js)

const express = require('express');
const app = express();

app.get('/books/:id', (req, res) => {
  // Simulasi get data
  res.json({ id: req.params.id, title: "Clean Code", author: "Robert C. Martin" });
});

app.listen(3000, () => console.log('REST API on port 3000'));

2. GraphQL (Apollo Server)

const { ApolloServer, gql } = require('apollo-server');

// Type definitions
const typeDefs = gql`
  type Book { id: ID!, title: String!, author: String! }
  type Query { book(id: ID!): Book }
`;

// Resolvers
const resolvers = {
  Query: { 
    book: (_, { id }) => ({ id, title: "Clean Code", author: "Robert C. Martin" })
  }
};

// Server
const server = new ApolloServer({ typeDefs, resolvers });
server.listen().then(({ url }) => console.log(`GraphQL ready at ${url}`));

3. gRPC (Node.js)

a. Protobuf Definition (book.proto):

syntax = "proto3";

service BookService {
  rpc GetBook(GetBookRequest) returns (Book);
}

message GetBookRequest { string id = 1; }
message Book { string id = 1; string title = 2; string author = 3; }

b. Server Implementation:

const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');

const packageDefinition = protoLoader.loadSync('book.proto');
const bookProto = grpc.loadPackageDefinition(packageDefinition);

function getBook(call, callback) {
  callback(null, { id: call.request.id, title: "Clean Code", author: "Robert C. Martin" });
}

const server = new grpc.Server();
server.addService(bookProto.BookService.service, { GetBook: getBook });
server.bindAsync('127.0.0.1:50051', grpc.ServerCredentials.createInsecure(), () => server.start());

Benchmark Sederhana: REST vs gRPC

Berikut simulasi perbandingan kecepatan ciri utama dari REST dan gRPC (tanpa GraphQL karena fokus performa pada REST vs gRPC):

Note: Angka di atas adalah simulasi, rata-rata hasil benchmarking komunitas menggunakan nodejs/grpc dan nodejs/express.

Complex Data Fetching: Overfetching dan Underfetching

• REST: Response tetap sama walau client hanya butuh satu field.
• GraphQL: Client bisa spesifik request field apa saja.
• gRPC: Mirip REST (satu RPC satu response fixed), tapi lebih fleksibel karena bisa buat service lebih granular.

Contoh Query GraphQL yang hanya memerlukan title, tidak butuh author:

query {
  book(id: "1") { title }
}

REST dan gRPC harus mengembalikan semua nilai yang didefinisikan pada endpoint/service, atau harus custom.

Pengembangan dan Tools

• REST: OpenAPI/Swagger, Postman, Insomnia
• GraphQL: GraphQL Playground, Altair, Apollo Studio
• gRPC: Evans, grpcurl, Postman (terbatas)

Evolusi API & Versioning

• REST: /api/v1/books, /api/v2/books
• GraphQL: Umumnya non-breaking, introspective schema
• gRPC: Mendukung evolution (field number proto tidak boleh ganti) dan optional fields

Kesimpulan

Secara teknis, REST menawarkan kesederhanaan yang disukai banyak developer, terutama dalam API publik. GraphQL mengatasi masalah overfetch dan underfetch dengan fleksibilitas query, sisi client. Di sisi lain, gRPC adalah pilihan modern untuk komunikasi mesin-ke-mesin (machine-to-machine) di lingkungan microservices yang membutuhkan performa dan efisiensi tinggi.

Rekomendasi:

• Jika API publik atau integrasi dengan banyak client eksternal: REST atau GraphQL.
• Jika API internal, performa, dan kecepatan prioritas: gRPC.

Semua jalan punya karakteristik. Pilihlah berdasarkan kebutuhan, tim, dan ekosistem Anda!

Referensi:

• gRPC vs REST: Why gRPC?
• GraphQL vs REST
• Protocol Buffers Basics