Desain RESTful API Skala Enterprise dengan Rate Limiting dan Circuit Breaker

1. Konteks Industri & Analisis Akar Masalah

Dalam lanskap arsitektur sistem terdistribusi modern, RESTful API menjadi tulang punggung yang menghubungkan berbagai layanan internal, aplikasi klien (Web, Mobile, IoT), dan pihak ketiga. Namun, ketika sebuah sistem menghadapi lonjakan lalu lintas yang tidak terduga (traffic spike) atau kegagalan beruntun pada layanan hilir (downstream services), arsitektur API yang naif akan runtuh seketika.

Bottleneck utama dalam performa API skala enterprise bukanlah pada kapasitas komputasi CPU semata, melainkan pada kehabisan sumber daya (resource exhaustion), seperti koneksi database yang jenuh, kehabisan memori akibat payload masif, dan terakumulasinya thread pool pada layanan eksternal yang lambat. Ketika layanan pihak ketiga mengalami kelambatan, request yang masuk akan terus menumpuk (efek thread starvation), menyebabkan seluruh aplikasi mengalami cascading failure.

Kondisi Sebelum vs Sesudah Penerapan

2. Konsep Inti & Deep Dive Arsitektur

Untuk membangun API yang tangguh, kita memerlukan pemisahan tanggung jawab yang jelas antara perutean, pembatasan akses, dan perlindungan kesalahan.

[ Client / Mobile / Web ]
           │
           ▼
    [ Cloudflare CDN ]
           │
           ▼
[ Nginx API Gateway ] ──(Rate Limiting via Redis)──┐
           │                                       │
           ▼                                       ▼
   [ Go Microservice ] ──(Circuit Breaker)──> [ External DB / API ]

Alur Eksekusi Data (Under the Hood)

1. Edge Level (Cloudflare / WAF): Menyaring ancaman DDoS lapisan 3/4/7 dan melakukan validasi SSL/TLS.
2. Gateway Level (Nginx + Redis): Melakukan pemeriksaan Rate Limiting berdasarkan token atau IP menggunakan algoritma Token Bucket atau Sliding Window Counter.
3. Application Level (Go / Node.js): Menerima request valid, mengecek Idempotency Key, dan meneruskannya ke layanan hilir melalui Circuit Breaker (Closed, Open, Half-Open states).

3. Perbandingan Komparatif / Analisis Pendekatan

4. Prasyarat Sistem & Persiapan Lingkungan

Sebelum masuk ke implementasi teknis, pastikan environment produksi Anda memenuhi spesifikasi berikut:

• OS: Ubuntu 22.04 LTS / Debian 12 Bookworm
• Web Server / Gateway: Nginx 1.24+
• Cache & Rate Limit Store: Redis 7.0+
• Backend Language: Go 1.21+ (untuk performa konkurensi tinggi)
• Database: MySQL 8.0 / PostgreSQL 15+

Instalasi dependensi dasar pada sistem berbasis Debian/Ubuntu:

sudo apt update && sudo apt upgrade -y
sudo apt install nginx redis-server build-essential curl git -y
sudo systemctl enable --now nginx redis-server

5. Panduan Implementasi Langkah demi Langkah

Langkah 1: Konfigurasi Rate Limiting di Nginx

Buat file konfigurasi Nginx untuk mendefinisikan zona rate limit menggunakan modul limit_req.

# /etc/nginx/conf.d/rate_limit.conf

# Mendefinisikan zona memori 10MB dengan batas 10 request per detik per IP
limit_req_zone $binary_remote_addr zone=api_limit:10m rate=10r/s;

server {
    listen 80;
    server_name api.enterprise.internal;

    location /v1/ {
        # Menerapkan rate limit dengan burst hingga 20 request tanpa penolakan langsung
        limit_req zone=api_limit burst=20 nodelay;
        
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Langkah 2: Implementasi Circuit Breaker dan Idempotency di Go

Berikut adalah implementasi penuh layanan backend menggunakan bahasa Go dengan pola Circuit Breaker (menggunakan library sony/gobreaker) dan penanganan Idempotency berbasis Redis.

package main

import (
	"context"
	"encoding/json"
	"fmt" 
	"net/http"
	"time"

	"github.com/go-redis/redis/v8"
	"github.com/sony/gobreaker"
)

var ctx = context.Background()
var rdb *redis.Client
var cb *gobreaker.CircuitBreaker

type PaymentRequest struct {
	Amount float64 `json:"amount"`
	Currency string `json:"currency"`
}

func init() {
	// Inisialisasi Redis Client
	rdb = redis.NewClient(&redis.Options{
		Addr: "localhost:6379",
	})

	// Konfigurasi Circuit Breaker
	var st gobreaker.Settings
	st.Name = "PaymentService"
	st.MaxRequests = 3
	st.Interval = 10 * time.Second
	st.Timeout = 5 * time.Second
	st.ReadyToTrip = func(counts gobreaker.Counts) bool {
		failureRatio := float64(counts.TotalFailures) / float64(counts.Requests)
		return counts.Requests >= 3 && failureRatio >= 0.6
	}

	cb = gobreaker.NewCircuitBreaker(st)
}

func handlePayment(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	// 1. Validasi Idempotency Key
	idempotencyKey := r.Header.Get("X-Idempotency-Key")
	if idempotencyKey == "" {
		http.Error(w, "X-Idempotency-Key header is required", http.StatusBadRequest)
		return
	}

	val, err := rdb.Get(ctx, idempotencyKey).Result()
	if err == nil {
		// Request sudah pernah diproses sebelumnya, kembalikan hasil cache
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusOK)
		w.Write([]byte(val))
		return
	}

	var req PaymentRequest
	err = json.NewDecoder(r.Body).Decode(&req)
	if err != nil {
		http.Error(w, "Invalid request payload", http.StatusBadRequest)
		return
	}

	// 2. Eksekusi via Circuit Breaker
	result, err := cb.Execute(func() (interface{}, error) {
		// Simulasi pemanggilan layanan pembayaran eksternal yang rentan gagal
		time.Sleep(100 * time.Millisecond)
		if req.Amount > 10000 {
			return nil, fmt.Errorf("gateway timeout or payment declined")
		}
		return map[string]string{"status": "SUCCESS", "transaction_id": "TXN-998877\