karawaci.kode

2026-10-13 · 12 min

Game Day Tim Kecil: Simulasi Gangguan dan Chaos Engineering dengan Toxiproxy

Tanggal 13 Oktober adalah Hari Pengurangan Risiko Bencana Internasional. Semangat peringatan itu sederhana: latihan evakuasi dilakukan saat cuaca cerah, bukan saat banjir sudah masuk rumah. Sistem backend juga sama. Kalau satu-satunya waktu Anda tahu bagaimana aplikasi bereaksi saat Postgres melambat adalah saat Postgres benar-benar melambat, berarti tim Anda sedang berlatih di tengah bencana. Artikel ini adalah panduan chaos engineering Toxiproxy untuk tim kecil: satu sesi game day, tiga orang, docker-compose, dan daftar hipotesis yang akan Anda buktikan atau patahkan sendiri.

Saya ingin jelas soal cakupannya. Ini bukan latihan failover multi-region. Itu sudah saya bahas di strategi multi-region deployment, dan butuh infrastruktur yang belum tentu dimiliki tim tiga orang. Yang diuji di sini lebih membumi dan jauh lebih sering terjadi: dependency yang masih hidup tapi melambat, macet, atau memutus koneksi. Database yang p99-nya tiba-tiba naik sepuluh kali lipat. Redis yang di-restart provider tanpa pemberitahuan. Koneksi TCP yang menggantung tanpa error. Itulah gangguan yang memeriksa apakah timeout, retry, dan degradasi fitur Anda benar-benar bekerja, atau hanya ada di kepala.

Kenapa Game Day, Bukan Menunggu Insiden

Hampir setiap service yang saya review punya asumsi resiliensi yang belum pernah diuji. “Kalau Redis mati, kita fallback ke database.” “Query punya timeout kok.” “Retry-nya cuma sekali.” Kalimat-kalimat itu biasanya benar di level niat, tapi sering salah di level konfigurasi. Default driver, urutan timeout, dan interaksi antara pool koneksi dan retry adalah tempat asumsi itu patah.

Game day memaksa asumsi menjadi hipotesis yang bisa diukur. Formatnya selalu sama:

Ketika [gangguan] terjadi pada [dependency], kami memperkirakan [perilaku sistem], yang terlihat dari [metrik atau log]. Kami menghentikan eksperimen kalau [batas berhenti].

Kalau hipotesisnya terbukti, Anda mendapat kepercayaan diri yang berbasis bukti. Kalau patah, Anda menemukan bug di hari Selasa siang dengan kopi di tangan, bukan Sabtu jam dua pagi.

Peran untuk Tim Tiga Orang

Tim kecil tidak butuh struktur rumit. Tiga peran ini cukup, dan rotasikan di game day berikutnya:

  • Pemandu: menyuntikkan gangguan sesuai skrip, menjaga waktu, dan memegang tombol reset. Ia satu-satunya yang boleh menyentuh Toxiproxy.
  • Pengamat: memantau log, hasil load probe, dan dashboard, lalu mencatat apa yang benar-benar terjadi dibanding hipotesis. Ia tidak memperbaiki apa pun selama skenario berjalan.
  • Responder: bertindak seperti engineer on-call. Ia tidak diberi tahu urutan skenario dan harus mendiagnosis dari sinyal yang ada. Ini menguji observability dan runbook, bukan hanya kode.

Batasi sesinya dua sampai tiga jam, dengan lima skenario. Lebih dari itu, fokus tim turun dan catatan jadi asal-asalan.

Toxiproxy Docker Compose: Menyiapkan Lab Gangguan

Toxiproxy adalah proxy TCP buatan Shopify yang dirancang khusus untuk mensimulasikan kondisi jaringan buruk. Aplikasi tidak lagi terhubung langsung ke Postgres dan Redis, melainkan ke Toxiproxy, yang meneruskan trafik ke dependency aslinya. Di tengah jalur itu, Anda bisa memasang “toxic”: latency, bandwidth terbatas, koneksi yang tidak pernah menjawab, atau reset koneksi. Semuanya dikontrol lewat HTTP API di port 8474.

Struktur folder lab:

gameday/
├── docker-compose.yml
├── toxiproxy.json
├── init.sql
├── chaos.sh
├── probe.mjs
└── app/
    ├── Dockerfile
    ├── package.json
    └── server.mjs

docker-compose.yml:

services:
  postgres:
    image: postgres:17
    environment:
      POSTGRES_USER: app
      POSTGRES_PASSWORD: app
      POSTGRES_DB: app
    volumes:
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql:ro
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U app -d app"]
      interval: 2s
      timeout: 2s
      retries: 15

  redis:
    image: redis:7

  toxiproxy:
    # Pin versi. Cek rilis terbaru di halaman GitHub Toxiproxy sebelum memakai.
    image: ghcr.io/shopify/toxiproxy:2.9.0
    command: ["-host=0.0.0.0", "-config=/config/toxiproxy.json"]
    volumes:
      - ./toxiproxy.json:/config/toxiproxy.json:ro
    ports:
      - "8474:8474"   # HTTP API untuk mengatur toxic
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_started

  app:
    build: ./app
    environment:
      # Aplikasi bicara ke Toxiproxy, bukan langsung ke dependency
      DATABASE_URL: postgres://app:app@toxiproxy:15432/app
      REDIS_URL: redis://toxiproxy:16379
    ports:
      - "3000:3000"
    depends_on:
      - toxiproxy

toxiproxy.json mendefinisikan dua proxy yang dibuat saat Toxiproxy start:

[
  {
    "name": "postgres",
    "listen": "0.0.0.0:15432",
    "upstream": "postgres:5432",
    "enabled": true
  },
  {
    "name": "redis",
    "listen": "0.0.0.0:16379",
    "upstream": "redis:6379",
    "enabled": true
  }
]

init.sql mengisi 100.000 produk. Jumlah ini sengaja dibuat besar supaya probe yang mengambil ID acak lebih sering kena cache miss dan benar-benar menyentuh database:

CREATE TABLE products (
  id       integer PRIMARY KEY,
  name     text    NOT NULL,
  price    integer NOT NULL,
  stock    integer NOT NULL,
  category text    NOT NULL
);

INSERT INTO products (id, name, price, stock, category)
SELECT g,
       'Produk ' || g,
       (random() * 500000)::int,
       (random() * 50)::int,
       'kat-' || (g % 20)
FROM generate_series(1, 100000) AS g;

CREATE INDEX products_category_idx ON products (category);

Aplikasi yang Diuji: Timeout, Retry, dan Degradasi

Aplikasinya kecil tapi mewakili pola yang umum: endpoint GET /products/:id membaca dari cache Redis, jatuh ke Postgres saat cache miss, lalu menambahkan daftar produk terkait sebagai fitur sekunder. Setiap keputusan resiliensi ditulis eksplisit supaya bisa diuji.

app/package.json:

{
  "name": "gameday-app",
  "private": true,
  "type": "module",
  "dependencies": {
    "ioredis": "^5.4.1",
    "pg": "^8.13.0"
  }
}

app/Dockerfile:

FROM node:22-alpine
WORKDIR /app
COPY package.json ./
RUN npm install --omit=dev
COPY server.mjs ./
CMD ["node", "server.mjs"]

app/server.mjs:

import http from 'node:http';
import pg from 'pg';
import Redis from 'ioredis';

const log = (evt, extra = {}) =>
  console.log(JSON.stringify({ t: new Date().toISOString(), evt, ...extra }));

// ---------- Postgres ----------
const pool = new pg.Pool({
  connectionString: process.env.DATABASE_URL,
  max: 10,
  connectionTimeoutMillis: 1000, // batas menunggu client dari pool atau membuka koneksi baru
  statement_timeout: 1000,       // sisi server: Postgres membatalkan query yang lebih lama
  query_timeout: 1500,           // sisi klien: berhenti menunggu jawaban, apa pun penyebabnya
  idleTimeoutMillis: 30000,
});

// Tanpa listener ini, koneksi idle yang diputus dari luar akan
// memicu event 'error' tanpa handler dan menjatuhkan proses Node.js.
pool.on('error', (err) => log('pg_idle_client_error', { msg: err.message }));

// ---------- Redis (cache, boleh gagal) ----------
const redis = new Redis(process.env.REDIS_URL, {
  connectTimeout: 500,
  commandTimeout: 100,       // cache yang lambat lebih buruk dari cache miss
  maxRetriesPerRequest: 1,
  enableOfflineQueue: false, // saat terputus, perintah langsung gagal, tidak diantrekan
  retryStrategy: (times) => Math.min(times * 200, 2000),
});
redis.on('error', (err) => log('redis_error', { msg: err.message }));

async function cacheGet(key) {
  try {
    const raw = await redis.get(key);
    return raw ? JSON.parse(raw) : null;
  } catch (err) {
    log('cache_get_failed', { key, msg: err.message });
    return null; // degradasi: perlakukan sebagai cache miss
  }
}

function cacheSet(key, value) {
  // Fire-and-forget: kegagalan menulis cache tidak boleh menggagalkan request
  redis
    .set(key, JSON.stringify(value), 'EX', 60)
    .catch((err) => log('cache_set_failed', { key, msg: err.message }));
}

// ---------- Retry dan deadline ----------
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

// Hanya error koneksi yang di-retry. Timeout TIDAK di-retry:
// dependency yang lambat tidak menjadi cepat karena diberi beban dua kali lipat.
function isRetryable(err) {
  return (
    ['ECONNREFUSED', 'ECONNRESET', 'EPIPE', '57P01'].includes(err.code) ||
    /Connection terminated/i.test(err.message)
  );
}

async function queryWithRetry(config) {
  try {
    return await pool.query(config);
  } catch (err) {
    if (!isRetryable(err)) throw err;
    log('pg_retry', { msg: err.message });
    await sleep(100 + Math.random() * 200); // jitter supaya retry tidak serempak
    return pool.query(config);
  }
}

function withDeadline(promise, ms, label) {
  let timer;
  const deadline = new Promise((_, reject) => {
    timer = setTimeout(() => reject(new Error(`${label} melewati deadline ${ms}ms`)), ms);
  });
  return Promise.race([promise, deadline]).finally(() => clearTimeout(timer));
}

// ---------- Logika endpoint ----------
async function getProduct(id) {
  const key = `product:${id}`;
  let product = await cacheGet(key);
  let source = 'cache';

  if (!product) {
    source = 'db';
    const { rows } = await queryWithRetry({
      text: 'SELECT id, name, price, stock, category FROM products WHERE id = $1',
      values: [id],
    });
    if (rows.length === 0) return null;
    product = rows[0];
    cacheSet(key, product);
  }

  // Fitur sekunder: produk terkait. Budget ketat, boleh gagal.
  let related = [];
  let degraded = null;
  try {
    const { rows } = await withDeadline(
      pool.query({
        text: 'SELECT id, name FROM products WHERE category = $1 AND id <> $2 LIMIT 4',
        values: [product.category, product.id],
        query_timeout: 300,
      }),
      350,
      'related'
    );
    related = rows;
  } catch (err) {
    degraded = 'related';
    log('related_degraded', { msg: err.message });
  }

  return { product, related, source, degraded };
}

// ---------- HTTP server ----------
const server = http.createServer(async (req, res) => {
  const url = new URL(req.url, 'http://localhost');

  // Liveness tidak menyentuh dependency. Lihat pembahasan di bawah.
  if (url.pathname === '/healthz') {
    res.writeHead(200).end('ok');
    return;
  }

  const match = url.pathname.match(/^\/products\/(\d+)$/);
  if (!match) {
    res.writeHead(404).end();
    return;
  }

  try {
    const result = await getProduct(Number(match[1]));
    if (!result) {
      res.writeHead(404, { 'content-type': 'application/json' }).end('{"error":"not_found"}');
      return;
    }
    const headers = { 'content-type': 'application/json', 'x-source': result.source };
    if (result.degraded) headers['x-degraded'] = result.degraded;
    res.writeHead(200, headers).end(JSON.stringify({ ...result.product, related: result.related }));
  } catch (err) {
    log('request_failed', { path: url.pathname, msg: err.message });
    res
      .writeHead(503, { 'content-type': 'application/json', 'retry-after': '5' })
      .end('{"error":"temporarily_unavailable"}');
  }
});

server.listen(3000, () => log('listening', { port: 3000 }));

Ada tiga detail di kode ini yang justru akan diuji di game day.

Pertama, pool.query, bukan pool.connect manual. Saat query gagal, pool.query melepas client dengan membawa error-nya, sehingga client itu dibuang dari pool, bukan dipakai ulang. Kalau Anda memakai pool.connect() lalu client.release() tanpa argumen setelah timeout, koneksi yang statusnya tidak jelas bisa kembali ke pool.

Kedua, query_timeout tidak menghitung waktu menunggu client dari pool. Timer-nya baru mulai saat query dikirim. Kalau pool sedang penuh atau koneksi baru lambat dibuka, waktu tunggu itu ditentukan connectionTimeoutMillis. Karena itu fitur sekunder dibungkus withDeadline: batas 350 ms itu berlaku untuk seluruh proses, dari menunggu pool sampai jawaban datang.

Ketiga, cache diperlakukan sebagai opsional. commandTimeout: 100 dan enableOfflineQueue: false memastikan Redis yang bermasalah berubah menjadi cache miss yang cepat, bukan request yang menggantung. Dengan default ioredis, perintah saat koneksi putus akan diantrekan dan di-retry sampai maxRetriesPerRequest (default 20) habis. Total waktunya bergantung pada retryStrategy, dan dalam kondisi umum bisa mencapai hitungan detik per request.

Alat Ukur: Skrip Gangguan dan Load Probe

Pemandu memakai chaos.sh, pembungkus tipis untuk HTTP API Toxiproxy. Dengan begini, setiap gangguan punya nama yang bisa dicatat dan diulang:

#!/usr/bin/env bash
set -euo pipefail

API="${TOXIPROXY_API:-http://localhost:8474}"
JSON=(-H 'Content-Type: application/json')

case "${1:-}" in
  pg-latency)
    curl -fsS -X POST "$API/proxies/postgres/toxics" "${JSON[@]}" \
      -d '{"name":"pg_latency","type":"latency","stream":"downstream","attributes":{"latency":800,"jitter":200}}' ;;
  pg-stall)
    # timeout=0: data ditahan tanpa batas dan koneksi tidak ditutup sampai toxic dihapus
    curl -fsS -X POST "$API/proxies/postgres/toxics" "${JSON[@]}" \
      -d '{"name":"pg_stall","type":"timeout","stream":"downstream","attributes":{"timeout":0}}' ;;
  pg-down)
    # Menonaktifkan proxy: koneksi yang ada diputus, koneksi baru ditolak
    curl -fsS -X POST "$API/proxies/postgres" "${JSON[@]}" -d '{"enabled":false}' ;;
  pg-up)
    curl -fsS -X POST "$API/proxies/postgres" "${JSON[@]}" -d '{"enabled":true}' ;;
  redis-latency)
    curl -fsS -X POST "$API/proxies/redis/toxics" "${JSON[@]}" \
      -d '{"name":"redis_latency","type":"latency","stream":"downstream","attributes":{"latency":300,"jitter":50}}' ;;
  redis-down)
    curl -fsS -X POST "$API/proxies/redis" "${JSON[@]}" -d '{"enabled":false}' ;;
  redis-up)
    curl -fsS -X POST "$API/proxies/redis" "${JSON[@]}" -d '{"enabled":true}' ;;
  reset)
    # Tombol darurat: hapus semua toxic dan aktifkan kembali semua proxy
    curl -fsS -X POST "$API/reset" ;;
  status)
    curl -fsS "$API/proxies" ;;
  *)
    echo "usage: $0 {pg-latency|pg-stall|pg-down|pg-up|redis-latency|redis-down|redis-up|reset|status}" >&2
    exit 1 ;;
esac
echo

Pengamat menjalankan probe.mjs (Node.js 18 ke atas, tanpa dependency) untuk mengukur apa yang dirasakan pengguna: persentil latency, distribusi status, dan berapa respons yang terdegradasi:

// Pemakaian: node probe.mjs [durasi_detik] [concurrency]
const BASE = process.env.PROBE_URL ?? 'http://localhost:3000/products/{id}';
const MAX_ID = 100000;
const DURATION_MS = Number(process.argv[2] ?? 30) * 1000;
const CONCURRENCY = Number(process.argv[3] ?? 10);

const results = [];
const deadline = Date.now() + DURATION_MS;
const target = () => BASE.replace('{id}', String(1 + Math.floor(Math.random() * MAX_ID)));

async function worker() {
  while (Date.now() < deadline) {
    const start = performance.now();
    let status = 'ERR';
    let degraded = '-';
    try {
      const res = await fetch(target(), { signal: AbortSignal.timeout(5000) });
      status = String(res.status);
      degraded = res.headers.get('x-degraded') ?? '-';
      await res.arrayBuffer();
    } catch (err) {
      status = err.name === 'TimeoutError' ? 'CLIENT_TIMEOUT' : 'ERR';
    }
    results.push({ ms: performance.now() - start, status, degraded });
  }
}

await Promise.all(Array.from({ length: CONCURRENCY }, worker));

const sorted = results.map((r) => r.ms).sort((a, b) => a - b);
const pct = (p) => Math.round(sorted[Math.min(sorted.length - 1, Math.floor((p / 100) * sorted.length))]);
const tally = (key) =>
  results.reduce((acc, r) => ({ ...acc, [r[key]]: (acc[r[key]] ?? 0) + 1 }), {});

console.log(JSON.stringify({
  total: results.length,
  p50_ms: pct(50),
  p95_ms: pct(95),
  p99_ms: pct(99),
  status: tally('status'),
  degraded: tally('degraded'),
}, null, 2));

Jalankan baseline sebelum gangguan apa pun:

docker compose up -d --build
chmod +x chaos.sh
node probe.mjs 30 10        # baseline: catat p50, p95, p99 dan distribusi status
docker compose logs -f app  # di terminal lain, untuk Pengamat

Baseline adalah pembanding untuk semua skenario. Tanpa baseline, angka “p95 1.200 ms saat gangguan” tidak berarti apa-apa.

Lima Skenario Simulasi Gangguan Database dan Cache

Tulis tabel hipotesis ini sebelum game day dimulai, dan jangan diubah selama sesi berjalan. Nilai ambangnya contoh berdasarkan konfigurasi di atas. Sesuaikan dengan budget latency service Anda.

#GangguanHipotesisBukti yang dicariBatas berhenti
1Postgres +800 ms latencyQuery utama tetap sukses, produk terkait terdegradasi, tidak ada 5xxx-degraded: related mendominasi, status 200, p95 di bawah ~2,5 sCLIENT_TIMEOUT muncul
2Postgres macet totalRequest cache miss gagal dalam ~1,5 s dengan 503, /healthz tetap 200Tidak ada CLIENT_TIMEOUT, log request_failed berisi timeoutProses app restart
3Postgres putus 20 detikProses tidak crash, cache hit tetap 200, pulih otomatis setelah proxy aktifLog pg_idle_client_error, tidak ada restart containerButuh restart manual untuk pulih
4Redis +300 ms latencyCache dianggap miss setelah ~100 ms, semua request jatuh ke DBLog cache_get_failed berisi “Command timed out”, p50 naik sekitar 100 msError koneksi pool Postgres
5Redis putusPerintah gagal seketika, aplikasi tetap melayani dari DB, reconnect otomatisStatus 200, p50 mendekati baseline cache missp95 melonjak ke hitungan detik

Skenario 1: Postgres melambat

./chaos.sh pg-latency
node probe.mjs 60 10
./chaos.sh reset

Hipotesis: query utama punya budget 1.500 ms, jadi latency 800 ms ± 200 ms masih masuk. Query produk terkait hanya punya 350 ms, jadi seharusnya selalu terdegradasi. Satu hal yang sering muncul di skenario ini dan jarang diantisipasi adalah koneksi baru. Membuka koneksi Postgres butuh beberapa kali bolak-balik (startup, autentikasi, parameter status). Kalau setiap jawaban dari server tertunda 800 ms, membuka satu koneksi baru bisa melewati connectionTimeoutMillis: 1000. Pool yang sudah hangat akan baik-baik saja, tapi pool yang sedang bertumbuh karena lonjakan trafik bisa gagal. Kalau Pengamat melihat error timeout exceeded when trying to connect, itu temuan, bukan kegagalan eksperimen.

Skenario 2: Postgres macet tanpa error

./chaos.sh pg-stall
node probe.mjs 30 10
curl -s -o /dev/null -w '%{http_code} %{time_total}s\n' localhost:3000/healthz
./chaos.sh reset

Ini skenario paling berharga, karena meniru gangguan yang paling licik: koneksi TCP tetap terbuka tapi tidak ada jawaban. Tidak ada ECONNRESET, tidak ada error dari server, hanya hening. statement_timeout tidak menolong di sini karena Postgres sudah selesai mengeksekusi query, hanya jawabannya yang tertahan. Yang menyelamatkan adalah query_timeout di sisi klien. Coba hapus baris query_timeout dari konfigurasi pool, build ulang, lalu ulangi skenario ini. Probe akan mulai mencatat CLIENT_TIMEOUT, karena node-postgres secara default tidak membatasi waktu tunggu query.

Perhatikan juga bahwa error timeout tidak di-retry. Kalau Anda mengubah isRetryable agar ikut me-retry timeout, waktu gagal setiap request menjadi dua kali lipat dan beban ke database yang sedang bermasalah ikut berlipat.

Skenario 3: Koneksi Postgres putus

./chaos.sh pg-down
node probe.mjs 20 10
./chaos.sh pg-up
node probe.mjs 20 10   # apakah pulih tanpa restart?
docker compose ps app  # cek kolom STATUS: apakah container sempat restart?

Saat proxy dinonaktifkan, Toxiproxy memutus semua koneksi yang ada. Client idle di pool menerima error, dan di sinilah pool.on('error') diuji. Komentari listener itu, build ulang, lalu jalankan skenario lagi. Di banyak setup, proses Node.js akan langsung berhenti karena event error tanpa handler, dan kalau container tidak punya restart policy, service Anda mati total meskipun database sudah kembali. Ini salah satu temuan yang paling sering saya lihat di service yang belum pernah diuji seperti ini.

Hipotesis kedua di skenario ini adalah pemulihan. Setelah pg-up, request seharusnya kembali 200 dalam hitungan detik tanpa restart aplikasi. Kalau tidak, cari koneksi rusak yang tertahan di pool atau konfigurasi yang hanya terbaca saat startup.

Skenario 4: Redis melambat

./chaos.sh redis-latency
node probe.mjs 30 10
./chaos.sh reset

Cache yang lambat itu berbahaya karena tidak terlihat seperti gangguan. Tanpa commandTimeout, setiap request menunggu 300 ms untuk cache, lalu tetap ke database kalau miss. Dengan commandTimeout: 100, aplikasi menyerah lebih cepat dan langsung ke database. Pertanyaan yang harus dijawab Pengamat: ketika seluruh trafik pindah ke database, apakah pool 10 koneksi masih cukup? Kalau log mulai menunjukkan error menunggu client dari pool, berarti “fallback ke database” Anda hanya bekerja selama trafik sedang rendah.

Skenario 5: Redis putus

./chaos.sh redis-down
node probe.mjs 30 10
./chaos.sh redis-up
sleep 5 && node probe.mjs 15 10   # pastikan cache dipakai lagi

Dengan enableOfflineQueue: false, perintah ke Redis yang sedang terputus langsung ditolak, lalu cacheGet mengembalikan null. Untuk membuktikan pentingnya setelan ini, ulangi skenario dengan opsi default ioredis (hapus enableOfflineQueue, maxRetriesPerRequest, dan commandTimeout). Bandingkan p95-nya. Selisih itulah alasan konfigurasi tersebut ada.

Untuk memeriksa apakah cache kembali dipakai setelah pulih, intip header x-source dari satu ID yang sama:

curl -s -o /dev/null -D - localhost:3000/products/42 | grep -i x-source   # pertama: db
curl -s -o /dev/null -D - localhost:3000/products/42 | grep -i x-source   # kedua: cache

Jebakan Health Check yang Sering Terbongkar

Perhatikan bahwa /healthz di aplikasi contoh tidak menyentuh Postgres maupun Redis. Itu disengaja. Di Kubernetes atau orchestrator lain, kalau liveness probe ikut memeriksa database, maka database yang melambat akan membuat semua pod dianggap mati dan di-restart bersamaan. Restart massal itu menambah koneksi baru ke database yang sedang kesulitan, persis saat ia paling tidak butuh beban tambahan.

Polanya: liveness hanya menjawab “apakah proses ini masih bisa melayani HTTP”, sedangkan readiness boleh memeriksa dependency kritis dengan timeout pendek, sehingga pod dikeluarkan sementara dari load balancer tanpa dibunuh. Skenario 2 adalah waktu yang tepat untuk membuktikan bahwa health check Anda tidak memperburuk keadaan.

Mencatat Hasil dan Mengubahnya Menjadi Tindakan

Pengamat mengisi satu catatan per skenario. Format sederhana sudah cukup, yang penting konsisten dan disimpan di repo bersama kode:

## Skenario 2 — Postgres macet total
- Tanggal / versi app: 2026-10-13 / commit abc1234
- Hipotesis: cache miss gagal ≤ 1,5 s dengan 503, /healthz tetap 200
- Hasil probe: (tempel output JSON probe.mjs)
- Status hipotesis: TERBUKTI / PATAH / SEBAGIAN
- Yang mengejutkan:
- Sinyal yang dipakai Responder untuk diagnosis:
- Tindak lanjut (tiket, pemilik, target):

Kolom “sinyal yang dipakai Responder” sering kali paling berguna. Kalau Responder butuh sepuluh menit untuk sadar bahwa masalahnya di Redis karena log tidak menyebut nama dependency, itu tiket observability, bukan tiket kode.

Skenario yang hipotesisnya pernah patah sebaiknya menjadi test otomatis, supaya regresinya tertangkap di CI dan bukan di game day berikutnya. Toxiproxy cocok untuk ini karena seluruhnya dikontrol lewat HTTP. Contoh dengan test runner bawaan Node.js, dijalankan saat stack docker-compose sedang hidup:

// resilience.test.mjs — jalankan: node --test resilience.test.mjs
import { test, after } from 'node:test';
import assert from 'node:assert/strict';

const TOXI = 'http://localhost:8474';
const APP = 'http://localhost:3000';

async function toxiproxy(path, body = {}) {
  const res = await fetch(`${TOXI}${path}`, {
    method: 'POST',
    headers: { 'content-type': 'application/json' },
    body: JSON.stringify(body),
  });
  if (!res.ok) throw new Error(`toxiproxy ${path}: HTTP ${res.status}`);
}

after(() => toxiproxy('/reset'));

test('Postgres macet: request gagal cepat dengan 503, tidak menggantung', async () => {
  await toxiproxy('/proxies/postgres/toxics', {
    name: 'pg_stall',
    type: 'timeout',
    stream: 'downstream',
    attributes: { timeout: 0 },
  });

  const id = 50000 + Math.floor(Math.random() * 50000); // kemungkinan besar belum ada di cache
  const start = performance.now();
  const res = await fetch(`${APP}/products/${id}`, { signal: AbortSignal.timeout(5000) });
  const elapsed = performance.now() - start;

  assert.equal(res.status, 503);
  assert.ok(elapsed < 2500, `request butuh ${Math.round(elapsed)} ms`);

  await toxiproxy('/reset');
});

test('Redis putus: endpoint tetap 200 dari database', async () => {
  await toxiproxy('/proxies/redis', { enabled: false });

  const res = await fetch(`${APP}/products/42`, { signal: AbortSignal.timeout(5000) });

  assert.equal(res.status, 200);
  assert.equal(res.headers.get('x-source'), 'db');

  await toxiproxy('/reset');
});

Dengan test seperti ini, seseorang yang tidak sengaja menghapus query_timeout atau mengembalikan opsi default ioredis akan langsung tahu dari CI.

Di Mana Posisi Game Day Ini dalam Disaster Recovery

Game day disaster recovery sering dibayangkan sebagai latihan besar: matikan satu region, promosikan replica, ukur RTO. Itu penting, dan latihan restore backup juga wajib, seperti yang saya tulis di panduan uji backup dan restore database. Tapi kejadian yang paling sering menjatuhkan service tim kecil bukanlah region yang hilang. Yang paling sering adalah dependency yang setengah sehat, dan aplikasi yang tidak tahu cara menyerah dengan anggun.

Latihan dengan Toxiproxy ini adalah lapisan paling bawah dari kesiapan bencana. Ia menguji apakah timeout terpasang di tempat yang benar, apakah retry tidak memperparah keadaan, dan apakah fitur sekunder bisa dikorbankan demi fitur utama. Setelah lapisan ini kokoh, pola yang lebih tinggi seperti circuit breaker dengan Opossum dan alert berbasis SLO dan error budget baru benar-benar bisa diandalkan, karena perilaku dasar yang mereka lindungi sudah terbukti.

Checklist Game Day Pertama Anda

  1. Siapkan lab docker-compose dengan Toxiproxy di antara aplikasi dan setiap dependency.
  2. Samakan versi driver, ukuran pool, dan nilai timeout dengan production.
  3. Tulis tabel hipotesis, lengkap dengan bukti yang dicari dan batas berhenti, sebelum sesi dimulai.
  4. Bagi peran Pemandu, Pengamat, dan Responder. Rotasikan di sesi berikutnya.
  5. Ukur baseline, lalu jalankan skenario satu per satu dengan reset di antaranya.
  6. Catat hasil per skenario, terutama yang mengejutkan dan sinyal yang dipakai untuk diagnosis.
  7. Ubah setiap hipotesis yang patah menjadi tiket dan, setelah diperbaiki, menjadi test otomatis.

Hari Pengurangan Risiko Bencana mengingatkan bahwa kesiapan dibangun sebelum kejadian. Untuk tim tiga orang, kesiapan itu bisa dimulai dari satu sore, satu file docker-compose.yml, dan kejujuran untuk menulis hipotesis yang mungkin saja salah.

Ditulis oleh Reza Pradipta