78. Men-deploy gRPC Service di Docker

title: “78. Men-deploy gRPC Service di Docker” date: 2024-06-13 author: Software Engineer Senior

gRPC belakangan menjadi semakin populer sebagai salah satu teknologi RPC (Remote Procedure Call) yang cepat, efisien, dan sangat cocok digunakan pada arsitektur berbasis microservices. Namun, membangun gRPC Service saja tidak cukup tanpa tahu cara packaging dan deployment yang baik, terutama ke dalam lingkungan tercontainerisasi seperti Docker.

Di artikel ini saya akan membagikan pengalaman dan best-practice untuk men-deploy gRPC Service menggunakan Docker, dilengkapi dengan contoh kode, simulasi, tabel, dan diagram alur deployment via mermaid. Kita akan menggunakan bahasa Go sebagai contoh implementasi, karena sintaks yang jelas dan kecepatan build-nya, tapi konsepnya sangat bisa diterapkan pada stack manapun (Python, Java, Node.js, dsb).

1. Mengenal gRPC dan Docker secara Singkat

Apa itu gRPC?

gRPC adalah framework open-source yang dikembangkan Google, memungkinkan aplikasi berkomunikasi antar perangkat dengan definisi API (interaktif, berbasis Protobuf) yang efisien. Kelebihan gRPC antara lain:

• Mendukung Multilanguage (Go, Java, C#, Python, dsb)
• Fast onder-the-hood HTTP/2 (bukan HTTP/1.1)
• Mendukung streaming bidirectional dan unary
• Mendukung Autogenerate Stubs dari *.proto

Apa itu Docker?

Docker adalah tools containerization yang memudahkan kita untuk mengemas aplikasi beserta seluruh dependensi agar dapat berjalan konsisten di mana saja—di laptop, server, atau cloud tanpa khawatir dependency hell.

2. Struktur Proyek Minimal

Sebelum masuk ke deployment, berikut struktur minimal sebuah proyek gRPC berbasis Go yang akan kita gunakan:

 1grpc-docker-demo/
 2│
 3├── proto/
 4│   └── hello.proto
 5├── server/
 6│   └── main.go
 7├── client/
 8│   └── main.go
 9├── Dockerfile
10└── go.mod

3. Menyiapkan Service gRPC Sederhana

Langkah 1: Definisikan Service di Protobuf

Buat file proto/hello.proto

 1syntax = "proto3";
 2
 3package helloworld;
 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 2: Generate Code Go

Instal protoc dan plugin Go:

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

Generate kode:

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

Langkah 3: Implementasi Server

Buat file server/main.go:

 1package main
 2
 3import (
 4  "context"
 5  "log"
 6  "net"
 7
 8  pb "grpc-docker-demo/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: "Hello " + 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("gRPC server listening on :50051")
29  if err := s.Serve(lis); err != nil {
30    log.Fatalf("failed to serve: %v", err)
31  }
32}

4. Membuat Dockerfile Untuk gRPC Service

Agar aplikasi Go kita bisa berjalan di mana saja, kita kemas menggunakan Docker. Berikut contoh Dockerfile yang cukup optimal:

 1# Stage 1: Build binary
 2FROM golang:1.21-alpine AS builder
 3WORKDIR /app
 4
 5COPY go.mod go.sum ./
 6RUN go mod download
 7
 8COPY . .
 9RUN CGO_ENABLED=0 GOOS=linux go build -o server ./server
10
11# Stage 2: Final image
12FROM scratch
13WORKDIR /root/
14
15COPY --from=builder /app/server .
16COPY proto/ ./proto/
17EXPOSE 50051
18ENTRYPOINT ["./server"]

5. Build & Simulasi Deploy Docker

Simulasi Build

Jalankan perintah berikut di root folder:

1docker build -t grpc-docker-demo:latest .

Menjalankan Container

1docker run -p 50051:50051 grpc-docker-demo:latest

Service sekarang sudah bisa diakses di localhost:50051 (untuk client gRPC).

6. Testing Lokal Dengan gRPC Client

Jika ingin menguji lewat client sederhana:

 1package main
 2
 3import (
 4  "context"
 5  "log"
 6  "time"
 7
 8  pb "grpc-docker-demo/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("did not connect: %v", err)
16  }
17  defer conn.Close()
18  c := pb.NewGreeterClient(conn)
19
20  ctx, cancel := context.WithTimeout(context.Background(), time.Second)
21  defer cancel()
22  r, err := c.SayHello(ctx, &pb.HelloRequest{Name: "Dunia"})
23  if err != nil {
24    log.Fatalf("could not greet: %v", err)
25  }
26  log.Printf("Server Response: %s", r.Message)
27}

7. Deployment Flow Diagram

Berikut adalah diagram alur deployment gRPC Service di Docker:

flowchart TD
    A[dev: Implementasi gRPC Service]
    B[Build Docker Image]
    C[Test Lokal Docker Run]
    D[Push ke Docker Registry]
    E[Deploy ke Server/Cloud (k8s, ECS, dll)]
    A --> B
    B --> C
    C --> D
    D --> E

flowchart TD
    A[dev: Implementasi gRPC Service]
    B[Build Docker Image]
    C[Test Lokal Docker Run]
    D[Push ke Docker Registry]
    E[Deploy ke Server/Cloud (k8s, ECS, dll)]
    A --> B
    B --> C
    C --> D
    D --> E

8. Tabel Perbandingan: Docker vs Native Run

9. Tips Profesional Deploy gRPC di Docker

Beberapa best-practices yang wajib diperhatikan:

• Gunakan multi-stage build untuk mengurangi size image
• Nonaktifkan CGO (CGO_ENABLED=0) supaya binary lebih portable
• Pisahkan credentials/secrets dari image, gunakan ENV variable atau secret manager
• Automate build/test dengan CI/CD (contoh: GitHub Actions, GitLab CI)
• Monitoring & Health Check: gRPC tidak expose HTTP endpoint, gunakan sidecar/liveness probe custom

10. Kesimpulan

Men-deploy gRPC Service ke dalam Docker bukan hanya praktik modern, tetapi juga menjamin aplikasi kita siap untuk scale up ke production environment modern seperti Kubernetes atau cloud platform lain. Prosesnya cukup straightforward jika project terstruktur dengan baik, dependencies tertata, dan kita disiplin mengikuti best-practice.

Dengan langkah-langkah di atas, Anda sudah bisa mengemas, menjalankan, dan men-deploy gRPC Service secara konsisten di mana pun.

Selamat mencoba, dan semoga service Anda mulus tanpa drama dependency lagi!

Referensi:

• Official gRPC Go Docs
• Mengoptimalkan Layer di Dockerfile
• Production Best Practice: gRPC Health Checking

Jika Anda ingin membahas topik seputar monitoring, observability, atau CI/CD untuk layanan gRPC di Docker, silakan request di kolom komentar!