105. Studi Kasus: Komunikasi antara Microservice Go dan Java via Protobuf

Studi Kasus: Komunikasi antara Microservice Go dan Java via Protobuf

Pendahuluan

Microservices memungkinkan kita membangun sistem yang scalable, modular, dan dapat dikembangkan secara paralel. Sering kali, tim berbeda menggunakan bahasa pemrograman berbeda untuk implementasi service mereka, misalnya Go (Golang) dan Java. Namun, tantangan terbesar adalah bagaimana memastikan komunikasi data antar service berjalan mulus dan efisien.

Di sini, gRPC dan Protocol Buffers (Protobuf) muncul sebagai solusi. Dengan Protobuf, serialisasi data jadi jauh lebih ringan dibanding JSON/XML—mengurangi latensi dan overhead, serta memungkinkan kompatibilitas lintas bahasa.

Artikel ini membahas studi kasus nyata: Bagaimana membangun komunikasi antara satu microservice Go dan satu microservice Java, keduanya berkomunikasi via gRPC dengan data serialization menggunakan Protobuf.

Studi Kasus: Order Service (Go) dan Payment Service (Java)

Bayangkan kita punya dua service penting dalam sistem e-commerce:

1. Order Service—Ditulis dalam Go.
2. Payment Service—Ditulis dalam Java.

Order Service akan mengirim instruksi pembayaran ke Payment Service, lalu menunggu konfirmasi. Skema diilustrasikan sebagai berikut:

sequenceDiagram
    participant Go-OrderService
    participant Java-PaymentService

    Go-OrderService->>Java-PaymentService: RequestPayment(orderId, amount)
    Java-PaymentService-->>Go-OrderService: PaymentResponse(status, transactionId)

sequenceDiagram
    participant Go-OrderService
    participant Java-PaymentService

    Go-OrderService->>Java-PaymentService: RequestPayment(orderId, amount)
    Java-PaymentService-->>Go-OrderService: PaymentResponse(status, transactionId)

Desain Kontrak Data dengan Protobuf

Agar interoperabilitas terjaga, kita desain file Protobuf (payment.proto) yang merepresentasikan kontrak data, berikut endpoint servis yang disediakan oleh Payment Service.

 1// payment.proto
 2syntax = "proto3";
 3
 4package payment;
 5
 6// Request dari OrderService ke PaymentService
 7message PaymentRequest {
 8  string order_id = 1;
 9  double amount = 2;
10}
11
12// Response PaymentService ke OrderService
13message PaymentResponse {
14  string status = 1;          // "SUCCESS" or "FAIL"
15  string transaction_id = 2;  // ID transaksi jika sukses
16}
17
18// Service definition
19service PaymentService {
20  rpc MakePayment(PaymentRequest) returns (PaymentResponse);
21}

File ini nantinya akan digunakan untuk generate stub gRPC pada kedua service, baik Go maupun Java.

Generate Stub Protobuf

Langkah-langkah generate kode:

1. Install Protobuf Compiler (protoc)

1# Ubuntu
2sudo apt-get install -y protobuf-compiler
3
4# Mac
5brew install protobuf

2. Generate Stub di Go

Install plugin:

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

Generate:

1protoc --go_out=. --go-grpc_out=. payment.proto

3. Generate Stub di Java

Tambahkan dependency Maven/Gradle:

1<!-- build.gradle -->
2dependencies {
3    implementation 'io.grpc:grpc-protobuf:1.54.0'
4    implementation 'io.grpc:grpc-netty-shaded:1.54.0'
5    implementation 'io.grpc:grpc-stub:1.54.0'
6}

Generate via plugin/maven/protoc:

1protoc --java_out=. --grpc-java_out=. payment.proto

Implementasi Payment Service (Java)

Mari lihat bagaimana Payment Service mengimplementasikan service sesuai kontrak.

 1// Java PaymentServiceImpl.java
 2public class PaymentServiceImpl extends PaymentServiceGrpc.PaymentServiceImplBase {
 3    @Override
 4    public void makePayment(Payment.PaymentRequest request, StreamObserver<Payment.PaymentResponse> responseObserver) {
 5        String orderId = request.getOrderId();
 6        double amount = request.getAmount();
 7
 8        // Simulasi pembayaran berhasil
 9        Payment.PaymentResponse response = Payment.PaymentResponse.newBuilder()
10                .setStatus("SUCCESS")
11                .setTransactionId("TXN-" + orderId)
12                .build();
13
14        responseObserver.onNext(response);
15        responseObserver.onCompleted();
16    }
17}

Bootstrapping server-nya:

1public static void main(String[] args) throws IOException, InterruptedException {
2    Server server = ServerBuilder.forPort(50051)
3            .addService(new PaymentServiceImpl())
4            .build()
5            .start();
6    server.awaitTermination();
7}

Implementasi Order Service (Go)

Di sisi Go, kita build gRPC client yang melakukan request ke Payment Service.

 1// order_service.go
 2package main
 3
 4import (
 5    "context"
 6    "log"
 7    "payment"  // hasil generate dari payment.proto
 8    "google.golang.org/grpc"
 9)
10
11func main() {
12    conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
13    if err != nil {
14        log.Fatalf("Did not connect: %v", err)
15    }
16    defer conn.Close()
17    client := payment.NewPaymentServiceClient(conn)
18
19    req := &payment.PaymentRequest{
20        OrderId: "ORD-123",
21        Amount:  150000,
22    }
23
24    resp, err := client.MakePayment(context.Background(), req)
25    if err != nil {
26        log.Fatalf("Error calling MakePayment: %v", err)
27    }
28
29    log.Printf("Payment Status: %s, Transaction ID: %s", resp.GetStatus(), resp.GetTransactionId())
30}

Simulasi Komunikasi

Langkah menjalankan simulasi:

1. Jalankan Payment Service (Java, port 50051)
2. Jalankan Order Service (Go)

Order Service akan mengirim permintaan pembayaran via gRPC dan menerima respons sukses.

Output yang Diharapkan

1Payment Status: SUCCESS, Transaction ID: TXN-ORD-123

Bandingkan Efisiensi: Protobuf vs JSON

Dengan Protobuf, kelebihan yang kasat mata antara lain:

• Serialized message jauh lebih kecil.
• Parsing & serialisasi lebih cepat.
• Kontrak antar layanan jadi “typed” dan versioned.

Diagram Arsitektur

flowchart LR
    GS[Go Order Service] -- gRPC+Protobuf --> JS[Java Payment Service]

flowchart LR
    GS[Go Order Service] -- gRPC+Protobuf --> JS[Java Payment Service]

Tips Best Practices

1. Jaga backward-compatibility schema Protobuf, apalagi jika service sudah di-deploy ke production dan ada client beda versi.
2. Otomatiskan generate code di CI/CD pipeline agar setiap perubahan .proto langsung ter-reflect di stub language masing-masing.
3. Monitor latency. Protobuf memang cepat, tapi pastikan overhead networking gRPC cukup rendah.
4. Protocol versioning. Gunakan field number baru untuk penambahan fitur, hindari menghapus/mengubah arti field lama.

Kesimpulan

Perpaduan Go dan Java dengan Protobuf menunjukkan microservice lintas bahasa bisa tetap efisien, maintainable, dan future-proof. Dengan satu kontrak data, developer tinggal fokus ke logic bisnis—interoperabilitas, scale, dan kecepatan sudah terjamin oleh Protobuf dan gRPC.

Punya pengalaman membangun microservices lintas bahasa dengan Protobuf? Share di komentar!