2026-11-09 · 13 min
Virtual Waiting Room untuk Lonjakan Promo: Cloudflare vs Antrian Redis
Dua hari lagi 11.11. Di titik ini pertanyaannya bukan lagi “apakah trafik akan melebihi kapasitas”, karena jawabannya sudah jelas: pasti. Pertanyaan yang sebenarnya cuma satu, dan saya akan jawab tegas di artikel ini: kalau kapasitas pasti terlampaui, apakah Anda ingin sebagian user mengantre dengan jujur, atau semua orang kena timeout dan error acak secara bersamaan? Jawaban saya adalah yang pertama, dan jalan ke sana namanya virtual waiting room.
Sebagai reviewer dev tool, saya tidak akan menulis ulasan “lima cara menangani lonjakan trafik flash sale” yang isinya daftar generik. Saya akan membangun satu implementasi antrian token memakai Redis sorted set dan middleware Node.js yang benar-benar meloloskan user sesuai kapasitas, lalu membandingkannya dengan Cloudflare Waiting Room berdasarkan empat kriteria yang tegas: usaha setup, kontrol atas urutan dan fairness, perilaku saat komponennya sendiri bermasalah, dan ketergantungan pada vendor. Soal race condition stok sudah saya bahas tuntas di artikel pencegahan overselling bulan lalu; artikel ini fokus pada lapisan sebelum itu, yaitu siapa yang boleh masuk ke pintu depan sama sekali.
Kenapa Virtual Waiting Room Lebih Jujur daripada Auto-Scaling Panik
Insting pertama banyak tim ketika mendengar “trafik akan melonjak” adalah menambah instance, menaikkan batas koneksi database, dan berharap auto-scaling mengejar tepat waktu. Masalahnya, auto-scaling bereaksi terhadap beban yang sudah terjadi, sementara lonjakan 11.11 datang dalam hitungan detik di jam yang sama persis. Begitu origin kelebihan beban, yang terjadi bukan kegagalan yang rapi, melainkan degradasi acak: sebagian request lambat, sebagian timeout, sebagian error 500, dan user tidak tahu apakah harus menunggu atau mencoba lagi. Ini load shedding yang tidak disengaja, terjadi begitu saja ketika resource habis.
Virtual waiting room membalik urutannya. Anda memutuskan lebih dulu, bukan saat insiden berlangsung, berapa banyak sesi yang boleh berada di dalam checkout secara bersamaan. Request yang melebihi angka itu tidak ditolak, tetapi ditahan di ruang tunggu dengan posisi yang jelas, lalu diloloskan begitu ada slot kosong. Ini bentuk load shedding yang disengaja dan terkontrol: origin Anda tidak pernah menerima lebih dari yang sanggup ia layani dengan baik, dan user yang menunggu tahu persis bahwa mereka sedang menunggu, bukan sedang gagal.
Bedanya dengan rate limiting biasa penting untuk digarisbawahi. Rate limiter seperti token bucket atau sliding window, yang pernah saya bahas di tulisan soal rate limiting dengan Cloudflare, biasanya menolak request yang melebihi kuota dengan status 429 dan selesai di situ. Virtual waiting room tidak menolak, ia menunda, dan memberi kepastian kapan giliran akan tiba. Keduanya bisa dipakai bersama: rate limiter di layer yang lebih luar untuk menahan bot dan request abusif, waiting room untuk mengatur antrian user sungguhan yang memang ingin berbelanja.
Desain Antrian Token dengan Redis Sorted Set
Antrian yang akan saya bangun memakai dua sorted set per “ruang tunggu” (satu ruang tunggu bisa mewakili satu halaman checkout, satu event promo, atau satu produk tertentu):
wr:queue:{room}: sorted set berisi session ID yang sedang menunggu, dengan score berupa waktu bergabung. Score inilah yang membuat urutannya FIFO murni, bukan undian.wr:active:{room}: sorted set berisi session ID yang sudah diloloskan masuk, dengan score berupa waktu kedaluwarsa slot aktifnya.
Kurung kurawal pada {room} adalah hash tag, supaya kedua key untuk satu ruang tunggu selalu berada di slot yang sama kalau nanti Anda pindah ke Redis Cluster.
Model kapasitasnya adalah concurrency cap: “berapa sesi boleh berada di dalam secara bersamaan”, bukan “berapa user baru per menit”. Ketika satu sesi aktif meninggalkan halaman atau slotnya kedaluwarsa, satu slot terbuka, dan satu orang berikutnya dari antrian diloloskan. Ada tiga operasi atomic yang saya tulis sebagai Lua script, karena semuanya harus baca-lalu-tulis tanpa celah:
- JOIN: kalau sesi sudah aktif, langsung kembalikan status admitted. Kalau belum ada di antrian, tambahkan dengan score waktu sekarang. Kalau sudah ada di antrian, jangan sentuh score-nya lagi (supaya polling berulang tidak mendorong posisi orang itu ke belakang), cukup kembalikan posisinya.
- ADMIT: buang dulu sesi aktif yang sudah kedaluwarsa, hitung slot kosong, lalu pindahkan sejumlah sesi dengan score terkecil dari antrian ke aktif.
- HEARTBEAT: perpanjang waktu kedaluwarsa sesi yang sedang aktif, supaya user yang masih mengisi form checkout tidak ditendang di tengah jalan.
// src/waitingroom.ts
import Redis, { Result } from "ioredis";
const keys = (room: string) => [`wr:queue:{${room}}`, `wr:active:{${room}}`] as const;
// ARGV: sessionId, now (ms), ttlMs | Return: [status, position]
// status 1 = sudah admitted, 0 = masih antre
const JOIN = `
local active = redis.call('ZSCORE', KEYS[2], ARGV[1])
if active and tonumber(active) > tonumber(ARGV[2]) then
return {1, 0}
end
if redis.call('ZSCORE', KEYS[1], ARGV[1]) == false then
redis.call('ZADD', KEYS[1], ARGV[2], ARGV[1])
end
local rank = redis.call('ZRANK', KEYS[1], ARGV[1])
return {0, rank + 1}
`;
// ARGV: now, capacity, ttlMs, batchSize | Return: jumlah sesi yang baru diloloskan
const ADMIT = `
redis.call('ZREMRANGEBYSCORE', KEYS[2], '-inf', ARGV[1])
local activeCount = redis.call('ZCARD', KEYS[2])
local slots = tonumber(ARGV[2]) - activeCount
if slots <= 0 then return 0 end
local batch = tonumber(ARGV[4])
if slots < batch then batch = slots end
local candidates = redis.call('ZRANGE', KEYS[1], 0, batch - 1)
for _, id in ipairs(candidates) do
redis.call('ZREM', KEYS[1], id)
redis.call('ZADD', KEYS[2], tonumber(ARGV[1]) + tonumber(ARGV[3]), id)
end
return #candidates
`;
// ARGV: sessionId, now, ttlMs | Return: 1 = diperpanjang, 0 = sesi sudah tidak aktif
const HEARTBEAT = `
local score = redis.call('ZSCORE', KEYS[1], ARGV[1])
if not score or tonumber(score) <= tonumber(ARGV[2]) then return 0 end
redis.call('ZADD', KEYS[1], tonumber(ARGV[2]) + tonumber(ARGV[3]), ARGV[1])
return 1
`;
declare module "ioredis" {
interface RedisCommander<Context> {
wrJoin(k1: string, k2: string, sessionId: string, now: number, ttlMs: number): Result<[number, number], Context>;
wrAdmit(k1: string, k2: string, now: number, capacity: number, ttlMs: number, batch: number): Result<number, Context>;
wrHeartbeat(k1: string, sessionId: string, now: number, ttlMs: number): Result<number, Context>;
}
}
export const redis = new Redis(process.env.REDIS_URL ?? "redis://localhost:6379");
redis.defineCommand("wrJoin", { numberOfKeys: 2, lua: JOIN });
redis.defineCommand("wrAdmit", { numberOfKeys: 2, lua: ADMIT });
redis.defineCommand("wrHeartbeat", { numberOfKeys: 1, lua: HEARTBEAT });
Satu detail desain yang disengaja: JOIN memeriksa ZSCORE ... == false sebelum menambahkan ke antrian. Tanpa pengecekan ini, setiap kali halaman antre memuat ulang dan memanggil JOIN lagi, ZADD akan menimpa score lama dengan waktu sekarang, dan posisi user itu akan terus mundur ke belakang antrian selamanya. Dengan pengecekan ini, posisi hanya ditentukan sekali, saat pertama kali bergabung.
Middleware yang Meloloskan User Sesuai Kapasitas
Bagian ini yang menjawab pertanyaan inti di judul: bagaimana sebuah antrian virtual Redis benar-benar meloloskan user, bukan sekadar menghitung posisi. Middleware di bawah dipasang di depan route checkout. Setiap request yang masuk, baik yang sedang antre maupun yang baru datang, ikut memicu ADMIT, sehingga antrian tetap maju tanpa harus bergantung pada satu worker terpisah yang mungkin lupa dijalankan di malam sibuk.
// src/waitingroom-guard.ts
import type { Request, Response, NextFunction } from "express";
import { randomUUID } from "node:crypto";
import { redis } from "./waitingroom";
export type RoomConfig = {
room: string;
capacity: number;
activeTtlMs?: number;
admitBatchSize?: number;
onRedisError?: "fail-open" | "fail-closed";
};
function renderWaitingPage(position: number, total: number, retryMs: number) {
return `<!doctype html>
<html lang="id">
<head><meta charset="utf-8"><title>Anda sedang mengantre</title></head>
<body>
<h1>Terima kasih sudah menunggu</h1>
<p>Posisi Anda: <strong>${position}</strong> dari ${total} yang sedang antre.</p>
<p>Halaman ini akan memeriksa ulang secara otomatis.</p>
<script>
setTimeout(() => location.reload(), ${retryMs} + Math.floor(Math.random() * 1000));
</script>
</body>
</html>`;
}
export function waitingRoomGuard(cfg: RoomConfig) {
const activeTtlMs = cfg.activeTtlMs ?? 60_000;
const admitBatchSize = cfg.admitBatchSize ?? 20;
const failMode = cfg.onRedisError ?? "fail-closed";
const [queueKey, activeKey] = [`wr:queue:{${cfg.room}}`, `wr:active:{${cfg.room}}`];
const cookieName = `wr_${cfg.room}`;
return async function guard(req: Request, res: Response, next: NextFunction) {
let sessionId: string | undefined = req.signedCookies?.[cookieName];
if (!sessionId) {
sessionId = randomUUID();
res.cookie(cookieName, sessionId, { signed: true, httpOnly: true, sameSite: "lax" });
}
const now = Date.now();
try {
// Setiap request yang lewat sini ikut memajukan antrean secara global
await redis.wrAdmit(queueKey, activeKey, now, cfg.capacity, activeTtlMs, admitBatchSize);
const [status, position] = await redis.wrJoin(queueKey, activeKey, sessionId, now, activeTtlMs);
if (status === 1) {
await redis.wrHeartbeat(activeKey, sessionId, now, activeTtlMs);
return next();
}
const total = await redis.zcard(queueKey);
return res.status(200).type("html").send(renderWaitingPage(position, total, 3000));
} catch (err) {
console.error("waiting room redis error", cfg.room, err);
if (failMode === "fail-open") return next(); // origin menanggung beban penuh tanpa antrian
return res.status(503).type("html").send("Sedang ramai, coba muat ulang beberapa saat lagi.");
}
};
}
export function startAdmitter(cfg: RoomConfig, intervalMs = 2000) {
const activeTtlMs = cfg.activeTtlMs ?? 60_000;
const admitBatchSize = cfg.admitBatchSize ?? 20;
const [queueKey, activeKey] = [`wr:queue:{${cfg.room}}`, `wr:active:{${cfg.room}}`];
return setInterval(() => {
redis
.wrAdmit(queueKey, activeKey, Date.now(), cfg.capacity, activeTtlMs, admitBatchSize)
.catch((err) => console.error("wrAdmit gagal", cfg.room, err));
}, intervalMs);
}
Dan pemakaiannya di aplikasi Express:
// src/app.ts
import express from "express";
import cookieParser from "cookie-parser";
import { waitingRoomGuard, startAdmitter } from "./waitingroom-guard";
const app = express();
app.use(cookieParser(process.env.COOKIE_SECRET));
const checkoutRoom = {
room: "checkout-1111",
capacity: 300, // berapa sesi boleh berada di checkout secara bersamaan
activeTtlMs: 90_000, // slot aktif hilang kalau tidak ada heartbeat 90 detik
onRedisError: "fail-closed" as const,
};
startAdmitter(checkoutRoom); // jaring pengaman kalau trafik sedang sepi request
app.get("/checkout", waitingRoomGuard(checkoutRoom), (req, res) => {
res.send("Halaman checkout sungguhan ada di sini");
});
app.listen(3000);
Pasang dengan npm i express ioredis cookie-parser plus tipe devDependency-nya. Tiga hal yang membuat implementasi ini layak dipakai, bukan sekadar contoh:
- Keputusan fail-open atau fail-closed eksplisit di konfigurasi, bukan tersembunyi sebagai efek samping dari exception yang tidak tertangani. Ini bentuk nyata load shedding di Node.js: ketika komponen penahan beban sendiri bermasalah, Anda yang memutuskan arah kegagalannya, bukan runtime yang memutuskan untuk Anda.
- Posisi antrian tidak pernah mundur karena polling berulang, berkat pengecekan
ZSCOREdi scriptJOIN. - Tidak ada worker terpisah yang wajib hidup.
ADMITberjalan setiap request, danstartAdmitterhanya jaring pengaman tambahan untuk periode sepi trafik.
Sebelum 11.11 sungguhan, uji middleware ini dengan beban paralel seperti pola load test di artikel pencegahan overselling: tembak ratusan sesi serentak, lalu pastikan jumlah sesi aktif tidak pernah melebihi capacity sepanjang durasi test, bukan hanya menilai dari kode status HTTP yang kembali.
Cloudflare Waiting Room: Cara Kerjanya Secara Ringkas
Cloudflare Waiting Room menempatkan logika admission control di level edge, sebelum request menyentuh origin sama sekali. Secara konsep, Anda mendefinisikan sebuah ruang tunggu untuk hostname dan path tertentu, menetapkan batas jumlah pengguna aktif secara bersamaan, dan batas pengguna baru yang masuk per periode waktu. Cloudflare yang menangani pelacakan sesi lewat cookie, antrian FIFO, dan halaman tunggu yang bisa dikustomisasi.
Karena Waiting Room berjalan di proxy, dasar admission control-nya bisa aktif tanpa mengubah kode aplikasi Anda. Yang biasanya tetap butuh pekerjaan tambahan: menyesuaikan tampilan halaman tunggu agar konsisten dengan brand, serta memisahkan aturan untuk endpoint yang bukan navigasi halaman biasa, misalnya WebSocket atau panggilan API internal. Nama field konfigurasi, opsi lanjutan seperti aturan per path atau daftar pengecualian, dan syarat paket terus diperbarui oleh Cloudflare, jadi untuk detail paling akurat, rujuk langsung ke dokumentasi resminya di developers.cloudflare.com/waiting-room sebelum menetapkan desain final. Saya sengaja tidak mengutip angka paket atau harga di sini karena keduanya berubah dan dokumentasi resmi adalah satu-satunya sumber yang pantas dipercaya untuk itu.
Kriteria Perbandingan Tegas: Redis DIY vs Cloudflare Waiting Room
Ini bagian yang saya anggap paling penting. Bukan “mana yang lebih bagus”, tetapi mana yang menang di kriteria yang benar-benar menentukan keputusan Anda dua hari sebelum 11.11.
| Kriteria | Antrian Redis (DIY) | Cloudflare Waiting Room |
|---|---|---|
| Usaha setup | Anda menulis Lua script, middleware, halaman tunggu, dan menguji sendiri. Butuh Redis yang sudah berjalan, tapi banyak tim sudah punya untuk cache atau session. Semua bug jadi tanggung jawab Anda, termasuk yang baru ketahuan saat load test H-2. | Dikonfigurasi lewat dashboard atau API, umumnya tanpa deploy ulang aplikasi untuk mekanisme intinya. Lebih cepat untuk tenggat yang mepet, tapi Anda bekerja dalam batas opsi yang tersedia di produk, bukan menulis logika sendiri. |
| Kontrol atas urutan & fairness | Penuh. Urutan FIFO di contoh ini ditentukan oleh score waktu bergabung, dan bisa diubah sendiri, misalnya jalur prioritas untuk member tertentu dengan score yang dikurangi bonus prioritas. | Mengikuti perilaku antrian yang didokumentasikan Cloudflare beserta parameter yang tersedia untuk dikonfigurasi. Anda mengatur angka dan aturan, bukan mengubah algoritmanya sendiri. Cek dokumentasi untuk opsi fairness terkini yang relevan dengan kebutuhan Anda. |
| Perilaku saat komponennya sendiri bermasalah | Anda yang memutuskan: kode di atas eksplisit memilih fail-open atau fail-closed saat Redis tidak terjangkau, dan keputusan itu ada di repo Anda, bisa diuji, dan bisa diganti kapan saja. | Waiting Room adalah bagian dari jaringan edge Cloudflare; perilaku spesifiknya saat ada gangguan di sisi Cloudflare sendiri diatur oleh sistem mereka, bukan oleh kode Anda. Periksa dokumentasi resmi dan status page mereka untuk memahami apa yang didokumentasikan, dan jangan berasumsi tanpa mengecek. |
| Ketergantungan vendor | Rendah. Redis adalah komponen generik, logikanya hidup di repo Anda, dan bisa diuji secara lokal maupun di CI tanpa akun pihak ketiga. | Konfigurasi hidup di control plane Cloudflare, terikat pada akun dan domain yang sudah memakai proxy mereka. Berpindah penyedia nanti berarti menulis ulang logika admission control dari awal. |
Pola yang muncul dari tabel ini konsisten: Redis DIY menang di kontrol dan independensi, karena semuanya ada di tangan dan repo Anda. Cloudflare Waiting Room menang di kecepatan mengaktifkan admission control standar tanpa menambah kode baru yang berisiko bug saat tenggat sudah mepet seperti sekarang.
Kapan Pilih yang Mana
Kriteria saya sederhana dan tidak butuh diskusi panjang:
- Pilih Redis DIY kalau Redis Anda sudah stabil dan sudah dites, tim terbiasa menulis dan membaca Lua script, dan Anda butuh aturan fairness yang spesifik untuk bisnis Anda, misalnya jalur terpisah untuk member berbayar.
- Pilih Cloudflare Waiting Room kalau trafik Anda memang sudah lewat Cloudflare, waktu tersisa terlalu mepet untuk menguji kode baru dengan layak, dan yang dibutuhkan adalah admission control standar yang terbukti berjalan di skala besar tanpa menambah permukaan bug di aplikasi Anda sendiri.
- Pakai keduanya sekaligus bukan hal aneh: Cloudflare menahan sebagian besar lonjakan paling kasar di edge sebelum menyentuh origin sama sekali, sementara antrian Redis Anda tetap menjadi penjaga kedua yang presisi untuk kapasitas spesifik satu halaman checkout. Keduanya adalah admission control, bukan pengganti satu sama lain.
Satu hal yang tidak boleh dilupakan apa pun pilihannya: virtual waiting room mengatur siapa yang boleh masuk, bukan apa yang terjadi setelah mereka masuk. Soal stok yang tidak boleh oversold tetap harus dijaga terpisah di lapisan data, seperti yang sudah saya bahas di artikel sebelumnya, dan soal kapasitas origin yang perlu diawasi selama sale berjalan sebaiknya mengikuti disiplin error budget seperti di tulisan SLO untuk tim kecil.
Checklist H-2 Sebelum 11.11
- Tetapkan angka kapasitas konkurensi untuk halaman checkout Anda berdasarkan kapasitas origin yang sudah diuji, bukan tebakan.
- Kalau membangun sendiri: pasang Lua script
JOIN,ADMIT,HEARTBEAT, lalu load test dengan ratusan sesi paralel dan verifikasi jumlah sesi aktif tidak pernah melebihi kapasitas. - Tentukan fail-open atau fail-closed untuk skenario Redis bermasalah, dan tulis eksplisit di kode, bukan dibiarkan sebagai default tersembunyi.
- Kalau memakai Cloudflare Waiting Room: baca dokumentasi resminya untuk opsi konfigurasi dan syarat paket terkini, lalu pastikan endpoint non-HTML seperti WebSocket punya aturan terpisah.
- Siapkan halaman tunggu yang jujur: tampilkan posisi dan perkiraan, jangan biarkan user menatap spinner tanpa informasi.
- Jalankan satu simulasi penuh dari antrian sampai checkout selesai sebelum jam sibuk sungguhan tiba.
Virtual waiting room bukan tentang membuat lonjakan trafik hilang. Lonjakannya tetap datang, dan kapasitas Anda tetap terbatas. Yang berubah hanyalah siapa yang mengambil keputusan soal urutan dan keadilan, apakah itu kode yang Anda tulis dan uji sendiri, atau konfigurasi di tangan vendor yang sudah terbukti di skala besar. Dua-duanya sah, asal dipilih dengan sadar sebelum jam nol 11.11, bukan sesudah antrean checkout mendadak penuh error.
Ditulis oleh Asti Larasati