Implementasi gRPC untuk High Throughput Service Communication

Anda merasa API yang Anda bangun mulai terasa “keteteran” saat harus melayani banyak request? Atau mungkin Anda mulai mencari cara agar komunikasi antar microservices berjalan lebih cepat, lebih efisien, dan lebih hemat bandwidth? Jika ya, maka gRPC adalah teknologi yang sedang Anda butuhkan.

Banyak pemula yang ingin masuk ke dunia high-performance backend merasa bingung. “Bagaimana memulainya?”, “Apa bedanya dengan REST?”, “Haruskah saya belajar ProtoBuf dulu?”. Kekhawatiran seperti itu wajar—dan artikel ini hadir untuk menjawab semuanya.

Di sini Anda akan mendapatkan panduan langkah demi langkah, penjelasan konsep dengan bahasa sederhana, serta tips penting agar implementasi gRPC Anda tidak gagal di tengah jalan. Jika Anda membaca hingga akhir, Anda akan memahami bagaimana membuat service gRPC, menulis file .proto, menjalankan server, hingga menghubungkannya ke client.

Apa Itu gRPC dan Mengapa Penting untuk High Throughput?

gRPC adalah framework komunikasi antar layanan (service-to-service) yang dibangun oleh Google. gRPC menggunakan HTTP/2 dan Protocol Buffers (ProtoBuf) sehingga mampu menghasilkan komunikasi yang sangat cepat, ringan, dan stabil.

Beberapa alasan gRPC cocok untuk high throughput:

• Seri­alisasi ProtoBuf lebih kecil dan cepat dibanding JSON.
• HTTP/2 mendukung multiplexing dan streaming.
• Cocok untuk microservices yang membutuhkan komunikasi intensif.
• Mendukung bi-directional streaming, ideal untuk data real-time.

1. Persiapan Lingkungan & Tools yang Dibutuhkan

Sebelum memulai, pastikan Anda memiliki:

1. Bahasa pemrograman pilihan (Go, Node.js, Python, Java, C#, dll).
2. Protocol Buffer Compiler (protoc).
3. Plugin tambahan sesuai bahasa Anda.

Contoh instalasi protoc di Linux:

sudo apt install protobuf-compiler
protoc --version

sudo apt install protobuf-compiler
protoc --version

2. Membuat File ProtoBuf (.proto)

File .proto adalah jantung dari gRPC. Di dalamnya berisi:

• Struktur data (message)
• Definisi layanan (service)
• Metode komunikasi (RPC method)

Contoh file user.proto:

syntax = "proto3";

package user;

service UserService {
  rpc GetUser (UserRequest) returns (UserResponse);
}

message UserRequest {
  int32 id = 1;
}

message UserResponse {
  int32 id = 1;
  string name = 2;
}

syntax = "proto3";

package user;

service UserService {
  rpc GetUser (UserRequest) returns (UserResponse);
}

message UserRequest {
  int32 id = 1;
}

message UserResponse {
  int32 id = 1;
  string name = 2;
}

Penjelasan singkat:

• service UserService adalah nama layanan.
• rpc GetUser adalah fungsi yang dapat dipanggil oleh client.
• message mendefinisikan struktur data.

3. Generate Kode gRPC dari File .proto

Gunakan protoc untuk menghasilkan file server dan client secara otomatis.

Contoh untuk Go:

protoc --go_out=. --go-grpc_out=. user.proto

protoc --go_out=. --go-grpc_out=. user.proto

Untuk Node.js:

npm install -g grpc-tools
grpc_tools_node_protoc --js_out=import_style=commonjs,binary:. --grpc_out=. user.proto

npm install -g grpc-tools
grpc_tools_node_protoc --js_out=import_style=commonjs,binary:. --grpc_out=. user.proto

Langkah ini akan menghasilkan kode boilerplate yang siap digunakan.

4. Implementasi Server gRPC

Contoh server sederhana menggunakan Go:

type UserServer struct {
  userpb.UnimplementedUserServiceServer
}

func (s *UserServer) GetUser(ctx context.Context, req *userpb.UserRequest) (*userpb.UserResponse, error) {
  return &userpb.UserResponse{
    Id: req.Id,
    Name: "John Doe",
  }, nil
}

type UserServer struct {
  userpb.UnimplementedUserServiceServer
}

func (s *UserServer) GetUser(ctx context.Context, req *userpb.UserRequest) (*userpb.UserResponse, error) {
  return &userpb.UserResponse{
    Id: req.Id,
    Name: "John Doe",
  }, nil
}

Jalankan server:

lis, _ := net.Listen("tcp", ":50051")
grpcServer := grpc.NewServer()
userpb.RegisterUserServiceServer(grpcServer, &UserServer{})
grpcServer.Serve(lis)

lis, _ := net.Listen("tcp", ":50051")
grpcServer := grpc.NewServer()
userpb.RegisterUserServiceServer(grpcServer, &UserServer{})
grpcServer.Serve(lis)

Intinya: Anda membuat implementasi fungsi RPC dan mendaftarkannya ke server gRPC.

5. Implementasi Client gRPC

Contoh client Go:

conn, _ := grpc.Dial("localhost:50051", grpc.WithInsecure())
client := userpb.NewUserServiceClient(conn)

resp, _ := client.GetUser(context.Background(), &userpb.UserRequest{Id: 1})
fmt.Println(resp.Name)

conn, _ := grpc.Dial("localhost:50051", grpc.WithInsecure())
client := userpb.NewUserServiceClient(conn)

resp, _ := client.GetUser(context.Background(), &userpb.UserRequest{Id: 1})
fmt.Println(resp.Name)

Client hanya perlu mengimpor kode generated dan memanggil metode RPC seperti fungsi biasa.

6. Mode Komunikasi gRPC (Penting untuk High Throughput)

gRPC mendukung empat pola komunikasi yang memengaruhi throughput:

(1) Unary RPC

Permintaan–jawaban tunggal seperti REST.

(2) Server Streaming

Server mengirim banyak data ke client.

(3) Client Streaming

Client mengirim batch data besar ke server.

(4) Bi-directional Streaming

Client & server saling streaming secara bersamaan.
Ini adalah mode paling powerful untuk high throughput real-time.

7. Tips Implementasi gRPC Agar Performa Maksimal

Beberapa best practice:

• Gunakan deadline & timeout untuk mencegah request menggantung.
• Aktifkan connection pooling di client.
• Optimalkan ukuran ProtoBuf, hindari pesan terlalu besar.
• Gunakan load balancing jika traffic besar.
• Hindari log terlalu banyak di RPC yang dipanggil intensif.

Anda kini telah memahami konsep dasar gRPC, cara membuat file .proto, menjalankan server dan client, serta pola streaming yang membuat gRPC unggul untuk komunikasi high throughput. Dengan langkah-langkah ini, Anda sudah bisa mulai membangun sistem backend modern yang cepat, ringan, dan scalable.

Jika Anda ingin memperdalam topik ini, Anda bisa lanjut membaca artikel lanjutan seperti:
“Building Resilient Backend dengan Circuit Breaker (Hystrix Pattern)”