Rate limiting

Tanpa rate limit, satu skrip bisa menghabiskan CPU-mu lewat endpoint login, mengosongkan kuota API pihak ketiga, atau membuat tagihan AWS-mu meledak dalam semalam.

Token bucket

Ember berisi token, terisi ulang r token/detik, kapasitas b.
Setiap permintaan mengambil satu token; ember kosong = ditolak.

rate.NewLimiter(10, 20)
  → rata-rata 10 permintaan/detik
  → boleh melonjak sampai 20 sekaligus setelah periode tenang

import "golang.org/x/time/rate"

l := rate.NewLimiter(rate.Limit(10), 20)

if !l.Allow() {                  // tidak memblokir; langsung menjawab
	http.Error(w, "terlalu banyak permintaan", http.StatusTooManyRequests)
	return
}

// Varian lain
_ = l.Wait(ctx)                  // menunggu giliran (untuk klien keluar, bukan server)
res := l.Reserve()               // reservasi dengan waktu tunggu yang bisa dibaca

Per-kunci, dengan pembersihan

type Pembatas struct {
	mu     sync.Mutex
	klien  map[string]*entri
	r      rate.Limit
	b      int
}

type entri struct {
	l       *rate.Limiter
	terakhir time.Time
}

func (p *Pembatas) Izinkan(kunci string) bool {
	p.mu.Lock()
	defer p.mu.Unlock()

	e, ada := p.klien[kunci]
	if !ada {
		e = &entri{l: rate.NewLimiter(p.r, p.b)}
		p.klien[kunci] = e
	}
	e.terakhir = time.Now()
	return e.l.Allow()
}

// WAJIB: tanpa pembersihan, map ini tumbuh selamanya — dan itu
// kebocoran memori yang dikendalikan penyerang.
func (p *Pembatas) bersihkan(ctx context.Context) {
	t := time.NewTicker(time.Minute)
	defer t.Stop()
	for {
		select {
		case <-ctx.Done():
			return
		case <-t.C:
			p.mu.Lock()
			for k, e := range p.klien {
				if time.Since(e.terakhir) > 10*time.Minute {
					delete(p.klien, k)
				}
			}
			p.mu.Unlock()
		}
	}
}

Kunci: dari apa membatasinya

// Mendapatkan IP asli di belakang ALB/CloudFront.
// X-Forwarded-For BISA DIPALSUKAN kalau kamu percaya seluruh isinya.
func ipKlien(r *http.Request, jumlahProxy int) string {
	xff := r.Header.Get("X-Forwarded-For")
	if xff == "" {
		host, _, _ := net.SplitHostPort(r.RemoteAddr)
		return host
	}
	bagian := strings.Split(xff, ",")

	// Hitung dari KANAN: entri paling kanan ditambahkan proxy tepercayamu.
	// Entri paling kiri bisa saja diketik sendiri oleh klien.
	i := len(bagian) - jumlahProxy
	if i < 0 {
		i = 0
	}
	return strings.TrimSpace(bagian[i])
}

Batas yang wajar

Balasan yang benar

func tolak(w http.ResponseWriter, sisa time.Duration, batas int) {
	w.Header().Set("Retry-After", strconv.Itoa(int(sisa.Seconds()+1)))
	w.Header().Set("RateLimit-Limit", strconv.Itoa(batas))
	w.Header().Set("RateLimit-Remaining", "0")
	w.Header().Set("RateLimit-Reset", strconv.Itoa(int(sisa.Seconds()+1)))
	http.Error(w, "terlalu banyak permintaan", http.StatusTooManyRequests)
}

Batas bersama antar container

// Limiter di memori × 10 task = batas efektif 10 kali lipat.
// Untuk batas yang benar-benar global, hitungannya harus di Redis.
func (p *PembatasRedis) Izinkan(ctx context.Context, kunci string,
	batas int, jendela time.Duration) (bool, error) {

	k := fmt.Sprintf("rl:%s:%d", kunci, time.Now().Unix()/int64(jendela.Seconds()))

	n, err := p.rdb.Incr(ctx, k).Result()
	if err != nil {
		return true, err       // Redis mati → JANGAN kunci semua orang
	}
	if n == 1 {
		p.rdb.Expire(ctx, k, jendela)
	}
	return n <= int64(batas), nil
}

Berlapis