3 Instalasi gRPC di Go Langkah demi Langkah

Pendahuluan

Seiring berkembangnya kebutuhan aplikasi modern yang skalabel dan handal seperti microservices, Remote Procedure Call (RPC) menjadi metode komunikasi lintas proses yang semakin populer. Salah satu teknologi RPC yang powerful dan telah menjadi de facto standar industri adalah gRPC. gRPC menawarkan kecepatan tinggi, kontrak API yang eksplisit via Protobuf, serta dukungan ekosistem yang mumpuni.

Jika Anda seorang engineer Go yang ingin memulai adopsi gRPC, artikel ini akan membahas langkah demi langkah instalasi gRPC di Go, lengkap dengan contoh kode, simulasi layanan, serta diagram alur agar Anda bisa mencoba langsung di mesin sendiri.

Apa itu gRPC?

gRPC adalah framework RPC open-source dari Google. Ia menggunakan Protocol Buffers (Protobuf) sebagai Interface Definition Language (IDL) dan transport HTTP/2. Beberapa keunggulan utama:

• Performa tinggi: Penggunaan HTTP/2 memberikan multiplexing, streaming, dan binary framing.
• Konsistensi kontrak: Protobuf sebagai IDL memastikan tipe data yang konsisten.
• Interoperabilitas: Mendukung banyak bahasa pemrograman.
• Streaming data: Mendukung streaming data dua arah.

Prasyarat

Sebelum melakukan instalasi, pastikan Anda telah menyiapkan:

• Go 1.18 atau lebih baru (go version).
• Protobuf compiler (protoc).
• Git dan akses internet.

Agar tutorial tetap ringkas, gunakan sistem operasi Linux/Mac. Untuk Windows, sesuaikan path ketika diperlukan.

Langkah 1: Instalasi Protobuf Compiler (protoc)

Protobuf compiler (protoc) adalah alat untuk mengubah file .proto menjadi kode sumber Go.

Untuk Linux/MacOS

# Download release terbaru (ganti X.Y.Z dengan versi terbaru)
wget https://github.com/protocolbuffers/protobuf/releases/download/v24.0/protoc-24.0-linux-x86_64.zip
unzip protoc-24.0-linux-x86_64.zip -d $HOME/.local
export PATH="$PATH:$HOME/.local/bin"

Verifikasi instalasi:

protoc --version
# Output: libprotoc 24.0 (atau versi terbaru)

Untuk Mac (brew)

Alternatif via Homebrew (MacOS):

brew install protobuf

Langkah 2: Instalasi Plugin gRPC Go

gRPC pada Go memerlukan dua plugin:

• protoc-gen-go: Generate kode Protobuf Go
• protoc-gen-go-grpc: Generate kode stub gRPC Go

Install keduanya dengan go install:

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

# Pastikan $GOPATH/bin ada di PATH Anda
export PATH="$PATH:$(go env GOPATH)/bin"

Verifikasi:

protoc-gen-go --version
protoc-gen-go-grpc --version

Langkah 3: Inisialisasi Module Go

Buat folder proyek baru dan inisialisasi:

mkdir grpc-hello
cd grpc-hello
go mod init github.com/username/grpc-hello

Langkah 4: Tulis File .proto

Buat folder proto dan file hello.proto:

mkdir proto
touch proto/hello.proto

Isi file hello.proto:

syntax = "proto3";

package hello;

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

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Langkah 5: Generate Kode Go dari Protobuf

Jalankan perintah berikut di root project:

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

Ini akan menghasilkan dua file:

• proto/hello.pb.go - kode tipe data
• proto/hello_grpc.pb.go - kode service stub

Langkah 6: Instalasi Dependensi gRPC Go

Install gRPC library dan Protobuf Go module:

go get google.golang.org/grpc
go get google.golang.org/protobuf

Langkah 7: Implementasi Server gRPC

Buat file server.go:

package main

import (
	"context"
	"log"
	"net"

	pb "github.com/username/grpc-hello/proto"
	"google.golang.org/grpc"
)

type server struct {
	pb.UnimplementedGreeterServer
}

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

func main() {
	lis, err := net.Listen("tcp", ":50051")
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}
	s := grpc.NewServer()
	pb.RegisterGreeterServer(s, &server{})

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

Langkah 8: Implementasi Client gRPC

Buat file client.go:

package main

import (
	"context"
	"log"
	"time"

	pb "github.com/username/grpc-hello/proto"
	"google.golang.org/grpc"
)

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

	client := pb.NewGreeterClient(conn)
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()

	resp, err := client.SayHello(ctx, &pb.HelloRequest{Name: "gopher"})
	if err != nil {
		log.Fatalf("Error calling SayHello: %v", err)
	}
	log.Printf("Response: %s", resp.Message)
}

Diagram Alur: Proses Komunikasi gRPC

Mari visualisasikan alur klasik request-response antara client dan server gRPC dengan diagram Mermaid di bawah ini:

sequenceDiagram
    participant Client
    participant Server
    Client->>Server: SayHello(name="gopher")
    Server-->>Client: HelloReply(message="Halo, gopher!")

Simulasi: Uji Coba

1. Jalankan server

   go run server.go
   

   Output:

   Server listened on :50051
   

2. Jalankan client di terminal baru

   go run client.go
   

   Output:

   Response: Halo, gopher!
   

Tabel: Checklist Instalasi dan Setup

Kesimpulan

Dengan mengikuti langkah demi langkah di atas, Anda kini sudah memiliki boilerplate instalasi gRPC di Go - lengkap dari persiapan env, generate code, hingga make request secara end-to-end. Metode ini dapat dikembangkan sebagai dasar membangun microservices performant, type-safe, dan scalable menggunakan Go.

Sebagai next step, Anda bisa mengeksplorasi advanced feature gRPC seperti:

• Authentication & Authorisation,
• Bidirectional streaming,
• Interceptors & Middleware,
• Load balancing & service discovery.

Semoga artikel ini bisa menjadi referensi praktis dan komprehensif untuk Anda yang ingin membangun microservices modern di Go menggunakan gRPC. Jika ada pertanyaan atau ingin sharing pengalaman, silakan tinggalkan di kolom komentar!

Happy coding! 🚀