Pola Desain API Gateway: Implementasi Algoritma Token Bucket dan Leaky Bucket dengan Redis

Arsitektur Rate Limiting Terdistribusi Berbasis Token Bucket & Redis:
Klien (Browser / Mobile / B2B)
       │
       ▼ [Request Masuk: GET /api/v1/orders]
┌──────────────────────────────────────────────┐
│  API Gateway (Kong / Traefik / Node.js)      │
│  1. Ekstrak Identitas (API Key / Client IP)  │
│  2. Kirim Perintah Atomik ke Redis via Lua   │
└──────┬───────────────────────────────────────┘
       │
       ▼ [EVAL sha_token_bucket.lua key limit capacity refill_rate]
┌──────────────────────────────────────────────┐
│  Redis In-Memory Data Store                  │
│  - Kapasitas Ember (Bucket Capacity): 100    │
│  - Laju Pengisian (Refill Rate): 10 token/dtk│
│  - Token Tersedia: 84                        │
└──────┬───────────────────────────────────────┘
       │
       ├── Jika Token > 0: Kurangi 1 token ──> [Teruskan Request ke Service Backend]
       │
       └── Jika Token = 0: TOLAK SEGERA ────> [HTTP 429 Too Many Requests]
                                                Header: Retry-After: 5

-- token_bucket.lua
local key = KEYS[1]
local capacity = tonumber(ARGV[1])    -- Kapasitas maksimum ember (burst limit)
local refill_rate = tonumber(ARGV[2]) -- Jumlah token bertambah per detik
local requested = tonumber(ARGV[3])   -- Jumlah token yang diminta (biasanya 1)
local now = tonumber(ARGV[4])         -- Waktu saat ini (epoch timestamp detik)

-- Ambil data state ember sebelumnya
local data = redis.call('HMGET', key, 'tokens', 'last_updated')
local tokens = tonumber(data[1])
local last_updated = tonumber(data[2])

if tokens == nil then
  -- Inisialisasi awal saat key pertama kali dibuat
  tokens = capacity
  last_updated = now
else
  -- Hitung pertambahan token berdasarkan selisih waktu yang berlalu
  local elapsed = math.max(0, now - last_updated)
  tokens = math.min(capacity, tokens + (elapsed * refill_rate))
  last_updated = now
end

if tokens >= requested then
  -- Token mencukupi: izinkan request dan kurangi token
  tokens = tokens - requested
  redis.call('HMSET', key, 'tokens', tokens, 'last_updated', last_updated)
  -- Set TTL otomatis agar Redis membersihkan kunci yang sudah tidak aktif
  redis.call('EXPIRE', key, math.ceil(capacity / refill_rate) * 2)
  return { 1, math.floor(tokens) } -- 1 = ALLOWED, tokens tersisa
else
  -- Token habis: tolak request
  redis.call('HMSET', key, 'tokens', tokens, 'last_updated', last_updated)
  return { 0, math.floor(tokens) } -- 0 = BLOCKED
end

// middleware/rateLimiter.ts
import { Request, Response, NextFunction } from 'express';
import Redis from 'ioredis';
import fs from 'fs';
import path from 'path';

const redis = new Redis(process.env.REDIS_URL || 'redis://127.0.0.1:6379');
const luaScript = fs.readFileSync(path.join(__dirname, 'token_bucket.lua'), 'utf8');

// Muat skrip ke Redis SHA script cache untuk eksekusi ultra cepat
let scriptSha: string;
redis.script('load', luaScript).then((sha) => {
  scriptSha = sha as string;
});

export async function tokenBucketRateLimiter(
  req: Request,
  res: Response,
  next: NextFunction
) {
  // 1. Identifikasi klien: Utamakan API Key, fallback ke IP asli Cloudflare
  const clientId = (req.headers['x-api-key'] as string) ||
                   (req.headers['cf-connecting-ip'] as string) ||
                   req.ip;

  const key = `ratelimit:client:${clientId}`;
  const capacity = 100;     // Maksimum burst 100 request
  const refillRate = 10;    // Isi ulang 10 token per detik
  const requested = 1;
  const now = Math.floor(Date.now() / 1000);

  try {
    const result = await redis.evalsha(
      scriptSha,
      1,
      key,
      capacity,
      refillRate,
      requested,
      now
    ) as [number, number];

    const isAllowed = result[0] === 1;
    const remainingTokens = result[1];

    // 2. Sematkan Header Standar IETF RFC 6585
    res.setHeader('X-RateLimit-Limit', capacity);
    res.setHeader('X-RateLimit-Remaining', remainingTokens);

    if (!isAllowed) {
      const retryAfterSeconds = Math.ceil((1 - remainingTokens) / refillRate);
      res.setHeader('Retry-After', Math.max(1, retryAfterSeconds));
      return res.status(429).json({
        error: 'Too Many Requests',
        message: 'Batas kuota akses API terlampaui. Silakan perlambat frekuensi permintaan Anda.',
        retry_after_seconds: Math.max(1, retryAfterSeconds),
      });
    }

    next();
  } catch (error) {
    // Fail-open strategy: Jika Redis down, jangan sampai sistem menolak pengguna sah
    console.error('[RateLimiter Error]', error);
    next();
  }
}