106. Studi Kasus: Berbagi File Protobuf antara Proyek Go dan C#

Di era software modern, interoperabilitas antarlayanan menjadi sangat krusial. Salah satu solusi populer untuk pertukaran data lintas platform adalah Protobuf (Protocol Buffers). Dalam artikel ini, saya akan mengajak Anda menyelami studi kasus konkret: berbagi file Protobuf antara proyek backend Go dan aplikasi client berbasis C#. Kita akan membahas tantangan, solusi, contoh kode nyata, dan bahkan simulasi serta code flow menggunakan diagram mermaid.

Latar Belakang

Bayangkan skenario berikut: Anda bekerja di tim backend yang mengembangkan layanan utama menggunakan Go (golang). Di sisi lain, tim client membuat aplikasi desktop multiplatform berbasis C#. Keduanya perlu berkomunikasi menggunakan data yang terstruktur, efisien, dan type-safe. JSON memang fleksibel, tapi overhead serialisasinya tinggi dan type safety-nya terbatas. Di sinilah Protobuf naik panggung.

Protobuf, format serialisasi data buatan Google, menawarkan:

• Pengiriman data yang ringan (binary dan compressible)
• Backward kompatibilitas via schema versioning
• Type safety di banyak bahasa, termasuk Go dan C#
• Tooling solid: kode generator, validator, dsb.

Namun, menyelaraskan schema Protobuf dan toolchain antar dua ekosistem tidak selalu sesederhana copy-paste. Berikut studi kasusnya.

Kasus: Berbagi File Protobuf Go & C#

Kebutuhan Bisnis

1. Tim backend (Go) membuat layanan gRPC.
2. Tim client (C#) mengkonsumsi layanan gRPC & Protobuf tersebut.
3. Setiap perubahan schema harus sinkron di kedua platform.
4. Developer Go dan C# harus mendapat kode typed dari .proto yang sama.

File .proto: Desain Sederhana

Misal kita punya schema user.proto:

syntax = "proto3";

package user;

// Data user sederhana
message User {
    int32 id = 1;
    string name = 2;
    string email = 3;
}

// Request untuk mengambil user by ID
message GetUserRequest {
    int32 id = 1;
}

// Response data user
message GetUserResponse {
    User user = 1;
}

// Service untuk user
service UserService {
    rpc GetUser(GetUserRequest) returns (GetUserResponse);
}

Workflow Berbagi File Protobuf

Berikut flow yang ideal untuk berbagi schema .proto antara Go dan C#:

graph TD
    A[Developer Merancang user.proto] --> B[Commit ke Repo Protobuf]
    B --> C[CI Build: Generate Kode Go]
    B --> D[CI Build: Generate Kode C#]
    C --> E[Backend Go Menggunakan hasil generate]
    D --> F[Client C# Menggunakan hasil generate]

Keterangan:

• Repo Protobuf: Dedicated repo (atau submodul) agar .proto selalu single source of truth (SSOT).
• CI Build: Otomasi generate kode via pipeline (Github Actions/CI lainnya).

Langkah Praktis: Integrasi Protobuf Go & C#

Mari lihat proses riilnya, beserta tooling yang digunakan.

1. Strukur Repo untuk Kolaborasi

/proto-schema/
  └── user.proto
/backend-go/
  └── <kode Go>
/client-csharp/
  └── <kode C#>

Atur proto-schema/ bisa sebagai submodul atau mono-repo. Ini kunci single source agar schema tidak drift.

2. Generasi Kode Go

Install Protoc dan Plugin Go

# Install Protobuf Compiler
brew install protobuf # (macOS)
apt-get install protobuf-compiler # (Ubuntu)

# Install Plugin Go
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

Generate File Go dari .proto

protoc --go_out=./backend-go --go-grpc_out=./backend-go \
    --proto_path=./proto-schema \
    ./proto-schema/user.proto

Hasil: Tercipta file Go user.pb.go dan user_grpc.pb.go di /backend-go/user/.

Snippet: Penggunaan di Go

import (
    "context"
    userpb "backend-go/user"
)

type UserServiceServer struct {
    userpb.UnimplementedUserServiceServer
}

func (s *UserServiceServer) GetUser(ctx context.Context, req *userpb.GetUserRequest) (*userpb.GetUserResponse, error) {
    user := &userpb.User{
        Id: 42,
        Name: "Alice",
        Email: "alice@example.com",
    }
    return &userpb.GetUserResponse{User: user}, nil
}

3. Generasi Kode C#

Install Protoc + Plugin C#

• Download protoc (https://github.com/protocolbuffers/protobuf/releases)
• Tambahkan nuget package di project C#:

  dotnet add package Grpc.Tools
  dotnet add package Google.Protobuf
  dotnet add package Grpc.Net.Client
  dotnet add package Grpc.AspNetCore
  

Generate File C# dari .proto

protoc --csharp_out=./client-csharp \
       --grpc_out=./client-csharp \
       --plugin=protoc-gen-grpc=packages/Grpc.Tools/tools/windows_x64/grpc_csharp_plugin.exe \
       --proto_path=./proto-schema user.proto

Alternatif Otomatis (pada .csproj):

Tambahkan di project file:

<ItemGroup>
  <Protobuf Include="..\proto-schema\user.proto" GrpcServices="Client" />
</ItemGroup>

Build project, file C# auto generate (di obj/).

Snippet: Konsumsi gRPC di C#

using Grpc.Net.Client;
using User;

var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new UserService.UserServiceClient(channel);

var req = new GetUserRequest { Id = 42 };
var resp = await client.GetUserAsync(req);

Console.WriteLine($"User: {resp.User.Name}, {resp.User.Email}");

Simulasi: Perubahan Schema dan Konsistensi

Mari simulasikan perubahan schema dan propagasi perubahan ke kedua platform.

1. Penambahan Field di User

message User {
    int32 id = 1;
    string name = 2;
    string email = 3;
    string phone = 4; // New field!
}

Langkah Simulasi Perubahan:

Hasil: Keduanya langsung dapat user.Phone secara type-safe.

Tantangan dan Tips

1. Kompatibilitas:

• Ikuti aturan Protobuf (field number tidak boleh diubah, only add/remove optional field).
• Hindari breaking change (rename field hanya efek di kode, bukan wire).

2. Tooling/Automation:

• Buat script/pipeline CI untuk generate & publish library jika diperlukan.
• Perhatikan path import antara .proto jika lebih dari satu file.

3. Testing:

• Build integration test yang roundtrip serialisasi/deserialisasi.
• Validasi service secara e2e (Go server ↔️ C# client).

Penutup

Membagikan schema Protobuf antara proyek Go dan C# bukan sekadar masalah generate file; ini soal disiplin source of truth, automation, dan best practice. Studi kasus di atas sudah membuktikan, dengan tooling yang tepat, Anda bisa mengelola schema bersama dengan aman, tanpa perlu copy-paste, dan tanpa kehilangan type safety.

Semoga artikel ini memudahkan langkah Anda selanjutnya membangun aplikasi lintas platform, dengan Protobuf sebagai jembatan handal!

Referensi:

• Protocol Buffers Documentation (Google)
• gRPC for .NET
• gRPC for Go

Selamat mencoba, dan silakan bagikan pengalaman atau pertanyaan Anda di kolom komentar!