Kapan upgrade server sudah tidak cukup, bagaimana menyiapkan aplikasi Laravel agar siap berjalan di banyak server, dan cara memasang load balancer Nginx dengan benar.
Pendahuluan
Saat traffic naik dan situs mulai lambat, reaksi pertama biasanya sama: upgrade VPS. Dari 2 vCPU menjadi 4, lalu 8, lalu 16. Cara ini disebut vertical scaling dan memang sering berhasil, tetapi ada batasnya:
- Harga naik lebih cepat daripada kapasitas yang didapat.
- Selalu ada satu titik kegagalan: kalau server mati, seluruh situs mati.
- Upgrade sering butuh reboot, artinya downtime.
- Bila penyebab lambat adalah query yang buruk, server lebih besar hanya menunda masalah.
Alternatifnya adalah horizontal scaling: beberapa server aplikasi di belakang sebuah load balancer. Artikel ini membahas kapan itu masuk akal, apa yang harus diubah di Laravel, dan bagaimana mengonfigurasinya.
1. Pastikan Dulu: Apakah Memang Butuh Load Balancer?
Sebelum menambah server, cari tahu di mana bottleneck sebenarnya.
# CPU, memori, dan beban
htop
uptime
# Proses PHP-FPM
sudo systemctl status php8.3-fpm --no-pager
sudo tail -n 50 /var/log/php8.3-fpm.log
# Query lambat MySQL
sudo mysqladmin -u root -p processlist
Tanda-tanda dan solusi yang paling masuk akal:
| Gejala | Penyebab Mungkin | Solusi Pertama |
|---|---|---|
| CPU 100% saat ramai, DB santai | Terlalu banyak proses PHP | Tuning PHP-FPM, OPcache, lalu scale out |
| CPU DB tinggi, banyak query lambat | N+1, index kurang | Optimasi query, cache, bukan load balancer |
| Memori habis, FPM max_children reached | Worker kebanyakan atau bocor | Hitung ulang pm.max_children |
| Satu server mati = situs mati | Single point of failure | Load balancer + minimal 2 server |
| Ingin deploy tanpa downtime | - | Load balancer + rolling deploy |
Urutan yang sehat: optimasi dulu (cache, index, eager loading, OPcache), baru scale out. Menambah server di depan database yang lambat hanya memindahkan antrean.
2. Arsitektur Target
┌──────────────┐
Pengguna ──────► │ Load Balancer│ (Nginx / HAProxy / LB cloud)
└──────┬───────┘
┌────────────┼────────────┐
▼ ▼ ▼
┌────────┐ ┌────────┐ ┌────────┐
│ App #1 │ │ App #2 │ │ App #3 │ Nginx + PHP-FPM + Laravel
└───┬────┘ └───┬────┘ └───┬────┘
└────────────┼────────────┘
┌───────────┼────────────┐
▼ ▼ ▼
┌────────┐ ┌────────┐ ┌──────────────┐
│ MySQL │ │ Redis │ │ Object Store │
│ │ │ (cache,│ │ (S3 / MinIO) │
│ │ │ session│ │ upload file │
│ │ │ queue) │ └──────────────┘
└────────┘ └────────┘
Prinsip utamanya: server aplikasi harus stateless. Setiap request bisa dilayani oleh server mana pun tanpa kehilangan konteks. Semua yang bersifat "state" dipindahkan ke layanan bersama.
3. Menyiapkan Laravel agar Stateless
Ini bagian yang paling sering dilewatkan, dan penyebab utama bug aneh setelah memasang load balancer ("kadang login, kadang logout sendiri").
a. Session: pindah dari file ke Redis (atau database)
Driver file menyimpan session di disk masing-masing server. Pengguna yang dipindah ke server lain akan dianggap belum login.
SESSION_DRIVER=redis
SESSION_CONNECTION=default
CACHE_STORE=redis
QUEUE_CONNECTION=redis
REDIS_CLIENT=phpredis
REDIS_HOST=10.0.0.20
REDIS_PASSWORD=GantiDenganPasswordRedis
REDIS_PORT=6379
b. Cache: terpusat
Cache file di tiap server akan menghasilkan data yang berbeda-beda antar server. Gunakan Redis (atau Memcached) agar semua server membaca cache yang sama.
c. File upload: jangan simpan di disk lokal
File yang diunggah ke storage/app/public hanya ada di satu server. Gunakan object storage yang kompatibel S3, atau NFS sebagai alternatif.
composer require league/flysystem-aws-s3-v3 "^3.0"
FILESYSTEM_DISK=s3
AWS_ACCESS_KEY_ID=...
AWS_SECRET_ACCESS_KEY=...
AWS_DEFAULT_REGION=ap-southeast-3
AWS_BUCKET=nama-bucket
AWS_ENDPOINT=https://s3.contoh-provider.com
AWS_USE_PATH_STYLE_ENDPOINT=true
$path = $request->file('foto')->store('produk', 's3');
$url = Storage::disk('s3')->url($path);
d. APP_KEY harus identik di semua server
Session terenkripsi dan cookie ditandatangani dengan APP_KEY. Jika berbeda antar server, pengguna akan mendapat error payload invalid.
# di setiap server, harus menghasilkan hash yang sama
grep '^APP_KEY=' .env | sha256sum
e. Scheduler: jalankan di satu server saja
Jika cron schedule:run aktif di tiga server, setiap tugas terjadwal akan berjalan tiga kali. Gunakan onOneServer() (membutuhkan cache terpusat seperti Redis):
// routes/console.php
use Illuminate\Support\Facades\Schedule;
Schedule::command('laporan:harian')->dailyAt('01:00')->onOneServer();
Schedule::command('pesanan:kedaluwarsa')->everyFiveMinutes()->onOneServer();
f. Queue worker: pisahkan atau pusatkan
Worker boleh berjalan di server aplikasi atau di server khusus, selama semuanya terhubung ke Redis yang sama. Untuk beban besar, pisahkan worker dari server web agar proses berat tidak mengganggu respons halaman.
g. Percayai header dari load balancer
Di belakang load balancer, IP pengunjung dan skema HTTPS dikirim lewat header X-Forwarded-*. Tanpa konfigurasi ini, request()->ip() akan selalu berisi IP load balancer, dan URL yang dibuat bisa berupa http:// padahal pengguna memakai HTTPS.
// bootstrap/app.php (Laravel 11+)
->withMiddleware(function (Middleware $middleware) {
$middleware->trustProxies(at: ['10.0.0.10']); // IP privat load balancer
})
Gunakan IP load balancer yang spesifik, bukan '*', kecuali server aplikasi memang tidak bisa diakses langsung dari internet. Kalau tidak, pengguna bisa memalsukan header IP mereka.
4. Memasang Load Balancer dengan Nginx
Di server load balancer (misalnya 10.0.0.10):
sudo apt install -y nginx
sudo nano /etc/nginx/conf.d/laravel-lb.conf
upstream laravel_backend {
least_conn; # kirim ke server dengan koneksi paling sedikit
server 10.0.0.11:80 max_fails=3 fail_timeout=15s;
server 10.0.0.12:80 max_fails=3 fail_timeout=15s;
server 10.0.0.13:80 max_fails=3 fail_timeout=15s backup; # hanya aktif jika yang lain gagal
keepalive 32;
}
server {
listen 80;
server_name contoh-domain.com www.contoh-domain.com;
client_max_body_size 20M;
location / {
proxy_pass http://laravel_backend;
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_connect_timeout 5s;
proxy_read_timeout 60s;
proxy_next_upstream error timeout http_502 http_503 http_504;
proxy_next_upstream_tries 2;
}
}
sudo nginx -t && sudo systemctl reload nginx
Setelah SSL dipasang di load balancer (misalnya dengan Certbot), server aplikasi cukup melayani HTTP di jaringan privat. Pastikan jaringan antar server tidak terbuka ke publik (gunakan firewall atau VPC).
Algoritma yang tersedia
| Algoritma | Cara Kerja | Cocok Untuk |
|---|---|---|
round robin (default) |
Bergiliran | Server setara, request serupa |
least_conn |
Ke server paling sedikit koneksi | Durasi request bervariasi |
ip_hash |
Klien yang sama ke server yang sama | Aplikasi yang belum stateless |
weight=N |
Bobot kapasitas | Server berspesifikasi berbeda |
ip_hash sering dipakai sebagai jalan pintas ("sticky session"), tetapi itu menutupi masalah, bukan menyelesaikannya. Distribusi jadi tidak merata, dan pengguna di belakang NAT (kantor, kampus) menumpuk di satu server. Lebih baik jadikan aplikasi stateless.
5. Health Check
Nginx versi open source hanya melakukan passive health check (menandai server gagal setelah beberapa error, seperti max_fails di atas). Agar load balancer tidak mengirim trafik ke server yang sebenarnya bermasalah, sediakan endpoint kesehatan yang memeriksa dependensi.
Laravel 11+ sudah menyediakan /up. Untuk pemeriksaan lebih dalam, buat sendiri:
// routes/web.php
use Illuminate\Support\Facades\{Cache, DB, Redis};
Route::get('/health', function () {
try {
DB::select('select 1');
Redis::connection()->ping();
Cache::store('redis')->put('health', now()->timestamp, 10);
return response()->json(['status' => 'ok']);
} catch (\Throwable $e) {
report($e);
return response()->json(['status' => 'error'], 503);
}
});
curl -s -o /dev/null -w "%{http_code}\n" http://10.0.0.11/health
200
Jangan menampilkan pesan exception di respons publik. Cukup status dan kode HTTP.
6. Deploy Bergulir (Rolling Deploy) Tanpa Downtime
Dengan beberapa server, Anda bisa memperbarui satu per satu. Keluarkan server dari rotasi, deploy, uji, lalu masukkan kembali.
#!/usr/bin/env bash
set -euo pipefail
SERVERS=("10.0.0.11" "10.0.0.12" "10.0.0.13")
for host in "${SERVERS[@]}"; do
echo ">> Deploy ke $host"
ssh deploy@$host '
cd /var/www/laravel-app &&
git pull origin main &&
composer install --no-dev --optimize-autoloader --no-interaction &&
php artisan optimize &&
sudo systemctl reload php8.3-fpm &&
php artisan queue:restart
'
# pastikan sehat sebelum lanjut ke server berikutnya
code=$(curl -s -o /dev/null -w "%{http_code}" "http://$host/health")
if [ "$code" != "200" ]; then
echo "!! $host tidak sehat ($code). Deploy dihentikan."
exit 1
fi
done
Migrasi database harus dijalankan sekali saja, dari satu server, dan harus kompatibel mundur (versi kode lama masih bisa berjalan di skema baru). Jangan menghapus atau mengganti nama kolom dalam satu rilis yang sama dengan kode yang masih memakainya.
7. Uji Beban Sebelum dan Sesudah
Jangan menebak. Ukur.
sudo apt install -y wrk
wrk -t4 -c100 -d30s --latency https://contoh-domain.com/
Contoh hasil sebelum scale out (satu server):
Running 30s test @ https://contoh-domain.com/
4 threads and 100 connections
Latency Distribution
50% 412.33ms
90% 1.21s
99% 2.87s
Requests/sec: 231.40
Socket errors: connect 0, read 0, write 0, timeout 38
Dan setelah tiga server di belakang load balancer (angka ilustrasi):
Latency Distribution
50% 118.07ms
90% 264.50ms
99% 590.12ms
Requests/sec: 781.62
Socket errors: connect 0, read 0, write 0, timeout 0
Lakukan uji beban hanya pada lingkungan yang Anda miliki, di luar jam sibuk atau di staging. Uji juga halaman yang berat (checkout, laporan), bukan hanya beranda.
8. Titik Lemah yang Baru: Database
Load balancer membuat lapisan aplikasi mudah diperbesar, tetapi semua server aplikasi memukul database yang sama. Setelah scale out, database sering menjadi bottleneck berikutnya.
Langkah bertahap, dari termurah:
- Cache hasil query berat (
Cache::remember) dan halaman yang jarang berubah. - Index dan perbaikan query lambat (aktifkan slow query log).
- Eager loading untuk menghilangkan N+1.
- Read replica: baca dari replika, tulis ke primary.
// config/database.php
'mysql' => [
'read' => ['host' => ['10.0.0.31', '10.0.0.32']],
'write' => ['host' => ['10.0.0.30']],
'sticky' => true, // setelah menulis, request yang sama membaca dari primary
// ...
],
Opsi sticky penting agar data yang baru ditulis langsung terbaca di request yang sama, tanpa terkena jeda replikasi.
- Pertimbangkan connection pooling (misalnya ProxySQL) bila jumlah koneksi dari banyak server membengkak.
9. Titik Kegagalan Tunggal Baru: Load Balancer Itu Sendiri
Satu load balancer yang mati akan menjatuhkan semuanya, sama seperti masalah awal. Opsi mitigasi:
- Gunakan load balancer terkelola dari penyedia cloud, yang sudah redundan.
- Pasang dua load balancer dengan keepalived (VRRP) dan IP virtual.
- Pastikan juga Redis dan MySQL punya rencana pemulihan (backup, replika, atau layanan terkelola).
Checklist Kesiapan
- ☐ Bottleneck sudah diukur, dan optimasi dasar (cache, index, OPcache) sudah dilakukan.
- ☐ Session dan cache memakai Redis, bukan
file. - ☐ Upload file ke object storage atau storage bersama.
- ☐
APP_KEYsama di semua server. - ☐ Scheduler memakai
onOneServer()dan hanya satu sumber cron yang aktif atau terkunci. - ☐
trustProxiesdiatur ke IP load balancer. - ☐ Endpoint
/healthmemeriksa database dan Redis. - ☐ Jaringan antar server tertutup dari internet.
- ☐ Rolling deploy diuji, termasuk migrasi yang kompatibel mundur.
- ☐ Uji beban dilakukan sebelum dan sesudah perubahan.
- ☐ Ada rencana untuk database dan load balancer sebagai titik kegagalan.
Penutup
Load balancer bukan tombol ajaib untuk mempercepat situs. Ia adalah konsekuensi dari arsitektur yang stateless: begitu aplikasi siap, menambah kapasitas semudah menambah satu server ke daftar upstream. Mulailah dari pengukuran, benahi aplikasi agar tidak menyimpan state di server, baru pasang load balancer. Dengan urutan itu, Anda mendapat kapasitas, ketahanan, dan deploy tanpa downtime, bukan sekadar server yang lebih banyak.