4 Struktur Proyek gRPC Sederhana di Go

gRPC semakin populer sebagai pilihan protokol Remote Procedure Call modern, terutama dalam membangun sistem microservices yang efisien dan scalable. Salah satu keunggulannya adalah dukungan penuh terhadap berbagai bahasa pemrograman, performa yang tinggi dengan HTTP/2, serta mekanisme serialisasi pesan yang andal via Protocol Buffers (protobuf).

Pada artikel ini, saya akan membahas secara praktis mengenai struktur proyek gRPC yang sederhana di Go (Golang). Pembahasan ini cocok untuk kamu yang sedang memulai dengan gRPC di Go, maupun developer yang ingin memperkaya wawasan tentang penataan proyek agar tetap clean, scalable, dan mudah dikembangkan.

Pendahuluan: Kenapa Perlu Memikirkan Struktur Proyek?

Seringkali, kita tergoda untuk langsung “ngoprek” dan membuat semuanya dalam satu file. Namun, seiring bertambahnya layanan, complexitas project pun meningkat. Proyek yang tidak terstruktur dengan baik akan menyulitkan maintenance, colab dengan tim, hingga scaling.

Struktur proyek yang baik dapat:

1. Memisahkan tanggung jawab kode (separation of concerns).
2. Memudahkan testing dan integrasi.
3. Membantu onboarding developer baru.
4. Mempercepat pengembangan layanan ke depannya.

Mari kita lihat best practice-nya.

Struktur Dasar Proyek gRPC di Go

Struktur berikut adalah salah satu pendekatan standar yang mudah dipahami untuk proyek gRPC sederhana. Ini sudah cukup untuk memulai, tapi fleksibel untuk dikembangkan menjadi lebih kompleks ke depannya.

grpc-simple-go/
├── proto/
│   └── hello.proto
├── pb/
│   └── hello.pb.go
├── server/
│   ├── handler.go
│   └── main.go
├── client/
│   └── main.go
├── go.mod
└── README.md

Mari kita bahas satu per satu direktori dan filenya:

Step-by-step Membuat Proyek

1. Buat File Protobuf Definition

Semua komunikasi gRPC dimulai dari file .proto. Berikut contoh file proto/hello.proto:

syntax = "proto3";

package hello;

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

2. Generate Kode Go dari File Protobuf

Instal plugin protoc-gen-go dan protoc-gen-go-grpc (bisa skip jika sudah pernah install):

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

Generate kode:

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

File hasil generate (hello.pb.go dan hello_grpc.pb.go) otomatis masuk ke folder /pb.

3. Implementasi Server gRPC

Struktur folder server/:

server/
├── handler.go
└── main.go

a. handler.go

File ini berisi implementasi logic service yang telah didefinisikan di proto.

// server/handler.go
package server

import (
    context "context"
    "grpc-simple-go/pb"
)

type GreeterServer struct {
    pb.UnimplementedGreeterServer
}

func (s *GreeterServer) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloReply, error) {
    return &pb.HelloReply{
        Message: "Hello, " + req.Name + "!",
    }, nil
}

b. main.go

Kode untuk menjalankan server:

// server/main.go
package main

import (
    "log"
    "net"

    "google.golang.org/grpc"
    "grpc-simple-go/pb"
    "grpc-simple-go/server"
)

func main() {
    lis, err := net.Listen("tcp", ":8080")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }

    s := grpc.NewServer()
    pb.RegisterGreeterServer(s, &server.GreeterServer{})

    log.Println("Server listening on :8080...")
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

4. Implementasi Client gRPC

Struktur folder client/:

client/
└── main.go

Kode client memanggil metode SayHello pada server.

// client/main.go
package main

import (
    "context"
    "log"
    "time"

    "google.golang.org/grpc"
    "grpc-simple-go/pb"
)

func main() {
    conn, err := grpc.Dial("localhost:8080", grpc.WithInsecure())
    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()

    c := pb.NewGreeterClient(conn)

    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()
    r, err := c.SayHello(ctx, &pb.HelloRequest{Name: "Gopher"})
    if err != nil {
        log.Fatalf("could not greet: %v", err)
    }
    log.Printf("Greeting: %s", r.GetMessage())
}

Simulasi Eksekusi

Misalkan kita menjalankan server (go run server/main.go), kemudian client (go run client/main.go). Output pada client akan seperti berikut:

2024/06/08 Greeting: Hello, Gopher!

Diagram Alur

Supaya makin jelas, berikut diagram alur request dari client ke server gRPC menggunakan Mermaid:

sequenceDiagram
    participant Client
    participant Server

    Client->>Server: SayHello(HelloRequest)
    Server-->>Client: HelloReply ("Hello, {name}!")

Penjelasan Folder dan Dependency

Best Practice

• Pisahkan proto dan hasil generate: Agar mudah integrasi CI/CD.
• Gunakan package logic: Project akan scaling, logic bisnis bisa pecah lagi jadi /internal/handler/, /usecase/, dll.
• Dokumentasikan alur komunikasi: Sequence diagram seperti di atas sangat membantu kolaborasi tim.

Kesimpulan

Struktur sederhana di atas sangat mudah dikembangkan: ingin menambah service? Tinggal tambahkan proto+handler baru. Ingin pisahkan repository logic dan delivery? Refaktor sedikit, sudah siap. Dengan struktur yang clean seperti ini, proyek Go-mu dengan gRPC akan lebih maintainable dan scalable.

Jangan lupa, kamu juga bisa lihat berbagai template open source seperti di grpc-ecosystem atau populer seperti golang-standards/project-layout sebagai inspirasi struktur lanjutan.

Selamat mencoba! 🚀

Referensi:

• Go gRPC Quickstart
• golang-standards/project-layout
• Official Protocol Buffers