71. Integrasi gRPC dengan REST Gateway (grpc-gateway)

Di era modern pengembangan API, dua arsitektur sering menjadi perdebatan panas: REST dan gRPC. REST (Representational State Transfer) sudah menjadi standar default frontend-backend komunikasi via HTTP, sedangkan gRPC (Google Remote Procedure Call) dikenal dengan performa, efisiensi, dan kemudahan untuk menghubungkan layanan antar server, terutama pada sistem berskala mikroservis.

Namun, di banyak organisasi, biasanya ada kebutuhan untuk menyediakan API publik berbasis REST dan komunikasi internal antar layanan yang lebih optimal menggunakan gRPC. Mentranslasi antara REST dan gRPC secara manual jelas tidak efisien dan menambah beban maintenance codebase. Di sinilah grpc-gateway hadir sebagai solusi otomatis.

Pada artikel ini, saya akan membahas integrasi gRPC dengan REST Gateway memakai grpc-gateway, lengkap dengan contoh kode, diagram alur, hingga simulasi request-response. Mari kita mulai dari teori hingga penerapannya!

Kenapa Perlu Integrasi REST dan gRPC?

Sebelum masuk ke implementasi, mari pahami dulu alasan pentingnya integrasi ini:

Banyak tim ingin kedua keunggulan ini tanpa menulis dua implementasi terpisah. Dengan grpc-gateway, kita bisa menyediakan service yang sama melalui gRPC dan REST/JSON, serta menghasilkan dokumentasi OpenAPI secara otomatis.

Bagaimana grpc-gateway Bekerja?

Mari kita visualisasikan prosesnya dengan diagram berikut:

graph TD;
    A[Client REST (HTTP/JSON)] -->|Request| B[grpc-gateway (Transcoder)];
    B -->|gRPC call (Protobuf)| C[gRPC Server];
    C -->|Response (Protobuf)| B;
    B -->|Response (HTTP/JSON)| A;

graph TD;
    A[Client REST (HTTP/JSON)] -->|Request| B[grpc-gateway (Transcoder)];
    B -->|gRPC call (Protobuf)| C[gRPC Server];
    C -->|Response (Protobuf)| B;
    B -->|Response (HTTP/JSON)| A;

Penjelasan:

1. REST Client mengirim permintaan HTTP (biasanya JSON).
2. grpc-gateway menerima, mentranslasi ke gRPC (Protobuf), dan meneruskan ke server gRPC asli.
3. gRPC Server memproses permintaan dan mengirim response biner/Protobuf.
4. grpc-gateway mentranslasi kembali ke JSON dan mengirim ke client REST.

Dengan pendekatan ini, Anda bisa menulis logika business one codebase, namun expose dua API berbeda (gRPC & RESTful) secara otomatis!

Instalasi dan Setup grpc-gateway

Kita akan gunakan Go (bahasa utama grpc-gateway), tapi konsepnya serupa di bahasa lain.

1. Install Protoc dan Plugin grpc-gateway

 1# Install protoc (compiler protobuf)
 2sudo apt install protobuf-compiler
 3
 4# Install Go plugin untuk grpc, gateway, dan openapiv2
 5go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
 6go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
 7go install github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-grpc-gateway@latest
 8go install github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2@latest
 9
10# Pastikan $GOPATH/bin sudah di $PATH
11export PATH="$PATH:$(go env GOPATH)/bin"

Contoh Implementasi: Simple User API

1. Definisikan Protobuf Service

File: user.proto

 1syntax = "proto3";
 2
 3package user;
 4
 5option go_package = "github.com/yourorg/yourrepo/gen/user;user";
 6
 7import "google/api/annotations.proto";
 8
 9service UserService {
10    rpc GetUser(GetUserRequest) returns (UserResponse) {
11        option (google.api.http) = {
12            get: "/v1/users/{id}"
13        };
14    }
15}
16
17message GetUserRequest {
18    string id = 1;
19}
20
21message UserResponse {
22    string id = 1;
23    string name = 2;
24    string email = 3;
25}

Perhatikan annotation google.api.http: inilah kunci agar grpc-gateway tahu endpoint HTTP yang harus diskonversi ke RPC call.

2. Generate Code

1protoc -I. \
2    -I $GOPATH/pkg/mod/github.com/grpc-ecosystem/grpc-gateway@v2.*/third_party/googleapis \
3    --go_out=. --go_opt=paths=source_relative \
4    --go-grpc_out=. --go-grpc_opt=paths=source_relative \
5    --grpc-gateway_out=. --grpc-gateway_opt=paths=source_relative \
6    user.proto

3. Implementasi Server gRPC

File: server.go

 1package main
 2
 3import (
 4    "context"
 5    "log"
 6    "net"
 7
 8    "google.golang.org/grpc"
 9    pb "github.com/yourorg/yourrepo/gen/user"
10)
11
12type server struct {
13    pb.UnimplementedUserServiceServer
14}
15
16func (s *server) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.UserResponse, error) {
17    return &pb.UserResponse{
18        Id:    req.Id,
19        Name:  "Alice",
20        Email: "alice@example.com",
21    }, nil
22}
23
24func main() {
25    lis, err := net.Listen("tcp", ":50051")
26    if err != nil {
27        log.Fatalf("failed to listen: %v", err)
28    }
29    s := grpc.NewServer()
30    pb.RegisterUserServiceServer(s, &server{})
31    log.Println("gRPC server listening on :50051")
32    if err := s.Serve(lis); err != nil {
33        log.Fatalf("failed to serve: %v", err)
34    }
35}

4. Implementasi REST Gateway

File: gateway.go

 1package main
 2
 3import (
 4    "context"
 5    "log"
 6    "net/http"
 7    "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 8    "google.golang.org/grpc"
 9    pb "github.com/yourorg/yourrepo/gen/user"
10)
11
12func main() {
13    ctx := context.Background()
14    mux := runtime.NewServeMux()
15    opts := []grpc.DialOption{grpc.WithInsecure()} // Insecure for dev
16
17    err := pb.RegisterUserServiceHandlerFromEndpoint(
18        ctx, mux, "localhost:50051", opts,
19    )
20    if err != nil {
21        log.Fatalf("Failed to register gateway: %v", err)
22    }
23
24    log.Println("REST gateway listening on :8080")
25    http.ListenAndServe(":8080", mux)
26}

5. Simulasi Request: JSON ke gRPC Otomatis

Misalnya kita request:

1curl http://localhost:8080/v1/users/1234

Response yang akan didapat:

1{
2    "id": "1234",
3    "name": "Alice",
4    "email": "alice@example.com"
5}

1. REST client (curl) request ke gateway
2. Gateway translate ke gRPC request ke port 50051
3. Server gRPC proses dan balas protobuf
4. Gateway translate ke JSON response dan kembalikan ke client

Kelebihan dan Keterbatasan grpc-gateway

Kelebihan:

• Tidak perlu implementasi dua service berbeda (REST & gRPC).
• Mendukung path, query, request body sesuai OpenAPI.
• Bisa generate spesifikasi OpenAPI otomatis.
• Sangat efisien pada migrasi monolith ke mikroservis atau hybrid api.

Keterbatasan:

• Tidak semua fitur gRPC bisa di-expose via HTTP/JSON (misal bi-directional streaming belum 100% didukung).
• Tambah layer berarti potensi latency bertambah.
• Maintenansi mapping annotation di Protobuf.

Studi Kasus: Migrasi Bertahap ke gRPC

Salah satu pola migrasi yang sering digunakan:

• Langkah 1: Tulis ulang/migrasi business logic di service gRPC.
• Langkah 2: Sediakan gRPC API untuk komunikasi internal.
• Langkah 3: Expose REST/JSON untuk external consumer (frontend, mobile) via grpc-gateway.
• Langkah 4: Matikan REST API original setelah consumer migrasi ke baru.

Keuntungan pola ini – No breaking change di sisi client.

Kesimpulan

Mengintegrasikan gRPC dengan REST Gateway (grpc-gateway) merupakan solusi jembatan antara dunia lama REST dan dunia baru gRPC. Pendekatan ini sangat ideal untuk organisasi yang ingin modernisasi API tanpa mengorbankan compatibility maupun produktivitas developer.

Sebagai engineer, memanfaatkan alat seperti grpc-gateway bukan hanya soal efisiensi – ini juga tentang menurunkan technical debt dan memberikan seamless developer experience untuk tim lintas teknologi.

Jangan ragu eksplorasi grpc-gateway lebih lanjut, misal dengan authentication, custom error handling, atau generate documentasi OpenAPI secara otomatis. Happy coding, salam refactor!

Referensi:

• Official grpc-gateway Guide
• Contoh kode pada Github
• gRPC vs REST: When to Use Which?