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

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

Verifikasi instalasi:

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

Untuk Mac (brew)

Alternatif via Homebrew (MacOS):

1brew 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:

1go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
2go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
3
4# Pastikan $GOPATH/bin ada di PATH Anda
5export PATH="$PATH:$(go env GOPATH)/bin"

Verifikasi:

1protoc-gen-go --version
2protoc-gen-go-grpc --version

Langkah 3: Inisialisasi Module Go

Buat folder proyek baru dan inisialisasi:

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

Langkah 4: Tulis File .proto

Buat folder proto dan file hello.proto:

1mkdir proto
2touch proto/hello.proto

Isi file hello.proto:

 1syntax = "proto3";
 2
 3package hello;
 4
 5service Greeter {
 6  rpc SayHello (HelloRequest) returns (HelloReply) {}
 7}
 8
 9message HelloRequest {
10  string name = 1;
11}
12
13message HelloReply {
14  string message = 1;
15}

Langkah 5: Generate Kode Go dari Protobuf

Jalankan perintah berikut di root project:

1protoc --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:

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

Langkah 7: Implementasi Server gRPC

Buat file server.go:

 1package main
 2
 3import (
 4	"context"
 5	"log"
 6	"net"
 7
 8	pb "github.com/username/grpc-hello/proto"
 9	"google.golang.org/grpc"
10)
11
12type server struct {
13	pb.UnimplementedGreeterServer
14}
15
16func (s *server) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloReply, error) {
17	return &pb.HelloReply{Message: "Halo, " + req.Name + "!"}, nil
18}
19
20func main() {
21	lis, err := net.Listen("tcp", ":50051")
22	if err != nil {
23		log.Fatalf("failed to listen: %v", err)
24	}
25	s := grpc.NewServer()
26	pb.RegisterGreeterServer(s, &server{})
27
28	log.Println("Server listened on :50051")
29	if err := s.Serve(lis); err != nil {
30		log.Fatalf("failed to serve: %v", err)
31	}
32}

Langkah 8: Implementasi Client gRPC

Buat file client.go:

 1package main
 2
 3import (
 4	"context"
 5	"log"
 6	"time"
 7
 8	pb "github.com/username/grpc-hello/proto"
 9	"google.golang.org/grpc"
10)
11
12func main() {
13	conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
14	if err != nil {
15		log.Fatalf("Could not connect: %v", err)
16	}
17	defer conn.Close()
18
19	client := pb.NewGreeterClient(conn)
20	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
21	defer cancel()
22
23	resp, err := client.SayHello(ctx, &pb.HelloRequest{Name: "gopher"})
24	if err != nil {
25		log.Fatalf("Error calling SayHello: %v", err)
26	}
27	log.Printf("Response: %s", resp.Message)
28}

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!")

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

Simulasi: Uji Coba

1. Jalankan server
   bash

   Salin

   1go run server.go

   Output:
   text

   Salin

   1Server listened on :50051

2. Jalankan client di terminal baru
   bash

   Salin

   1go run client.go

   Output:
   text

   Salin

   1Response: 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! 🚀