Belajar Caddy - Load Balancing Strategies

#Pendahuluan

Satu aplikasi tidak selalu cukup. Ketika traffic naik, kalian menambahkan instance kedua, ketiga, dan seterusnya — lalu butuh sesuatu yang membagi request secara adil di antara mereka. Itulah load balancing, dan Caddy memilikinya secara bawaan di dalam directive reverse_proxy.

#Load Balancing di reverse_proxy

#Multiple Backend

Pendaftaran banyak backend semudah menulis beberapa alamat:

app.example.com {
    reverse_proxy localhost:8080 localhost:8081
}

Caddy mendistribusikan request secara otomatis. Default policy-nya round_robin — setiap request bergantian ke backend berikutnya.

#Load Distribution Otomatis dan Failover

• Otomatis: request dibagi sesuai policy tanpa konfigurasi tambahan.
• Health check: backend yang gagal dicek akan dikeluarkan sementara dari pool.
• Failover: jika satu backend tidak merespons, request diarahkan ke backend lain.

#Policy Load Balancing

#round_robin dan least_conn

Policy menentukan bagaimana request dipilih backend:

app.example.com {
    reverse_proxy {
        to localhost:8080 localhost:8081 localhost:8082
        lb_policy least_conn
    }
}

• round_robin (default): bergantian merata.
• least_conn: pilih backend dengan koneksi tersedikit — ideal untuk request yang berdurasi lama.

#Hash dan Sticky Policy

Beberapa policy menargetkan request tertentu ke backend yang sama:

• ip_hash: request dari IP yang sama ke backend yang sama — session affinity sederhana.
• uri_hash: hash berdasarkan path URI — konsisten untuk caching.
• header: hash berdasarkan header tertentu.
• cookie: sticky sessions dengan cookie — dibahas di episode 15.
• random dan random_choose: pemilihan acak, untuk distribusi yang tidak perlu adil.

Contoh ip_hash:

app.example.com {
    reverse_proxy {
        to localhost:8080 localhost:8081
        lb_policy ip_hash
    }
}

lb_policy ip_hash memastikan klien yang sama selalu menuju backend yang sama — berguna untuk aplikasi dengan state ringan.

#Health Checks

#Active Health Checks

Caddy mem-probe backend secara berkala:

app.example.com {
    reverse_proxy {
        to localhost:8080 localhost:8081
        health_uri /healthz
        health_interval 10s
        health_timeout 5s
    }
}

• health_uri /healthz — path yang diprobed.
• health_interval 10s — probe setiap 10 detik.
• health_timeout 5s — backend dianggap gagal jika tidak merespons 5 detik.

#Passive Health Checks

Tanpa probe, Caddy menilai kesehatan dari respons request aktual:

app.example.com {
    reverse_proxy {
        to localhost:8080 localhost:8081
        max_fails 3
        fail_duration 30s
    }
}

#Konfigurasi Upstream

#Weight dan Batas Request

Tidak semua backend sama kuatnya. Beri bobot agar backend besar menerima lebih banyak:

app.example.com {
    reverse_proxy {
        to localhost:8080 localhost:8081 localhost:8082
        lb_policy round_robin
    }
}

Weight ditulis dalam bentuk daftar dengan opsi:

app.example.com {
    reverse_proxy {
        to http://localhost:8080 http://localhost:8081
        dial_timeout 10s
        max_conns_per_host 500
    }
}

#Timeout Response Header

Untuk backend yang lambat:

app.example.com {
    reverse_proxy {
        to localhost:8080
        transport http {
            response_header_timeout 30s
        }
    }
}

#Use Case: Scaling dan High Availability

#Horizontal Scaling

• Jalankan beberapa instance aplikasi di belakang satu domain Caddy.
• Saat traffic naik, tambah instance — cukup tambah satu baris di Caddyfile.
• Saat instance down, health check mengeluarkannya otomatis.

#Zero-Downtime Deployment

• Deploy versi baru dengan menambah instance baru sebelum menghapus yang lama.
• Health check memastikan instance baru siap sebelum menerima traffic.
• caddy reload menerapkan perubahan pool tanpa memutus koneksi.

caddy reload --config Caddyfile memuat ulang konfigurasi dengan mulus — pola yang akan kita pakai berulang kali di operasional.

#Penutup

Episode 14 membuka strategi load balancing Caddy: pendaftaran banyak backend, policy seperti round_robin, least_conn, ip_hash, dan random, health checks aktif dengan health_uri serta pasif dengan max_fails, konfigurasi upstream dengan weight, timeout, dan batas koneksi.

Inti yang harus dibawa pulang:

• reverse_proxy dengan banyak to otomatis membagi request.
• lb_policy memilih cara distribusi, default round_robin.
• Active health check memakai health_uri dan health_interval.
• Passive health check memakai max_fails dan fail_duration.
• dial_timeout dan max_conns_per_host mengatur beban per backend.
• Load balancing adalah fondasi scaling horizontal dan zero downtime.

Di episode 15 selanjutnya kita akan membahas session persistence & sticky sessions — cookie-based affinity, IP dan header affinity, konfigurasi cookie dengan attribute secure dan httponly, kapan harus memakai sticky sessions, serta alternatif stateless seperti shared session storage dan JWT.