Dalam sistem monolitik tradisional, kegagalan fungsi internal biasanya memicu pengecualian (exception) lokal yang dapat ditangani dalam siklus eksekusi memori yang sama. Namun, dalam arsitektur microservices terdistribusi, setiap panggilan antar-layanan melintasi batas jaringan fisik (HTTP REST, gRPC, atau koneksi basis data).
Karakteristik paling berbahaya dari kegagalan jaringan bukanlah ketika layanan hilir langsung mati seketika (mengembalikan status HTTP 500 dalam 2 milidetik), melainkan ketika layanan hilir mengalami degradasi performa lambat (respons tertahan selama 15 hingga 30 detik sebelum timeout). Ketika puluhan request masuk secara bersamaan, thread pool server hulu akan tersedot untuk menunggu respons yang tidak kunjung tiba. Dalam hitungan menit, seluruh antrean koneksi habis, server mengalami kehabisan memori, dan kegagalan merambat ke seluruh ekosistem (cascading failure).
Untuk membangun sistem yang memiliki daya tahan tinggi (resilient), arsitektur enterprise menerapkan kombinasi tiga pola desain: Circuit Breaker, Bulkhead Isolation, dan Retry with Exponential Jitter.
Status Mesin Circuit Breaker:
┌────────────────────────────────────────────────────────┐
│ STATUS: CLOSED │
│ Seluruh request dialirkan normal ke service eksternal. │
└────────────────────────────────────────────────────────┘
│
│ Jika Error Rate > 50% dalam Window Waktu
▼
┌────────────────────────────────────────────────────────┐
│ STATUS: OPEN │
│ Request LANGSUNG DITOLAK seketika (Fail Fast)! │
│ Tidak ada panggilan jaringan. Fallback dijalankan. │
└────────────────────────────────────────────────────────┘
│
│ Setelah Cooldown (Misal: 30 Detik)
▼
┌────────────────────────────────────────────────────────┐
│ STATUS: HALF-OPEN │
│ Menguji beberapa request percobaan (Canary probes). │
└────────────────────────────────────────────────────────┘
│ │
│ Berhasil Lolos │ Masih Gagal
▼ ▼
Kembali ke CLOSED Kembali ke OPEN
1. Pola Circuit Breaker: Memutus Jalur Sebelum Sistem Lumpuh #
Prinsip kerja Circuit Breaker diadaptasi dari pemutus sirkuit listrik di rumah tangga: jika terjadi kelebihan beban atau korsleting, sakelar listrik otomatis memutus aliran secara mekanis sebelum kabel terbakar.
Pada perangkat lunak, Circuit Breaker beroperasi melalui tiga status utama:
- CLOSED: Kondisi normal. Panggilan jaringan dieksekusi seperti biasa. Jika ada kegagalan sesekali, penghitung error mencatatnya tetapi sakelar tetap tertutup.
- OPEN: Jika rasio kegagalan atau timeout melampaui ambang batas aman (misalnya 50% dari 20 request terakhir), sakelar terbuka. Selama status OPEN, panggilan ke layanan hilir dibatalkan seketika tanpa menyentuh jaringan (fail fast). Sistem langsung mengembalikan respons degradasi cadangan (fallback).
- HALF-OPEN: Setelah masa pendinginan (cooldown) berakhir (misalnya 30 detik), sistem mengizinkan sebagian kecil permintaan uji coba lewat. Jika permintaan uji coba berhasil, sakelar kembali ke CLOSED. Jika gagal, sakelar kembali ke OPEN.
2. Pola Bulkhead: Mengisolasi Kompartemen Sumber Daya #
Pola Bulkhead dinamai berdasarkan sekat kedap air pada lambung kapal laut: jika lambung kapal bocor di kompartemen nomor 3, air hanya memenuhi kompartemen tersebut dan tidak menenggelamkan kompartemen lainnya.
Pada arsitektur microservices, Bulkhead membatasi jumlah konkurensi (thread pool atau koneksi HTTP) per dependensi.
- Jangan pernah menyatukan koneksi HTTP untuk memanggil Payment Gateway dan Rekomendasi Produk dalam satu pool global yang sama.
- Alokasikan maksimal 20 koneksi konkuren untuk Payment Gateway dan 10 koneksi untuk modul notifikasi. Jika sistem notifikasi mengalami macet, 20 koneksi pembayaran tetap aman dan dapat memproses transaksi penjualan pelanggan tanpa terganggu.
3. Retry dengan Exponential Backoff dan Full Jitter #
Mencoba kembali panggilan yang gagal (retry) adalah hal yang wajar, namun retry yang tidak terkontrol dapat membunuh server yang sedang berjuang pulih (Thundering Herd Problem).
Jika 1.000 klien serempak melakukan retry setiap 2 detik secara teratur, server akan dihantam gelombang lonjakan trafik periodik yang melumpuhkan CPU.
Solusi standarnya adalah menggunakan Exponential Backoff dengan Full Jitter:
$$t_{\text{sleep}} = \text{rand}(0, , \min(t_{\text{max}}, , t_{\text{base}} \times 2^{\text{attempt}}))$$
Dengan menyertakan nilai acak (jitter), waktu tunggu setiap klien akan tersebar merata sepanjang sumbu waktu, memberikan ruang bernapas bagi layanan hilir untuk memulihkan diri.
Implementasi Menggunakan Opossum pada Node.js / TypeScript #
Berikut adalah implementasi Circuit Breaker dengan penanganan fallback pada runtime TypeScript menggunakan pustaka opossum:
import CircuitBreaker from 'opossum';
interface PaymentRequest {
orderId: string;
amount: number;
paymentMethod: string;
}
interface PaymentResponse {
status: 'SUCCESS' | 'QUEUED_FOR_RETRY' | 'FAILED';
referenceId?: string;
message: string;
}
// Fungsi panggilan jaringan riil ke gateway pihak ketiga
async function callExternalPaymentGateway(payload: PaymentRequest): Promise<PaymentResponse> {
const controller = new AbortController();
const timeoutId = setTimeout(() => controller.abort(), 3000); // 3 detik timeout tegas
try {
const response = await fetch('https://api.gateway-pembayaran.id/v1/charge', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
signal: controller.signal,
});
if (!response.ok) {
throw new Error(`Gateway HTTP Error: ${response.status}`);
}
return await response.json();
} finally {
clearTimeout(timeoutId);
}
}
// Konfigurasi Opossum Circuit Breaker
const breakerOptions: CircuitBreaker.Options = {
timeout: 3000, // Jika eksekusi melampaui 3 detik, anggap gagal
errorThresholdPercentage: 50, // Buka sirkuit jika 50% panggilan gagal
resetTimeout: 30000, // Tunggu 30 detik sebelum mencoba status Half-Open
rollingCountTimeout: 10000, // Jendela evaluasi 10 detik terakhir
rollingCountBuckets: 10,
volumeThreshold: 10, // Minimal 10 request sebelum sirkuit boleh dibuka
};
export const paymentCircuitBreaker = new CircuitBreaker(callExternalPaymentGateway, breakerOptions);
// Penanganan Fallback Anggun (Graceful Degradation)
paymentCircuitBreaker.fallback((payload: PaymentRequest, error: Error): PaymentResponse => {
console.warn(`[Circuit Breaker Fallback Active] Order: ${payload.orderId}. Penyebab: ${error.message}`);
// Alih-alih melempar error 500 ke pengguna, simpan transaksi ke antrean asinkron (outbox)
return {
status: 'QUEUED_FOR_RETRY',
message: 'Layanan pembayaran sedang sibuk. Transaksi Anda telah dijadwalkan dan akan diproses otomatis.',
};
});
// Telemetri Observabilitas
paymentCircuitBreaker.on('open', () => {
console.error('[ALERT] Circuit Breaker Gateway Pembayaran TERBUKA! Mengaktifkan mode fail-fast.');
// Kirim metrik alert ke Prometheus / Slack
});
paymentCircuitBreaker.on('halfOpen', () => {
console.log('[INFO] Circuit Breaker memasuki status HALF-OPEN. Menguji konektivitas.');
});
paymentCircuitBreaker.on('close', () => {
console.log('[RECOVERY] Layanan pembayaran pulih normal. Circuit Breaker TERTUTUP.');
});
Dengan mengisolasi kegagalan melalui pemutus sirkuit, membatasi konsumsi sumber daya melalui sekat bulkhead, dan meratakan percobaan retry dengan jitter, arsitektur microservices dapat bertahan menghadapi kegagalan jaringan eksternal tanpa pernah meruntuhkan sistem inti bisnis.
