Struktur Proyek gRPC Sederhana di Go

Dalam pengembangan aplikasi berbasis microservices, menjaga konsistensi struktur proyek adalah kunci agar tim dapat berkolaborasi dengan lancar, mudah melakukan refactor, dan terhindar dari technical debt. Salah satu pendekatan modern dalam membangun layanan antar sistem adalah dengan gRPC — sebuah framework RPC yang cepat, ringan, dan berbasis HTTP/2 serta Protocol Buffers.

Setelah sebelumnya kita membahas instalasi dan setup gRPC di Go, kini saatnya kita menyusun struktur proyek yang terorganisir. Artikel ini akan membahas struktur direktori yang disarankan, konvensi penamaan, dan bagaimana memisahkan tanggung jawab antar layer secara bersih.

Mengapa Struktur Proyek Itu Penting?

Pernahkah Anda masuk ke proyek Go yang tidak punya struktur jelas? Semua file bercampur dalam satu folder main.go, logika bisnis bercampur dengan detail transport, dan perubahan kecil saja bisa menyebabkan merge conflict besar.

Sebaliknya, struktur proyek yang baik:

• Memudahkan navigasi kode
• Mempercepat iterasi dan testing
• Mendukung modularitas & scalability
• Mempermudah kolaborasi antar developer

Struktur Dasar Proyek gRPC

Berikut adalah contoh struktur proyek gRPC sederhana dan scalable:

grpc-hello/
├── proto/
│   └── hello.proto
├── api/
│   └── pb/
│       ├── hello.pb.go
│       └── hello\_grpc.pb.go
├── server/
│   ├── handler/
│   │   └── hello\_handler.go
│   └── main.go
├── client/
│   └── main.go
├── internal/
│   └── service/
│       └── hello\_service.go
├── go.mod
└── README.md

Mari kita bahas per direktori dan perannya:

1. proto/: Sumber Kebenaran Layanan

Di folder ini, kita menyimpan semua file .proto. File ini adalah kontrak antar layanan, mendefinisikan bentuk request, response, dan method RPC yang tersedia.

Contoh proto/hello.proto:

syntax = "proto3";

package hello;

option go_package = "santekno.com/grpc-hello/api/pb;pb";

service HelloService {
  rpc SayHello (HelloRequest) returns (HelloResponse);
}

message HelloRequest {
  string name = 1;
}

message HelloResponse {
  string message = 1;
}

2. api/pb/: Hasil Generate .proto

Setelah menjalankan perintah protoc, hasil file .pb.go dan .grpc.pb.go sebaiknya dipisahkan ke dalam folder api/pb/. Ini memudahkan Anda membedakan mana file auto-generated dan mana yang ditulis developer.

Command untuk generate:

protoc --go_out=api --go-grpc_out=api proto/hello.proto

3. server/: Entry Point dan Handler Server

Semua logic terkait server gRPC Anda diletakkan di sini. File main.go berfungsi sebagai entry point server, sedangkan handler berisi implementasi dari interface HelloServiceServer.

Contoh server/main.go:

func main() {
  lis, _ := net.Listen("tcp", ":50051")
  grpcServer := grpc.NewServer()
  pb.RegisterHelloServiceServer(grpcServer, handler.NewHelloHandler())
  grpcServer.Serve(lis)
}

4. server/handler/: Adapter RPC

Handler bertanggung jawab mengadaptasi RPC ke dalam pemanggilan service.

Contoh:

type HelloHandler struct {
  svc service.HelloService
}

func (h *HelloHandler) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloResponse, error) {
  return h.svc.SayHello(ctx, req)
}

5. internal/service/: Logika Bisnis

Semua proses bisnis diletakkan di dalam folder ini, agar terpisah dari transport layer (gRPC).

type HelloService interface {
  SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloResponse, error)
}

6. client/: Implementasi Client

Untuk testing manual atau integrasi ke sistem lain, client gRPC dibuat di folder ini.

func main() {
  conn, _ := grpc.Dial(":50051", grpc.WithInsecure())
  client := pb.NewHelloServiceClient(conn)
  res, _ := client.SayHello(context.Background(), &pb.HelloRequest{Name: "Budi"})
  fmt.Println(res.Message)
}

Praktik Terbaik

• Gunakan internal/ untuk membatasi scope akses dependency
• Pisahkan file proto dan hasil generate
• Hindari mencampur handler dan service
• Gunakan go_package pada .proto untuk kontrol path
• Commit file .proto dan hasil generate ke VCS

Penutup

Struktur proyek adalah fondasi dari kualitas software Anda. Dengan struktur yang baik, Anda tidak hanya membuat kode lebih rapi, tapi juga membuka jalan bagi praktik DevOps, CI/CD, testing otomatis, dan dokumentasi API.

gRPC bukan hanya sekadar teknologi RPC — ia adalah cara baru untuk berpikir soal kontrak layanan dan arsitektur yang evolusioner. Dengan struktur proyek yang solid, Anda siap membangun sistem terdistribusi yang reliable dan maintainable.

Semoga panduan ini membantu Anda membangun proyek gRPC yang lebih kuat, rapi, dan profesional.

Happy coding 🚀