102. Studi Kasus: Membuat gRPC Server di Go dan Client di Node.js

Hari-hari ini, arsitektur layanan mikro (microservices) kian populer digunakan untuk membangun aplikasi berskala besar. Salah satu cara efektif berkomunikasi antar layanan adalah menggunakan protokol gRPC. gRPC memungkinkan pertukaran data yang cepat, efisien, serta memberikan pengalaman development yang solid melalui penggunaan Protobuf (Protocol Buffer) sebagai definisi kontraknya.

Dalam artikel ini, saya akan berbagi studi kasus bagaimana membangun gRPC server menggunakan bahasa Go dan mengkonsumsinya dengan client sederhana di Node.js. Proyek ini cocok buat kamu yang ingin melihat praktik interoperability lintas bahasa dengan gRPC, serta ingin memahami workflow full-stack-nya secara komprehensif.

Apa yang akan kita bangun?

Bayangkan kita akan membuat microservice sederhana bernama UserService. Service ini hanya punya satu endpoint: GetUser, yang jadi RPC-method untuk mengambil profile user berdasarkan user ID.

Berikut arsitektur jaringan sederhananya:

flowchart TD
    Client(Node.js) -->|gRPC call| GoServer(UserService)
    GoServer(UserService) -->|Response| Client(Node.js)

flowchart TD
    Client(Node.js) -->|gRPC call| GoServer(UserService)
    GoServer(UserService) -->|Response| Client(Node.js)

1. Menyiapkan Protokol Kontrak (user.proto)

Pertama, kita definisikan kontrak API dengan sebuah file Protobuf bernama user.proto:

 1syntax = "proto3";
 2
 3package user;
 4
 5service UserService {
 6    rpc GetUser (GetUserRequest) returns (GetUserResponse);
 7}
 8
 9message GetUserRequest {
10    string id = 1;
11}
12
13message GetUserResponse {
14    string id = 1;
15    string name = 2;
16    string email = 3;
17}

Simpan file ini di folder proto projectmu.

2. Membuat gRPC Server di Go

2.1. Meng-generate Stubs dari .proto

Install dulu dependencies di Go (modul utama: google.golang.org/grpc, dan plugin protoc-gen-go & protoc-gen-go-grpc):

1go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
2go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

Generate kode Go dari proto:

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

Struktur project setelah generate akan seperti ini:

1.
2├── proto/
3│   └── user.proto
4├── user/
5│   ├── user.pb.go
6│   └── user_grpc.pb.go
7└── main.go

2.2. Implementasi UserService di Go

File: main.go

 1package main
 2
 3import (
 4    "context"
 5    "log"
 6    "net"
 7
 8    pb "your-module-name/user" // import package hasil generate
 9
10    "google.golang.org/grpc"
11)
12
13type server struct {
14    pb.UnimplementedUserServiceServer
15}
16
17func (s *server) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.GetUserResponse, error) {
18    // Simulasi: Ambil user by ID
19    users := map[string]struct{ name, email string }{
20        "1": {"Alice", "alice@mail.com"},
21        "2": {"Bob", "bob@mail.com"},
22    }
23    user, found := users[req.Id]
24    if !found {
25        return nil, grpc.Errorf(404, "User not found")
26    }
27
28    return &pb.GetUserResponse{
29        Id:    req.Id,
30        Name:  user.name,
31        Email: user.email,
32    }, nil
33}
34
35func main() {
36    lis, err := net.Listen("tcp", ":50051")
37    if err != nil {
38        log.Fatalf("failed to listen: %v", err)
39    }
40    grpcServer := grpc.NewServer()
41    pb.RegisterUserServiceServer(grpcServer, &server{})
42    log.Println("🚀 gRPC server running on :50051")
43    if err := grpcServer.Serve(lis); err != nil {
44        log.Fatalf("failed to serve: %v", err)
45    }
46}

Penjelasan singkat:

• Server Go di atas menjalankan satu RPC: GetUser.
• Data disimulasikan lewat map.
• Jalankan dengan go run main.go

3. Membuat gRPC Client Sederhana di Node.js

gRPC mendukung banyak bahasa, salah satunya JavaScript. Kita pakai package @grpc/grpc-js dan @grpc/proto-loader .

3.1. Install Dependencies

1npm init -y
2npm install @grpc/grpc-js @grpc/proto-loader

3.2. Implementasi Client

File: client.js

 1const grpc = require('@grpc/grpc-js');
 2const protoLoader = require('@grpc/proto-loader');
 3
 4// Load proto file
 5const packageDefinition = protoLoader.loadSync('proto/user.proto', {
 6    keepCase: true,
 7    longs: String,
 8    enums: String,
 9    defaults: true,
10    oneofs: true,
11});
12const userProto = grpc.loadPackageDefinition(packageDefinition).user;
13
14// Create client
15const client = new userProto.UserService('localhost:50051',
16    grpc.credentials.createInsecure()
17);
18
19// Call GetUser
20const userId = "1";
21client.GetUser({ id: userId }, (error, response) => {
22    if (error) {
23        console.error('Error: ', error.message);
24        return;
25    }
26    console.log('User Profile:', response);
27});

Jalankan server Go, kemudian di terminal baru jalankan client Node.js dengan:

1node client.js

Keluaran:

1User Profile: { id: '1', name: 'Alice', email: 'alice@mail.com' }

4. Simulasi dan Tabel Perbandingan

Mari kita lihat simulasi komunikasi dan respons latency secara teoretis (jika dibandingkan dengan REST/JSON):

5. Alur Kerja gRPC pada Studi Kasus Ini

sequenceDiagram
    participant NodeClient as Client (Node.js)
    participant GoServer as Server (Go)
    NodeClient->>GoServer: GetUser(Request{ id: "1" })
    GoServer-->>NodeClient: GetUserResponse{ id: "1", name: "Alice", email: "alice@mail.com" }

sequenceDiagram
    participant NodeClient as Client (Node.js)
    participant GoServer as Server (Go)
    NodeClient->>GoServer: GetUser(Request{ id: "1" })
    GoServer-->>NodeClient: GetUserResponse{ id: "1", name: "Alice", email: "alice@mail.com" }

6. Tips untuk Development Lintas Bahasa

• Keep Your .proto in Sync
  Pastikan file Protobuf yang sama digunakan di semua bahasa. Gunakan submodule atau tools seperti buf.build .

• Error Handling
  Injeksi error code via gRPC agar client lebih mudah melakukan troubleshooting.

• Codegen Automation
  Gunakan Makefile, npm script, atau Taskfile agar regeneration code stubs otomatis saat ada perubahan schema.

Kesimpulan

Pada studi kasus ini, kita membuktikan gRPC sangat powerful untuk membangun distributed microservices lintas bahasa. Server dengan Go, client dengan Node.js — semua bicara dengan Protobuf sebagai bahasa bersama.

Selain lebih hemat bandwidth dan RAM, pipeline gRPC juga type-safe serta memudahkan proses scaling di masa depan. Next, kamu bisa mengembangkan fitur lain seperti autentikasi, interceptors, atau gunakan streaming untuk pipeline data real-time.

Enjoy ngoding, dan semoga artikel hands-on singkat ini bisa langsung kamu terapkan di project microservice-mu selanjutnya! 🚀

Referensi:

• gRPC Official Docs
• Protocol Buffers (protobuf) Guide
• @grpc/grpc-js

Tertarik eksplor lebih lanjut atau ada pertanyaan? Yuk diskusi di kolom komentar!