63. gRPC Health Checking Standar

63. gRPC Health Checking Standar: Modern Approach for Microservices Reliability

Ketika membangun sistem terdistribusi berbasis microservices, memastikan setiap layanan berjalan dengan baik adalah hal krusial. Kegagalan satu service bisa berdampak ke keseluruhan sistem. Untuk itu, health check menjadi fondasi penting. Namun, bagaimana cara melakukan health check pada service berbasis gRPC, protokol RPC modern pilihan para engineer?

Di artikel ini, saya akan bahas standar gRPC Health Checking — termasuk konsep, implementasi, simulasi, contoh kode, dan best practice yang sudah banyak diadopsi industri.

Kenapa Health Check pada gRPC Penting?

Pada aplikasi tradisional HTTP/REST, health check biasanya cukup mudah: expose endpoint seperti GET /healthz yang mengembalikan status layanan (200 OK, 503 Service Unavailable, dst). Load balancer atau orchestrator seperti Kubernetes lalu menggunakan endpoint tersebut untuk memantau dan men-deploy ulang service yang gagal.

Namun, pada arsitektur gRPC, service hanya expose port binary, bukan endpoint HTTP. Tidak ada standar universal untuk health check seperti halnya pada REST API. Tanpa health check, orchestrator tidak tahu kapan harus mengganti atau memperbaiki instance service.

Di sinilah gRPC Health Checking Protocol (atau Health Checking Standard) berperan penting.

Standar gRPC Health Checking

gRPC Health Checking Protocol adalah standar terbuka untuk memeriksa status layanan gRPC. Standar ini didefinisikan sebagai sebuah service dengan nama grpc.health.v1.Health. Service ini memiliki method-method sederhana, yang memudahkan klien (load balancer, sidecar, orchestrator) untuk mengecek status service.

Definisi Protobuf

Berikut adalah definisi service health-check menurut protokol standar:

 1syntax = "proto3";
 2
 3package grpc.health.v1;
 4
 5service Health {
 6    // Cek status satu service
 7    rpc Check(HealthCheckRequest) returns (HealthCheckResponse);
 8
 9    // Streaming status secara kontinu
10    rpc Watch(HealthCheckRequest) returns (stream HealthCheckResponse);
11}
12
13message HealthCheckRequest {
14    string service = 1;
15}
16
17message HealthCheckResponse {
18    enum ServingStatus {
19        UNKNOWN = 0;
20        SERVING = 1;
21        NOT_SERVING = 2;
22        SERVICE_UNKNOWN = 3;  // status untuk service yang belum diketahui, hanya digunakan oleh Watch.
23    }
24    ServingStatus status = 1;
25}

1. Check: Klien mengirimkan nama service, mendapat status SERVING/NOT_SERVING.
2. Watch: Klien bisa subscribe perubahan status secara realtime (misal, untuk load balancer/sidecar).

Tabel status:

Diagram Alur Health Checking

Mari visualisasikan proses health check dengan diagram mermaid berikut:

sequenceDiagram
    participant Orchestrator as Orchestrator / Load Balancer
    participant Service as gRPC Service
    Orchestrator->>Service: Health.Check(serviceName)
    Service-->>Orchestrator: HealthCheckResponse(SERVING / NOT_SERVING)
    Note right of Orchestrator: Decision 
 Based on response

sequenceDiagram
    participant Orchestrator as Orchestrator / Load Balancer
    participant Service as gRPC Service
    Orchestrator->>Service: Health.Check(serviceName)
    Service-->>Orchestrator: HealthCheckResponse(SERVING / NOT_SERVING)
    Note right of Orchestrator: Decision <br/> Based on response

Implementasi Health Check pada Language Client & Server

Implementasi di Server Go

Pada gRPC ecosystem tersedia standard implementation untuk health checking, misal di Go (google.golang.org/grpc/health).

1. Server Setup

Misal, Anda punya service seperti di bawah ini:

 1package main
 2
 3import (
 4    "context"
 5    "google.golang.org/grpc"
 6    "google.golang.org/grpc/health"
 7    healthpb "google.golang.org/grpc/health/grpc_health_v1"
 8    "net"
 9    "log"
10)
11
12func main() {
13    lis, err := net.Listen("tcp", ":50051")
14    if err != nil {
15        log.Fatalf("failed to listen: %v", err)
16    }
17    s := grpc.NewServer()
18
19    // Buat instance gRPC health check
20    healthServer := health.NewServer()
21
22    // Tandai server ini SERVING status awal
23    healthServer.SetServingStatus("", healthpb.HealthCheckResponse_SERVING)
24    healthpb.RegisterHealthServer(s, healthServer)
25
26    log.Println("gRPC server with healthcheck running at :50051")
27    if err := s.Serve(lis); err != nil {
28        log.Fatalf("failed to serve: %v", err)
29    }
30}

2. Simulasi: Ubah Status Health Check

Misalkan saat maintenance, Anda ingin men-declare layanan tidak sehat (NOT_SERVING). Anda cukup update status dengan method SetServingStatus:

1// Notifikasi orchestrator dan load balancer service sedang maintenance
2healthServer.SetServingStatus("", healthpb.HealthCheckResponse_NOT_SERVING)

Client: Simulasi Health Check dengan Go

Sebagai client (misal load balancer, kubernetes-probe, dsb), Anda cukup panggil method berikut:

 1import (
 2    "context"
 3    "google.golang.org/grpc"
 4    healthpb "google.golang.org/grpc/health/grpc_health_v1"
 5    "log"
 6    "time"
 7)
 8
 9func main() {
10    conn, err := grpc.Dial(":50051", grpc.WithInsecure())
11    if err != nil {
12        log.Fatal("fail connect:", err)
13    }
14    defer conn.Close()
15    hc := healthpb.NewHealthClient(conn)
16    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
17    defer cancel()
18
19    res, err := hc.Check(ctx, &healthpb.HealthCheckRequest{Service: ""}) // Empty = seluruh server
20    if err != nil {
21        log.Fatalf("could not check health: %v", err)
22    }
23    log.Printf("Health status: %s", res.Status)
24}

Integrasi dengan Kubernetes

Di Kubernetes, probe HTTP bukan solusi ideal untuk gRPC. Namun, dengan standar gRPC health, Kubernetes >=v1.23 sudah mendukung grpc.health/v1 :

1livenessProbe:
2  grpc:
3    port: 50051
4readinessProbe:
5  grpc:
6    port: 50051

Hasil: Kubernetes langsung tanya ke service via health protocol, tanpa HTTP endpoint tambahan.

Best Practice dan Tips

1. Selalu Expose Health Service
   Semua gRPC service disarankan menjalankan standar health check. Banyak framework sudah menyediakan otomatisasi ini.

2. Granular Health Checking
   Anda bisa gunakan nama service pada request untuk granularitas status (misal: database, cache).

3. Dynamic Status
   Dinamis update status health secara periodik, misal jika gagal konek ke dependency (DB down, dsb).

4. Gunakan Stream Watch
   Jika environment Anda support, manfaatkan Watch untuk notifikasi real-time status service.

5. Security Concern
   Untuk keamanan, expose hanya pada internal network atau gunakan mTLS antara orchestrator dan service.

Studi Kasus: Health Check untuk Multiple Dependencies

Misal, gRPC service Anda tergantung pada beberapa database. Anda bisa buat proses checker seperti berikut (pseudo-code):

 1go func() {
 2    for {
 3        if db.Ping() == nil && redis.Ping() == nil {
 4            healthServer.SetServingStatus("", healthpb.HealthCheckResponse_SERVING)
 5        } else {
 6            healthServer.SetServingStatus("", healthpb.HealthCheckResponse_NOT_SERVING)
 7        }
 8        time.Sleep(time.Second)
 9    }
10}()

Kesimpulan

gRPC health checking standard adalah solusi modern untuk reliability application microservices. Ia membantu load balancer, orchestrator, dan monitoring system untuk mendeteksi dini kegagalan tanpa harus menambah endpoint HTTP baru. Dengan standar ini, Anda bisa menghadirkan arsitektur yang robust, maintainable, dan future-proof.

Jangan lupa: reliability aplikasi Anda adalah hasil dari disiplin menerapkan standar seperti ini!

Referensi:

• gRPC Health Checking Protocol
• Kubernetes gRPC Probes
• Official Go Implementation

Selamat mencoba, show the world your healthy microservices! 🚀