System Design untuk Developer: Panduan Lengkap

# Asumsi:
# - 200 juta DAU (Daily Active Users)
# - Setiap user membaca 10 tweets/hari = 2 miliar reads/hari
# - Setiap user membuat 2 tweets/hari = 400 juta writes/hari

# Write per detik:
# 400,000,000 / 86,400 ≈ 4,629 writes/detik

# Read per detik:
# 2,000,000,000 / 86,400 ≈ 23,148 reads/detik

# Storage per hari (rata-rata tweet 300 bytes):
# 400,000,000 × 300 bytes = 120 GB/hari = 43.8 TB/tahun

# Bandwidth (read, 1 KB per tweet + metadata):
# 23,148 reads/detik × 1 KB = ~23 MB/detik ≈ 184 Mbps

# Kesimpulan:
# - Database perlu handle ~5K writes/detik → perlu sharding
# - Cache sangat krusial untuk 23K reads/detik
# - CDN untuk media (foto, video)
# - Message queue untuk async fanout tweet ke followers

# Primary server (postgresql.conf)
wal_level = replica
max_wal_senders = 5
wal_keep_size = '1GB'

# Replica server (postgresql.conf)
primary_conninfo = 'host=primary-db port=5432 user=replicator'
hot_standby = on

# Aplikasi: routing query ke primary/replica
import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient({
  datasources: {
    db: {
      url: process.env.DATABASE_URL  // Primary untuk write
    }
  }
});

// Untuk read-heavy operations, gunakan replica
const readPrisma = new PrismaClient({
  datasources: {
    db: {
      url: process.env.DATABASE_REPLICA_URL  // Replica untuk read
    }
  }
});

// Write ke primary
await prisma.user.create({ data: { name: 'Budi' } });

// Read dari replica
const users = await readPrisma.user.findMany();

import Redis from 'ioredis';
const redis = new Redis();

// ============================================
// PATTERN 1: Cache-Aside (Lazy Loading)
// ============================================
async function getUserById(id: string) {
  const cacheKey = `user:${id}`;

  // 1. Check cache dulu
  const cached = await redis.get(cacheKey);
  if (cached) {
    console.log('Cache HIT');
    return JSON.parse(cached);
  }

  // 2. Cache miss → query database
  console.log('Cache MISS');
  const user = await db.user.findUnique({ where: { id } });

  // 3. Simpan ke cache (TTL 5 menit)
  if (user) {
    await redis.setex(cacheKey, 300, JSON.stringify(user));
  }

  return user;
}

// ============================================
// PATTERN 2: Write-Through
// ============================================
async function updateUser(id: string, data: UserUpdate) {
  // 1. Update database
  const user = await db.user.update({ where: { id }, data });

  // 2. Langsung update cache
  await redis.setex(`user:${id}`, 300, JSON.stringify(user));

  return user;
}

// ============================================
// PATTERN 3: Cache Invalidation
// ============================================
async function deleteUser(id: string) {
  await db.user.delete({ where: { id } });
  // Hapus dari cache
  await redis.del(`user:${id}`);
}

// ============================================
// PATTERN 4: Cache Stampede Prevention
// ============================================
async function getPopularProducts() {
  const cacheKey = 'popular:products';
  const ttl = 3600; // 1 jam

  let data = await redis.get(cacheKey);
  if (data) return JSON.parse(data);

  // Gunakan lock untuk hindari stampede
  const lockKey = `${cacheKey}:lock`;
  const locked = await redis.set(lockKey, '1', 'NX', 'EX', 30);

  if (locked) {
    const products = await db.product.findMany({
      orderBy: { views: 'desc' },
      take: 50
    });
    await redis.setex(cacheKey, ttl, JSON.stringify(products));
    await redis.del(lockKey);
    return products;
  }

  // Tunggu sebentar lalu coba dari cache lagi
  await new Promise(r => setTimeout(r, 100));
  return getPopularProducts();
}

import amqplib from 'amqplib';

// === PRODUCER: Mengirim pesan ke queue ===
async function sendOrderNotification(order: Order) {
  const conn = await amqplib.connect('amqp://localhost');
  const channel = await conn.createChannel();

  const queue = 'order_notifications';
  await channel.assertQueue(queue, { durable: true });

  const message = {
    type: 'ORDER_CREATED',
    data: {
      orderId: order.id,
      userId: order.userId,
      total: order.total,
      timestamp: new Date().toISOString()
    }
  };

  channel.sendToQueue(queue, Buffer.from(JSON.stringify(message)), {
    persistent: true  // Pesan tetap ada walau RabbitMQ restart
  });

  console.log('Order notification sent:', order.id);
  await channel.close();
  await conn.close();
}

// === CONSUMER: Memproses pesan dari queue ===
async function processOrderNotifications() {
  const conn = await amqplib.connect('amqp://localhost');
  const channel = await conn.createChannel();

  const queue = 'order_notifications';
  await channel.assertQueue(queue, { durable: true });

  // Prefetch: proses 1 pesan sekaligus
  channel.prefetch(1);

  console.log('Waiting for order notifications...');

  channel.consume(queue, async (msg) => {
    if (!msg) return;

    const { type, data } = JSON.parse(msg.content.toString());

    try {
      switch (type) {
        case 'ORDER_CREATED':
          await sendEmail(data.userId, 'Order confirmed!');
          await updateAnalytics(data);
          await notifyWarehouse(data.orderId);
          break;
      }

      // Acknowledge: pesan berhasil diproses
      channel.ack(msg);
    } catch (error) {
      // Reject & requeue: pesan akan diproses ulang
      channel.nack(msg, false, true);
    }
  });
}

enum CircuitState {
  CLOSED = 'CLOSED',     // Normal — request lewat
  OPEN = 'OPEN',         // Gagal terus — block request
  HALF_OPEN = 'HALF_OPEN' // Testing — coba beberapa request
}

class CircuitBreaker {
  private state = CircuitState.CLOSED;
  private failureCount = 0;
  private lastFailureTime = 0;
  private readonly threshold = 5;         // Max failures
  private readonly timeout = 30000;       // 30 detik cooldown

  async call(fn: () => Promise): Promise {
    if (this.state === CircuitState.OPEN) {
      if (Date.now() - this.lastFailureTime > this.timeout) {
        this.state = CircuitState.HALF_OPEN;
      } else {
        throw new Error('Circuit is OPEN — service unavailable');
      }
    }

    try {
      const result = await fn();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
      throw error;
    }
  }

  private onSuccess() {
    this.failureCount = 0;
    this.state = CircuitState.CLOSED;
  }

  private onFailure() {
    this.failureCount++;
    this.lastFailureTime = Date.now();
    if (this.failureCount >= this.threshold) {
      this.state = CircuitState.OPEN;
    }
  }
}

// Penggunaan
const paymentBreaker = new CircuitBreaker();
const result = await paymentBreaker.call(() =>
  paymentService.processPayment(orderId, amount)
);

-- Redis Lua script: Token Bucket Rate Limiter
-- KEYS[1] = rate_limit:{user_id}
-- ARGV[1] = max_tokens (e.g., 100)
-- ARGV[2] = refill_rate (e.g., 10 per second)
-- ARGV[3] = current_timestamp

local key = KEYS[1]
local max_tokens = tonumber(ARGV[1])
local refill_rate = tonumber(ARGV[2])
local now = tonumber(ARGV[3])

local data = redis.call('HMGET', key, 'tokens', 'last_refill')
local tokens = tonumber(data[1]) or max_tokens
local last_refill = tonumber(data[2]) or now

-- Refill tokens
local elapsed = now - last_refill
local new_tokens = math.min(max_tokens, tokens + elapsed * refill_rate)

if new_tokens >= 1 then
  -- Consume 1 token
  redis.call('HMSET', key, 'tokens', new_tokens - 1, 'last_refill', now)
  redis.call('EXPIRE', key, 3600)
  return 1  -- Allowed
else
  redis.call('HMSET', key, 'tokens', new_tokens, 'last_refill', now)
  return 0  -- Rate limited
end