Belajar Caddy - gRPC & Modern Protocols

#Pendahuluan

Microservices modern sering berkomunikasi dengan gRPC — framework RPC yang memakai HTTP/2 dan protobuf. gRPC menjanjikan performa tinggi dan streaming dua arah, tapi membawa satu syarat: HTTP/2 wajib. Episode 26 membahas cara Caddy melayani dan mem-proxy gRPC.

Kalian juga akan belajar gRPC-Web untuk klien browser, load balancing khusus gRPC, serta HTTP/3 (QUIC) — protokol generasi berikutnya yang diaktifkan Caddy secara otomatis.

Setelah episode ini, kalian bisa menjadikan Caddy sebagai API gateway untuk layanan gRPC sekaligus mendukung protokol modern paling mutakhir.

#Dasar gRPC

#Mengapa gRPC Butuh HTTP/2

gRPC memakai fitur HTTP/2 yang tidak ada di HTTP/1.1:

• Multiplexing: banyak stream dalam satu koneksi.
• Binary framing: efisien untuk protobuf.
• Streaming: server dan client streaming dua arah.
• Header compression: HPACK untuk penghematan bandwidth.

Tanpa HTTP/2, gRPC tidak berjalan sama sekali. Caddy menangani sisi klien secara otomatis (browser atau klien gRPC yang terhubung lewat HTTPS), tapi sisi backend perlu diatur.

#gRPC Reverse Proxy

#Transport h2c

gRPC backend biasanya berbicara HTTP/2 cleartext (h2c). Konfigurasinya:

grpc.example.com {
    reverse_proxy localhost:50051 {
        transport http {
            versions h2c 2
        }
    }
}

transport http { versions h2c 2 } memaksa koneksi ke backend memakai HTTP/2 tanpa TLS. Caddy menyelesaikan TLS dengan klien (HTTPS) lalu meneruskan ke backend lewat h2c.

#Protokol Deteksi

Caddy mendeteksi content-type application/grpc dan menangani stream dengan benar. Streaming, unary, dan bidirectional calls semua bekerja lewat konfigurasi yang sama. Tidak perlu matcher khusus.

#Pertimbangan TLS

• Klien gRPC terhubung lewat HTTPS — Caddy menyediakan sertifikat.
• Backend memakai h2c (tanpa TLS) karena sudah berada di jaringan internal.
• Jika backend memakai TLS sendiri, gunakan transport http dengan tls diaktifkan.

#Load Balancing gRPC

#Koneksi Panjang dan Health Check

gRPC menggunakan koneksi HTTP/2 yang panjang dengan banyak stream. Saat memakai banyak backend:

grpc.example.com {
    reverse_proxy {
        to grpc-a:50051 grpc-b:50051 grpc-c:50051
        lb_policy round_robin
        transport http {
            versions h2c 2
        }
        health_uri /healthz
        health_interval 10s
    }
}

health_uri /healthz mem-probe backend gRPC secara berkala. Backend yang gagal dikeluarkan dari pool — koneksi HTTP/2 yang lama membutuhkan health check yang proaktif.

#gRPC Service Health

Layanan gRPC standar mengekspos health check protokol. Pastikan endpoint /healthz dikonfigurasi di aplikasi atau gunakan grpc-health-probe. Backend yang sehat terdeteksi otomatis dan didaftarkan kembali setelah pulih.

#gRPC-Web

#gRPC dari Browser

Browser tidak bisa memakai gRPC native (butuh kontrol penuh HTTP/2). Solusinya gRPC-Web:

• Aplikasi web memanggil gRPC-Web endpoint.
• Caddy meneruskan ke backend gRPC.
• Backend menangani keduanya atau melalui proxy gRPC-Web.

Caddy mendukung gRPC-Web dengan mem-proxy request tersebut seperti biasa. Hal yang perlu diperhatikan adalah CORS — karena request datang dari origin berbeda:

grpc.example.com {
    @preflight {
        method OPTIONS
    }
    handle @preflight {
        header Access-Control-Allow-Origin *
        header Access-Control-Allow-Methods "POST"
        header Access-Control-Allow-Headers "content-type, x-grpc-web"
        respond 204
    }
    header Access-Control-Allow-Origin *
    reverse_proxy localhost:50051 {
        transport http {
            versions h2c 2
        }
    }
}

header Access-Control-Allow-Headers "content-type, x-grpc-web" mengizinkan header khusus gRPC-Web pada preflight. Tanpa CORS yang benar, browser memblokir panggilan dari web app.

#Use Case gRPC-Web

• UI admin yang memanggil service backend.
• Dashboard internal berbasis microservices.
• Mobile web apps yang butuh data streaming.

#HTTP/3 (QUIC)

#Mengaktifkan HTTP/3

HTTP/3 berjalan di atas UDP dengan protokol QUIC. Caddy mengaktifkannya otomatis:

{
    servers {
        protocols h1 h2 h3
    }
}
 
example.com {
    root * /var/www
    file_server
}

protocols h1 h2 h3 mencakup HTTP/3. Satu-satunya syarat eksternal: port UDP 443 terbuka di firewall. Tanpa itu, Caddy tetap berjalan dengan HTTP/2.

#Keuntungan QUIC

• 0-RTT: handshake jauh lebih cepat.
• Multiplexing tanpa head-of-line blocking — stream lain tidak tertahan.
• Connection migration: koneksi bertahan saat pindah jaringan.
• Built-in encryption: TLS 1.3 selalu aktif.

#Alt-Svc Header

Caddy mengirim header Alt-Svc: h3=... yang memberi tahu browser bahwa HTTP/3 tersedia. Browser yang mendukung akan otomatis memakai QUIC pada request berikutnya. Header ini ditangani otomatis — tidak perlu dikonfigurasi.

#Penutup

Episode 26 membahas gRPC dan protokol modern: kebutuhan HTTP/2, reverse proxy gRPC dengan transport http { versions h2c 2 }, load balancing dengan health check, gRPC-Web dengan CORS untuk browser, serta HTTP/3 (QUIC) dengan port UDP 443 dan header Alt-Svc.

Inti yang harus dibawa pulang:

• gRPC wajib HTTP/2; backend memakai h2c.
• versions h2c 2 di transport menyalakan HTTP/2 cleartext.
• Health check proaktif penting untuk pool backend gRPC.
• gRPC-Web butuh CORS dengan header x-grpc-web.
• HTTP/3 aktif otomatis jika UDP 443 terbuka.
• Alt-Svc memberitahu browser untuk memakai QUIC.

Di episode 27 selanjutnya kita akan membahas Docker integration — image resmi Caddy, multi-stage build, Docker Compose dengan volume dan network, persistence sertifikat, service discovery antar container, serta pola Caddy sebagai reverse proxy untuk banyak aplikasi.