karawaci.kode

2026-10-07 · 13 min

Cegah Overselling Flash Sale: Stok Atomic di PostgreSQL & Redis

Tiga hari lagi Harbolnas 10.10. Di banyak tim e-commerce, minggu ini adalah minggu ketika semua orang tiba-tiba peduli pada satu kolom integer bernama stock. Masalah yang paling sering muncul bukan server tumbang, melainkan sesuatu yang lebih memalukan: 100 unit dijual ke 140 orang. Artikel ini membahas cara mencegah overselling flash sale dengan tiga teknik yang bisa Anda pasang sebelum Jumat: UPDATE bersyarat di PostgreSQL, SELECT ... FOR UPDATE, dan reservasi stok di Redis memakai Lua script dengan TTL.

Saya tidak akan berhenti di teori. Semua kode di bawah saya jalankan terhadap PostgreSQL 17 dan Redis, lalu saya tembak dengan 1.000 pembeli serentak untuk 100 unit stok. Hasilnya ada di bagian load test, termasuk versi “naif” yang gagal dengan cara yang cukup spektakuler.

Anatomi Race Condition Stok E-commerce: Read-then-Write di ORM

Hampir semua kasus overselling yang saya temui berawal dari pola yang sama. Kodenya terlihat wajar, lolos code review, dan lolos test karena test tidak pernah berjalan paralel. Versi Prisma-nya kira-kira begini:

// JANGAN DITIRU
await prisma.$transaction(async (tx) => {
  const product = await tx.product.findUniqueOrThrow({ where: { id: productId } });
  if (product.stock < qty) throw new Error("SOLD_OUT");

  await tx.product.update({
    where: { id: productId },
    data: { stock: product.stock - qty }, // nilai dihitung di aplikasi
  });
  await tx.order.create({ data: { productId, userId, qty } });
});

Pola ini disebut read-then-write. Aplikasi membaca stok, memutuskan di memori, lalu menulis nilai hasil hitungannya sendiri. Masalahnya ada di celah antara baca dan tulis. Dengan dua pembeli yang datang hampir bersamaan, urutannya bisa seperti ini:

WaktuRequest ARequest B
t1SELECT stock → 100
t2SELECT stock → 100
t3cek 100 >= 1, loloscek 100 >= 1, lolos
t4UPDATE stock = 99, insert order
t5COMMITUPDATE stock = 99 (menunggu A, lalu jalan), insert order
t6COMMIT

Dua pesanan tercatat, stok hanya berkurang satu. Ini disebut lost update. Transaksi tidak menolong karena di isolation level default PostgreSQL, READ COMMITTED, SELECT biasa tidak mengunci apa pun. Yang perlu dicatat: B memang menunggu A di t5 karena keduanya meng-UPDATE baris yang sama, tetapi B menulis angka 99 yang sudah ia hitung sebelumnya, bukan menghitung ulang.

Dua hal yang sering disalahpahami:

  1. CHECK (stock >= 0) tidak menyelamatkan Anda dari pola ini. Stok tidak pernah minus, karena yang terjadi adalah penjualan yang hilang dari hitungan, bukan pengurangan berlebih. Constraint itu tetap wajib dipasang sebagai jaring pengaman terakhir, tetapi bukan solusi.
  2. data: { stock: { decrement: qty } } di Prisma sudah atomic, tetapi belum aman. Ia diterjemahkan menjadi SET stock = stock - qty, jadi tidak ada lost update. Namun tanpa syarat, pengecekan stock < qty di aplikasi masih memakai data basi, dan stok bisa turun di bawah nol. Kalau ada CHECK, request yang kalah akan gagal dengan constraint violation. Itu masih lebih baik daripada oversell, tetapi tetap bukan cara yang rapi untuk menolak pembeli.

Untuk semua contoh di artikel ini, skemanya sengaja dibuat minimal:

CREATE TABLE products (
  id    BIGINT PRIMARY KEY,
  sku   TEXT NOT NULL UNIQUE,
  stock INTEGER NOT NULL CHECK (stock >= 0)
);

CREATE TABLE orders (
  id             BIGSERIAL PRIMARY KEY,
  product_id     BIGINT NOT NULL REFERENCES products(id),
  user_id        BIGINT NOT NULL,
  qty            INTEGER NOT NULL CHECK (qty > 0),
  reservation_id TEXT UNIQUE,
  created_at     TIMESTAMPTZ NOT NULL DEFAULT now()
);

CREATE INDEX idx_orders_user_product ON orders (user_id, product_id);

Dan satu helper transaksi dengan pg yang dipakai ulang di semua contoh:

// src/db.ts
import { Pool, PoolClient } from "pg";

export const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
  max: 20,
});

export async function withTx<T>(fn: (c: PoolClient) => Promise<T>): Promise<T> {
  const client = await pool.connect();
  try {
    await client.query("BEGIN");
    const result = await fn(client);
    await client.query("COMMIT");
    return result;
  } catch (err) {
    await client.query("ROLLBACK");
    throw err;
  } finally {
    client.release();
  }
}

Kalau pool koneksi Anda belum disetel untuk lonjakan trafik, baca juga catatan saya soal connection pooling PostgreSQL dengan PgBouncer. Flash sale adalah ujian pertama yang akan dirasakan oleh pool Anda.

Opsi 1: UPDATE Bersyarat (WHERE stock >= qty)

Ini solusi yang paling sering saya rekomendasikan, karena pengecekan dan pengurangan stok dipindahkan ke dalam satu statement:

// src/conditional.ts
import { withTx } from "./db";

export async function checkoutConditional(productId: number, userId: number, qty: number) {
  return withTx(async (c) => {
    const dec = await c.query(
      `UPDATE products
          SET stock = stock - $2
        WHERE id = $1 AND stock >= $2
        RETURNING stock`,
      [productId, qty]
    );
    if (dec.rowCount === 0) return false; // stok habis atau tidak cukup

    await c.query(
      "INSERT INTO orders (product_id, user_id, qty) VALUES ($1, $2, $3)",
      [productId, userId, qty]
    );
    return true;
  });
}

Kenapa ini aman meski tetap di READ COMMITTED? Ketika dua transaksi meng-UPDATE baris yang sama, yang datang belakangan menunggu row lock dilepas. Setelah transaksi pertama commit, PostgreSQL mengevaluasi ulang klausa WHERE terhadap versi baris terbaru sebelum menerapkan update. Kalau stok sudah 0, syarat stock >= $2 gagal, baris tidak ter-update, dan rowCount bernilai 0. Tidak ada celah baca-tulis, karena keduanya terjadi dalam satu operasi di bawah row lock.

Versi ORM-nya juga ada. Di Prisma, gunakan updateMany karena update biasa hanya menerima filter unik:

const { count } = await prisma.product.updateMany({
  where: { id: productId, stock: { gte: qty } },
  data: { stock: { decrement: qty } },
});
if (count === 0) throw new Error("SOLD_OUT");

Kelebihannya jelas: satu round trip untuk stok, lock dipegang sesingkat mungkin, dan tidak ada logika aplikasi yang bisa salah. Satu hal yang wajib dijaga: jangan memanggil API eksternal di dalam transaksi ini. Row lock baru dilepas saat commit. Kalau Anda memanggil payment gateway di tengah transaksi, semua pembeli SKU itu ikut mengantre di belakang latency payment gateway.

Opsi 2: SELECT ... FOR UPDATE di PostgreSQL

UPDATE bersyarat mulai kewalahan ketika keputusan butuh lebih dari satu angka. Contoh yang realistis untuk flash sale: keranjang berisi beberapa SKU yang harus berhasil semua atau batal semua, ditambah batas “maksimal 2 unit per pembeli”. Batas per user ini sebenarnya race condition kedua. Kalau satu orang menekan tombol beli dari tiga tab sekaligus, pengecekan SUM(qty) di tiap tab bisa sama-sama melihat angka 0.

Di sinilah select for update postgresql berguna: kunci baris produk dulu, baru putuskan.

// src/for-update.ts
import { withTx } from "./db";

type CartItem = { productId: number; qty: number };
const MAX_PER_USER = 2; // batas pembelian per user per produk flash sale

export async function checkoutCart(userId: number, items: CartItem[]) {
  // Gabungkan item duplikat, lalu urutkan id supaya urutan lock selalu sama
  const wanted = new Map<number, number>();
  for (const it of items) wanted.set(it.productId, (wanted.get(it.productId) ?? 0) + it.qty);
  const ids = [...wanted.keys()].sort((a, b) => a - b);

  return withTx(async (c) => {
    await c.query("SET LOCAL lock_timeout = '3s'");

    const { rows } = await c.query<{ id: string; stock: number }>(
      `SELECT id, stock FROM products
        WHERE id = ANY($1::bigint[])
        ORDER BY id
        FOR UPDATE`,
      [ids]
    );
    if (rows.length !== ids.length) return false; // ada produk yang tidak ada

    // Baris produk sudah terkunci: checkout lain untuk produk yang sama
    // menunggu di sini, jadi pengecekan di bawah aman dari race.
    const bought = await c.query<{ product_id: string; total: string }>(
      `SELECT product_id, SUM(qty) AS total FROM orders
        WHERE user_id = $1 AND product_id = ANY($2::bigint[])
        GROUP BY product_id`,
      [userId, ids]
    );
    const boughtById = new Map(bought.rows.map((r) => [Number(r.product_id), Number(r.total)]));

    for (const row of rows) {
      const id = Number(row.id);
      const qty = wanted.get(id)!;
      if (row.stock < qty) return false;
      if ((boughtById.get(id) ?? 0) + qty > MAX_PER_USER) return false;
    }

    for (const id of ids) {
      const qty = wanted.get(id)!;
      await c.query("UPDATE products SET stock = stock - $2 WHERE id = $1", [id, qty]);
      await c.query(
        "INSERT INTO orders (product_id, user_id, qty) VALUES ($1, $2, $3)",
        [id, userId, qty]
      );
    }
    return true;
  });
}

Tiga detail yang membuat kode ini layak produksi:

  • ORDER BY id sebelum FOR UPDATE. Kalau pembeli X mengunci produk 1 lalu 2, sementara pembeli Y mengunci 2 lalu 1, keduanya bisa saling menunggu sampai PostgreSQL mendeteksi deadlock dan membatalkan salah satunya. Urutan lock yang selalu sama menghilangkan kemungkinan itu. Saya menguji 50 checkout serentak dengan urutan item keranjang yang dibolak-balik, dan tidak ada satu pun deadlock.
  • SET LOCAL lock_timeout = '3s'. Tanpa ini, request bisa menunggu lock selama apa pun yang dibutuhkan, sementara koneksi pool-nya tertahan. Lebih baik gagal cepat dengan pesan “coba lagi” daripada membuat seluruh pool habis. SET LOCAL hanya berlaku untuk transaksi ini.
  • bigint dari pg datang sebagai string. Karena itu ada Number(row.id). Untuk id yang aman di rentang integer JavaScript, ini cukup.

Harga yang dibayar: lock dipegang lebih lama karena ada beberapa query di antara SELECT ... FOR UPDATE dan COMMIT. Untuk satu SKU yang diserbu ribuan orang, semua request itu mengantre satu per satu di satu baris. Itu yang disebut hot row, dan itu alasan utama lapisan berikutnya ada.

Kalau Anda ingin menolak cepat alih-alih mengantre, ada FOR UPDATE NOWAIT yang langsung error ketika baris sedang dikunci. Jangan memakai SKIP LOCKED untuk stok. Opsi itu cocok untuk antrean job, tetapi untuk produk ia akan diam-diam melewati baris yang Anda butuhkan.

Opsi 3: Reservasi Stok Checkout via Redis Lua Script dengan TTL

Dua opsi di atas mengurangi stok saat order dibuat. Di dunia nyata, flash sale punya fase di antara klik “Beli” dan pembayaran sukses: pembeli memilih metode bayar, membuka aplikasi bank, atau menunggu virtual account. Kalau stok baru dikurangi saat bayar, 1.000 orang bisa sampai di halaman pembayaran untuk 100 unit, dan 900 di antaranya kecewa setelah transfer. Kalau stok dikurangi saat klik dan tidak pernah dikembalikan, checkout yang ditinggal akan mengunci stok selamanya.

Jawabannya adalah reservasi stok checkout dengan batas waktu: unit ditahan, misalnya, 10 menit. Kalau tidak dibayar, unit kembali ke pool. Redis cocok untuk ini karena Lua script dieksekusi secara atomic, dan tidak ada perintah lain yang bisa menyelip di tengahnya.

Desain key per SKU:

  • stock:{SKU}: string integer, jumlah unit yang masih bisa direservasi.
  • resv:{SKU}: sorted set, member = reservation id, score = deadline dalam milidetik.
  • resvqty:{SKU}: hash, reservation id → qty.

Kurung kurawal {SKU} adalah hash tag. Di Redis Cluster, semua key yang disentuh satu script harus berada di slot yang sama, dan hash tag memastikan ketiganya selalu bertetangga.

Kenapa tidak cukup SET resv:abc 1 PX 600000? Karena key yang expired hanya hilang, tanpa mengembalikan stok. Keyspace notification bisa memberi tahu saat key expired, tetapi itu pub/sub fire-and-forget. Kalau subscriber Anda sedang restart, event-nya hilang dan stok tidak pernah kembali. Jadi TTL di sini disimpan sebagai deadline di sorted set, lalu disapu secara atomic.

// src/stock-redis.ts
import Redis, { Result } from "ioredis";

// Semua key satu SKU memakai hash tag {sku} agar berada di slot yang sama (Redis Cluster)
const keys = (sku: string) => [`stock:{${sku}}`, `resv:{${sku}}`, `resvqty:{${sku}}`];

// Kembalikan stok dari reservasi yang sudah lewat deadline (maks. 100 per panggilan)
const REAP = `
local t = redis.call('TIME')
local now = tonumber(t[1]) * 1000 + math.floor(tonumber(t[2]) / 1000)
local expired = redis.call('ZRANGEBYSCORE', KEYS[2], '-inf', now, 'LIMIT', 0, 100)
for _, id in ipairs(expired) do
  local q = tonumber(redis.call('HGET', KEYS[3], id) or '0')
  redis.call('INCRBY', KEYS[1], q)
  redis.call('HDEL', KEYS[3], id)
  redis.call('ZREM', KEYS[2], id)
end
return #expired
`;

// ARGV[1] = reservationId, ARGV[2] = qty, ARGV[3] = ttl (ms)
// Return: 1 = berhasil (atau sudah pernah), 0 = stok tidak cukup, -1 = stok belum dimuat
const RESERVE = `
if redis.call('HEXISTS', KEYS[3], ARGV[1]) == 1 then return 1 end
local stock = tonumber(redis.call('GET', KEYS[1]) or '-1')
if stock < 0 then return -1 end
local qty = tonumber(ARGV[2])
if stock < qty then return 0 end
local t = redis.call('TIME')
local now = tonumber(t[1]) * 1000 + math.floor(tonumber(t[2]) / 1000)
redis.call('DECRBY', KEYS[1], qty)
redis.call('HSET', KEYS[3], ARGV[1], qty)
redis.call('ZADD', KEYS[2], now + tonumber(ARGV[3]), ARGV[1])
return 1
`;

// Pembayaran sukses: reservasi jadi permanen. 1 = ok, 0 = sudah kedaluwarsa/tidak ada
const CONFIRM = `
if redis.call('HEXISTS', KEYS[3], ARGV[1]) == 0 then return 0 end
redis.call('HDEL', KEYS[3], ARGV[1])
redis.call('ZREM', KEYS[2], ARGV[1])
return 1
`;

// Checkout dibatalkan: kembalikan stok. 1 = dikembalikan, 0 = tidak ada
const RELEASE = `
local q = redis.call('HGET', KEYS[3], ARGV[1])
if not q then return 0 end
redis.call('INCRBY', KEYS[1], tonumber(q))
redis.call('HDEL', KEYS[3], ARGV[1])
redis.call('ZREM', KEYS[2], ARGV[1])
return 1
`;

declare module "ioredis" {
  interface RedisCommander<Context> {
    reapStock(k1: string, k2: string, k3: string): Result<number, Context>;
    reserveStock(k1: string, k2: string, k3: string, id: string, qty: number, ttlMs: number): Result<number, Context>;
    confirmStock(k1: string, k2: string, k3: string, id: string): Result<number, Context>;
    releaseStock(k1: string, k2: string, k3: string, id: string): Result<number, Context>;
  }
}

export const redis = new Redis(process.env.REDIS_URL ?? "redis://localhost:6379");
redis.defineCommand("reapStock", { numberOfKeys: 3, lua: REAP });
redis.defineCommand("reserveStock", { numberOfKeys: 3, lua: RESERVE });
redis.defineCommand("confirmStock", { numberOfKeys: 3, lua: CONFIRM });
redis.defineCommand("releaseStock", { numberOfKeys: 3, lua: RELEASE });

export async function loadStock(sku: string, stock: number) {
  // NX: jangan menimpa stok yang sedang berjalan kalau skrip ini terpanggil dua kali
  await redis.set(`stock:{${sku}}`, stock, "NX");
}

export async function reserve(sku: string, reservationId: string, qty: number, ttlMs = 10 * 60_000) {
  const [s, z, h] = keys(sku);
  await redis.reapStock(s, z, h); // bersihkan reservasi basi dulu (lazy reclaim)
  return redis.reserveStock(s, z, h, reservationId, qty, ttlMs);
}

export async function confirm(sku: string, reservationId: string) {
  const [s, z, h] = keys(sku);
  return redis.confirmStock(s, z, h, reservationId);
}

export async function release(sku: string, reservationId: string) {
  const [s, z, h] = keys(sku);
  return redis.releaseStock(s, z, h, reservationId);
}

// Jalankan di satu worker: menyapu reservasi kedaluwarsa tiap 2 detik
export function startReaper(skus: string[], intervalMs = 2000) {
  return setInterval(async () => {
    for (const sku of skus) {
      const [s, z, h] = keys(sku);
      await redis.reapStock(s, z, h).catch((err) => console.error("reap gagal", sku, err));
    }
  }, intervalMs);
}

Beberapa keputusan desain di redis lua script stok ini yang patut dijelaskan:

  • Waktu diambil dari redis.call('TIME'), bukan dari aplikasi. Kalau tiap server aplikasi mengirim Date.now() sendiri, selisih jam antar-server ikut menentukan kapan reservasi kedaluwarsa. Dengan satu sumber waktu, masalah itu hilang. Sejak Redis 7, replikasi script memakai mode effects replication, jadi memanggil TIME di dalam script aman untuk replika.
  • RESERVE idempoten per reservation id. Kalau klien me-retry karena timeout jaringan, unit tidak diambil dua kali. Gunakan id yang dibuat sekali per sesi checkout, misalnya UUID yang disimpan di order PENDING.
  • REAP dibatasi 100 item per panggilan. Lua script memblokir Redis selama berjalan. Script yang menyapu puluhan ribu reservasi sekaligus akan membuat semua klien lain menunggu. Lebih baik sering dan pendek.
  • Return -1 kalau stok belum dimuat. Ini membedakan “habis” dari “lupa menjalankan loadStock”. Yang kedua harus memicu alert, bukan pesan “stok habis” ke pembeli.

Saat pembayaran sukses: Postgres tetap penjaga terakhir

Redis adalah gerbang, bukan sumber kebenaran. Ketika webhook pembayaran masuk, pengurangan stok yang permanen tetap terjadi di Postgres dengan UPDATE bersyarat:

// src/payment.ts
import { withTx } from "./db";
import { redis, confirm, release } from "./stock-redis";

class SoldOutError extends Error {}

type Paid = { sku: string; productId: number; userId: number; qty: number; reservationId: string };

export async function onPaymentSuccess(p: Paid) {
  // 1. Postgres = penjaga terakhir: idempoten lewat reservation_id, stok lewat UPDATE bersyarat
  const result = await withTx(async (c) => {
    const ins = await c.query(
      `INSERT INTO orders (product_id, user_id, qty, reservation_id)
       VALUES ($1, $2, $3, $4)
       ON CONFLICT (reservation_id) DO NOTHING
       RETURNING id`,
      [p.productId, p.userId, p.qty, p.reservationId]
    );
    if (ins.rowCount === 0) return "duplicate" as const; // webhook terkirim ulang

    const dec = await c.query(
      "UPDATE products SET stock = stock - $2 WHERE id = $1 AND stock >= $2",
      [p.productId, p.qty]
    );
    if (dec.rowCount === 0) throw new SoldOutError(); // rollback, order batal
    return "paid" as const;
  }).catch((err) => {
    if (err instanceof SoldOutError) return "refund" as const; // + kirim alert
    throw err;
  });

  // 2. Reservasi di Redis dijadikan permanen
  if (result === "paid" && (await confirm(p.sku, p.reservationId)) === 0) {
    // Reservasi sempat kedaluwarsa dan unitnya sudah kembali ke Redis: tarik lagi
    await redis.decrby(`stock:{${p.sku}}`, p.qty);
  }
  if (result === "refund") await release(p.sku, p.reservationId);
  return result;
}

Urutan langkahnya disengaja. Postgres diproses dulu, Redis belakangan. Kalau proses mati di antara keduanya, yang terjadi adalah Redis mencatat stok lebih sedikit atau lebih banyak sementara, dan Postgres tetap menolak penjualan yang melebihi stok fisik. Sistemnya gagal ke arah undersell atau refund, bukan oversell. Selisih seperti ini dibereskan dengan rekonsiliasi setelah sale selesai.

ON CONFLICT (reservation_id) DO NOTHING menangani webhook yang dikirim berkali-kali. Saya menguji empat webhook identik yang datang serentak: satu menghasilkan paid, tiga lainnya duplicate, dan stok hanya berkurang satu. Untuk pola idempotency webhook yang lebih lengkap, termasuk verifikasi signature dan dead-letter queue, lihat tulisan saya soal webhook reliability.

Satu keputusan bisnis yang harus Anda ambil sendiri: apa yang terjadi kalau pembayaran masuk setelah reservasi kedaluwarsa? Kode di atas tetap menerimanya selama stok di Postgres masih ada, dan baru me-refund kalau benar-benar habis. Sebagian tim memilih menolak semua pembayaran yang terlambat agar aturannya mudah dijelaskan. Keduanya sah, asalkan dipilih dengan sadar dan tertulis di syarat promo.

Load Test Singkat: Membuktikan Tidak Ada Overselling

Klaim “aman dari race condition” tanpa uji paralel hanyalah harapan. Skrip berikut mengosongkan tabel, mengisi 100 unit, lalu menembakkan 1.000 percobaan beli secara serentak ke tiap strategi. Versi naif di bawah adalah padanan SQL mentah dari contoh Prisma di awal artikel (SELECT stock, lalu UPDATE products SET stock = $2 dengan nilai hasil hitungan aplikasi):

// src/naive.ts
import { withTx } from "./db";

// JANGAN DITIRU: read-then-write, persis pola ORM pada umumnya
export async function checkoutNaive(productId: number, userId: number, qty: number) {
  return withTx(async (c) => {
    const { rows } = await c.query<{ stock: number }>(
      "SELECT stock FROM products WHERE id = $1",
      [productId]
    );
    if (rows.length === 0 || rows[0].stock < qty) return false;

    await c.query("UPDATE products SET stock = $2 WHERE id = $1", [
      productId,
      rows[0].stock - qty,
    ]);
    await c.query(
      "INSERT INTO orders (product_id, user_id, qty) VALUES ($1, $2, $3)",
      [productId, userId, qty]
    );
    return true;
  });
}

Dan skrip load test-nya:

// src/loadtest.ts
import { randomUUID } from "node:crypto";
import { pool } from "./db";
import { checkoutNaive } from "./naive";
import { checkoutConditional } from "./conditional";
import { checkoutCart } from "./for-update";
import { redis, loadStock, reserve, confirm } from "./stock-redis";

const STOCK = 100;
const BUYERS = 1000;

async function reset() {
  await pool.query("TRUNCATE orders RESTART IDENTITY");
  await pool.query("DELETE FROM products");
  await pool.query("INSERT INTO products (id, sku, stock) VALUES (1, 'FS-1010', $1)", [STOCK]);
}

async function report(label: string, ok: number, ms: number) {
  const { rows } = await pool.query(
    `SELECT (SELECT stock FROM products WHERE id = 1) AS stock,
            (SELECT COALESCE(SUM(qty), 0)::int FROM orders) AS sold`
  );
  const { stock, sold } = rows[0];
  const verdict = sold <= STOCK && stock + sold === STOCK ? "AMAN" : "OVERSELL";
  console.log(`${label.padEnd(14)} sukses=${ok} terjual=${sold} sisa=${stock} ${ms}ms -> ${verdict}`);
}

async function run(label: string, attempt: (userId: number) => Promise<boolean | number>) {
  await reset();
  const t0 = Date.now();
  const results = await Promise.allSettled(
    Array.from({ length: BUYERS }, (_, i) => attempt(i + 1))
  );
  const ok = results.filter((r) => r.status === "fulfilled" && r.value === true).length;
  await report(label, ok, Date.now() - t0);
}

async function redisFlow(userId: number) {
  const id = randomUUID();
  if ((await reserve("FS-1010", id, 1)) !== 1) return false;
  // ... user membayar ... webhook payment sukses masuk:
  if ((await confirm("FS-1010", id)) !== 1) return false;
  return checkoutConditional(1, userId, 1); // pengurangan permanen di Postgres
}

async function main() {
  await run("naive", (u) => checkoutNaive(1, u, 1));
  await run("conditional", (u) => checkoutConditional(1, u, 1));
  await run("for-update", (u) => checkoutCart(u, [{ productId: 1, qty: 1 }]));

  await redis.del("stock:{FS-1010}", "resv:{FS-1010}", "resvqty:{FS-1010}");
  await loadStock("FS-1010", STOCK);
  await run("redis+pg", redisFlow);
  console.log("sisa stok di Redis:", await redis.get("stock:{FS-1010}"));

  await pool.end();
  redis.disconnect();
}

main();

Jalankan dengan DATABASE_URL=... REDIS_URL=... npx tsx src/loadtest.ts. Ini output salah satu run di laptop saya, dengan PostgreSQL 17 di Docker, Redis lokal, dan pool 20 koneksi:

naive          sukses=1000 terjual=1000 sisa=42 1954ms -> OVERSELL
conditional    sukses=100 terjual=100 sisa=0 256ms -> AMAN
for-update     sukses=100 terjual=100 sisa=0 1336ms -> AMAN
redis+pg       sukses=100 terjual=100 sisa=0 112ms -> AMAN
sisa stok di Redis: 0

Angka milidetik dan sisa stok versi naif berubah setiap run dan bergantung pada mesin, jadi jangan dijadikan benchmark. Yang konsisten di setiap run saya adalah polanya:

  • Versi naif menjual 1.000 unit dari stok 100, dan stoknya bahkan tidak habis. Ini wujud nyata lost update. Setiap request menulis angka yang dihitung dari bacaan basi, sehingga sebagian besar pengurangan tertimpa. CHECK (stock >= 0) tidak pernah terpicu.
  • Ketiga strategi lain selalu tepat 100 terjual dan sisa 0.
  • for-update paling lambat karena lock dipegang selama beberapa query. Ini harga yang dibayar untuk logika batas per user.
  • redis+pg paling cepat karena 900 request yang kalah sudah ditolak di Redis tanpa menyentuh Postgres. Inilah manfaat lapisan Redis yang sebenarnya: bukan membuat stok lebih benar, tetapi melindungi database dari request yang pasti gagal.

Untuk uji di level HTTP, pola yang sama bisa dijalankan dengan k6 atau autocannon terhadap endpoint checkout Anda. Apa pun tool-nya, jangan menilai hasil dari jumlah respons 200. Nilailah dari database setelah test selesai:

SELECT p.stock AS sisa,
       COALESCE(SUM(o.qty), 0) AS terjual,
       p.stock + COALESCE(SUM(o.qty), 0) AS total
  FROM products p
  LEFT JOIN orders o ON o.product_id = p.id
 WHERE p.id = 1
 GROUP BY p.stock;

Kolom total harus sama persis dengan stok awal. Kalau lebih besar, Anda punya overselling, terlepas dari seberapa hijau dashboard load test-nya.

Kapan Cukup Postgres Saja, Kapan Butuh Lapisan Redis

Saya sering melihat tim langsung menambah Redis karena “flash sale itu harus pakai Redis”. Padahal setiap komponen tambahan adalah satu hal lagi yang bisa tidak sinkron saat jam 10.10 tepat. Kriteria yang saya pakai:

KondisiRekomendasi
Satu SKU per order, tanpa batas per user, trafik masih tertangani database AndaUPDATE bersyarat saja. Paling sederhana, paling sulit salah.
Keranjang multi-SKU, batas per user, aturan bundlingSELECT ... FOR UPDATE dengan urutan lock konsisten dan lock_timeout.
Butuh tahan stok selama pembeli membayar, tetapi trafik moderatReservasi di Postgres: tabel reservations dengan kolom expires_at, pengurangan via UPDATE bersyarat, dan job berkala yang mengembalikan stok dari reservasi kedaluwarsa.
Satu SKU diserbu jauh melebihi stok, connection pool sudah jenuh saat uji beban, atau perlu reservasi ber-TTL dalam jumlah besarRedis sebagai gerbang + Postgres sebagai penjaga terakhir, seperti di opsi 3.

Sinyal paling jelas bahwa Anda butuh Redis bukan jumlah pengunjung, melainkan rasio peminat terhadap stok pada satu SKU. Seribu orang berebut 100 unit berarti sekitar 90% request pasti gagal. Mengirim semuanya ke Postgres hanya untuk mendapat jawaban “habis” adalah pemborosan koneksi dan row lock, tepat di saat database paling dibutuhkan untuk transaksi yang berhasil.

Sebaliknya, kalau Anda memutuskan memakai Redis, terimalah konsekuensinya: Anda wajib memikirkan persistensi (AOF atau replika, agar restart tidak me-reset counter), memuat stok sebelum sale dimulai, menjalankan reaper, dan merekonsiliasi angka Redis dengan Postgres setelah sale selesai.

Checklist H-3 Sebelum 10.10

  1. Cari semua jalur kode yang mengurangi stok. Pastikan tidak ada lagi pola read-then-write yang menulis stock = <angka dari aplikasi>.
  2. Pasang CHECK (stock >= 0) sebagai jaring pengaman terakhir.
  3. Ganti pengurangan stok menjadi UPDATE bersyarat. Pakai FOR UPDATE hanya di jalur yang benar-benar butuh, misalnya batas per user dan keranjang multi-SKU.
  4. Pastikan tidak ada panggilan HTTP eksternal di dalam transaksi yang memegang lock stok.
  5. Kalau memakai Redis: muat stok sebelum sale, jalankan reaper, pakai hash tag untuk Cluster, dan pasang alert untuk return -1.
  6. Jalankan load test paralel dan verifikasi dengan query total = stok awal, bukan dengan jumlah respons 200.
  7. Siapkan query rekonsiliasi dan prosedur refund sebelum sale, bukan setelah ada yang komplain.

Overselling hampir tidak pernah disebabkan oleh trafik yang terlalu besar. Penyebabnya adalah celah beberapa milidetik antara membaca dan menulis, yang baru terlihat ketika ribuan orang menekan tombol yang sama di detik yang sama. Tutup celah itu di database, dan buktikan dengan test sebelum 10.10, bukan dengan laporan dari tim CS sesudahnya.

Ditulis oleh Reza Pradipta