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:

 1syntax = "proto3";
 2
 3package user;
 4
 5// Data user sederhana
 6message User {
 7    int32 id = 1;
 8    string name = 2;
 9    string email = 3;
10}
11
12// Request untuk mengambil user by ID
13message GetUserRequest {
14    int32 id = 1;
15}
16
17// Response data user
18message GetUserResponse {
19    User user = 1;
20}
21
22// Service untuk user
23service UserService {
24    rpc GetUser(GetUserRequest) returns (GetUserResponse);
25}

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]

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

1/proto-schema/
2  └── user.proto
3/backend-go/
4  └── <kode Go>
5/client-csharp/
6  └── <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

1# Install Protobuf Compiler
2brew install protobuf # (macOS)
3apt-get install protobuf-compiler # (Ubuntu)
4
5# Install Plugin Go
6go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
7go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

Generate File Go dari .proto

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

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

Snippet: Penggunaan di Go

 1import (
 2    "context"
 3    userpb "backend-go/user"
 4)
 5
 6type UserServiceServer struct {
 7    userpb.UnimplementedUserServiceServer
 8}
 9
10func (s *UserServiceServer) GetUser(ctx context.Context, req *userpb.GetUserRequest) (*userpb.GetUserResponse, error) {
11    user := &userpb.User{
12        Id: 42,
13        Name: "Alice",
14        Email: "alice@example.com",
15    }
16    return &userpb.GetUserResponse{User: user}, nil
17}

3. Generasi Kode C#

Install Protoc + Plugin C#

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

  Salin

  1dotnet add package Grpc.Tools
  2dotnet add package Google.Protobuf
  3dotnet add package Grpc.Net.Client
  4dotnet add package Grpc.AspNetCore

Generate File C# dari .proto

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

Alternatif Otomatis (pada .csproj):

Tambahkan di project file:

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

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

Snippet: Konsumsi gRPC di C#

 1using Grpc.Net.Client;
 2using User;
 3
 4var channel = GrpcChannel.ForAddress("https://localhost:5001");
 5var client = new UserService.UserServiceClient(channel);
 6
 7var req = new GetUserRequest { Id = 42 };
 8var resp = await client.GetUserAsync(req);
 9
10Console.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

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

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!