11 Membuat Server gRPC Pertama Anda

Membangun sistem komunikasi antar layanan yang efisien adalah esensial di era microservices. gRPC hadir sebagai salah satu solusi modern yang powerful dan scalable. Dengan protokol berbasis HTTP/2 dan serialization Protobuf, gRPC mendukung komunikasi yang cepat, ringan, dan kuat lintas bahasa pemrograman. Di artikel ini, saya akan membimbing Anda—dari engineer pemula hingga intermediate—untuk membuat server gRPC pertama Anda menggunakan Go.

Artikel ini dirancang praktis, step-by-step, disertai contoh kode kerja, simulasi request-response, dan diagram alur. Mari kita mulai!

Apa Itu gRPC?

gRPC adalah framework RPC (Remote Procedure Call) open source dari Google, berjalan di atas HTTP/2, memanfaatkan Protobuf untuk serialisasi data. Dengan keunggulan seperti streaming, authentication, load balancing, gRPC jadi pilihan utama modern Inter Process Communication (IPC).

Arsitektur High-Level gRPC

Agar semakin jelas, berikut adalah diagram alur bagaimana gRPC client dan server berinteraksi:

graph TD
    A[Client] -- Request (Protobuf) --> B[gRPC Server]
    B -- Response (Protobuf) --> A

1. Client membuat permintaan ke server menggunakan “stub” (kode yang digenerate dari Protobuf).
2. Server menerima permintaan, memproses, dan merespon kembali ke client.
3. Semua data ditransmisikan dalam format Protobuf melalui protokol HTTP/2.

Prasyarat Lingkungan

Sebelum ngoding, pastikan Anda sudah menginstal:

• Go (versi >= 1.16)
• protoc (Protocol Buffer compiler) di PATH
• protoc-gen-go dan protoc-gen-go-grpc plugins
• Editor teks favorit (VSCode, GoLand, dll)

Instalasi dengan command berikut:

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

1. Mendefinisikan Servis gRPC dengan Protobuf

Ayo mulai dengan service yang sederhana. Kita akan membuat Greeter, punya satu method: SayHello.

Buat file bernama helloworld.proto:

syntax = "proto3";

package helloworld;

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

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Penjelasan:

• service Greeter mendefinisikan layanan.
• rpc SayHello adalah method remote yang menerima HelloRequest dan mengembalikan HelloReply.

2. Generate Kode Go dari Protobuf

Jalankan perintah generate:

protoc --go_out=. --go-grpc_out=. helloworld.proto

Ini akan menghasilkan dua file:

• helloworld.pb.go (data message Go type)
• helloworld_grpc.pb.go (interface server dan client)

3. Implementasi Server gRPC

Buat file server.go, lalu tulis implementasi berikut:

package main

import (
    "context"
    "log"
    "net"

    "google.golang.org/grpc"
    pb "path/to/helloworld" // import sesuai lokasi file pb.go
)

type server struct {
    pb.UnimplementedGreeterServer
}

// Implementasi method `SayHello`
func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
    log.Printf("Received: %v", in.GetName())
    return &pb.HelloReply{Message: "Hello " + in.GetName()}, nil
}

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    grpcServer := grpc.NewServer()
    pb.RegisterGreeterServer(grpcServer, &server{})
    log.Printf("gRPC server started at :50051")
    if err := grpcServer.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

Poin Kunci:

• Fungsi utama membuka port TCP :50051.
• pb.RegisterGreeterServer mendaftarkan service.
• Implementasi method SayHello menyapa nama dari request client.

Simulasi: Contoh Request/Response

4. Membuat Client sederhana (Opsional)

Agar lebih nyata, kita buat client sederhana di Go:

package main

import (
    "context"
    "log"
    "time"

    "google.golang.org/grpc"
    pb "path/to/helloworld"
)

func main() {
    conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure(), grpc.WithBlock())
    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: "Andi"})
    if err != nil {
        log.Fatalf("could not greet: %v", err)
    }
    log.Printf("Greeting: %s", r.GetMessage())
}

Output di Client:

Greeting: Hello Andi

Output di Server:

gRPC server started at :50051
Received: Andi

Diagram Alur RPC

Bagaimana eksekusi berproses—mulai dari client call hingga server response:

sequenceDiagram
    participant C as Client
    participant S as gRPC Server

    C->>S: SayHello(name="Andi")
    S-->>S: Proses SayHello()
    S-->>C: HelloReply(message="Hello Andi")

Beberapa Tips Best Practice

Kesimpulan

Congrats! Anda telah berhasil membangun server gRPC Anda sendiri dari nol. Kita telah memulai dari mendefinisikan service di Protobuf, generate kode, implementasi server, hingga menyiapkan client untuk testing.

gRPC adalah tool yang powerful untuk membangun sistem yang scalable dan lintas platform. Langkah berikutnya, Anda bisa bereksperimen dengan streaming, authentication, dan load balancing.

Jika Anda ingin berkolaborasi atau berbagi pengalaman seputar gRPC di production, feel free drop komentar di bawah. Happy coding, engineer!

Referensi:

• gRPC.io Official Documentation
• Protocol Buffers Language Guide (proto3)