Điều kiện tiên quyết: Đây là Phần 11 của Khóa Học System Design. Mấy hồi trước hì hục xây đắp xương sống lõi cốt (core components) — hồi này vác khiên bọc giáp cho mớ APIs và múa roi quất dẹp loạn bọn khách sộp ùa dâng ngập lụt (traffic spikes) lúc phình bành.

Answer-first: Đòn bóp cổ nặn API (API rate limiting) bọc hậu bảo kê ba cái mỏ dịch vụ (backend services) bằng cách siết cổ vặn vòi lượng rác ọc vô (request volume). An ninh phòng thủ bắt buộc xài trò nhồi lô cốt n lớp (layered defense): Tiền đồn Tường Lửa WAF đập vỡ mõm bầy sóng thần dâng lụt trào (volumetric spikes) ngay ngưỡng cửa, Trạm Gác API Gateways cầm trịch vé tàu (credentials) và mâm cỗ (quotas) ở L7, và cuối cùng bọn bảo kê gầm giường (application middleware) nắm chốt siết gắt gao mớ luật mần ăn chi li (fine-grained business limits). Đòi móc mả vạch mặt thằng khách (client identification) thì phải ngậm bùa bắt IP tróc gốc, bảo mật kín kẽ (xài chiêu PROXY protocol hoặc lột sụn bấu vô cái chót X-Forwarded-For chót lọt tận mép phải).

Kiến Trúc Bóp Cổ Bọc Giáp Nhiều Tầng (Layered Architecture) & Khóa Mõm Đòn Tráo Trở IP (IP Spoofing)

Answer-first: Đòn bóp cổ siết họng xịn sò đòi hỏi thế võ vắt lầu (tiered approach), bung khiên phang chặn liền tay ở chóp ngoài WAF, nắn bóp chia mâm quota ở cái phễu L7 gateway, và ấn kẹp luật làm ăn sâu sát ở trong rốn middleware lõi. Đặng vạch mặt cấm bọn lươn lẹo xào chẻ IP (client IP spoofing), mấy khứa lính canh proxies phải lột trần vứt sọt rác mấy cái mũ X-Forwarded-For do bọn khách đội sẵn, chỉ gật gù tin sái cổ mớ IP của lũ lính proxy nội bộ nhà trồng, hoặc xài cái bùa PROXY protocol chèn rốn thẳng vô tầng TCP.

Bày Mâm Xếp Lô Cốt (Layered Defense Options)

Ba cái ổ mả phân tán không bao giờ được vắt cạn sinh lực phó mặc sinh tử vô tay duy nhất 1 thằng canh me (single choke point). Phải băm việc xẻ thịt vứt cho 3 tầng lầu gác cửa 3 chóp khác nhau:

Tầng Lầu (Defense Tier)Nghề Nghiệp Lõi (Primary Responsibility)Đồ Chơi (Common Technologies)Đánh Đổi Lời Lõm (Key Trade-offs)
Lính Đảo Edge WAFĐỡ đòn ngập lụt (Volumetric), dập DDoS, vạch mặt chém bot, check phốt danh tiếng IPCloudflare, AWS WAF, AkamaiBúa tạ đập ruồi, lẹ chóc; cơ mà đui mù chẳng rành ba cái đồ lòng (metadata) rắc rối dưới đáy ứng dụng.
Gác Cửa API Gateway (L7)Khớp khóa API (API keys), chia mâm múc quota xóm trọ (tenant), định tuyến chẻ ngã (routing)Kong, Envoy, TraefikRành rõ đường đi nước bước (routing metadata); nhưng thâu tóm vào 1 họng là ngộp thở lê lết ngay (high latency impact).
Bảo Kê Rốn Application MiddlewareĐếm xỉa từng cắc bạc (user actions) (vd: bóp vụ sửa mỏ profile, chặn ngọng vòi thử cà thẻ)Go middleware + RedisCắm vòi sục thẳng ruột DB hốt trọn bí kíp (context); ngốn CPU/băng thông rã họng tốn lúa.
graph TD
    Client([Bọn Lượn Lờ Internet]) -->|"Đập vỡ DDoS / Bot chặn cống\nCửa Tầng Lớp 3/4"| WAF["☁️ Lính Đảo Đóng Biên WAF\n(Cloudflare WAF / AWS WAF)"]
    WAF -->|"Đỡ đòn biển người xong\nRác sạch lết qua"| GW["🔀 Gác Cửa API Gateway\n(Kong / Envoy / Traefik)"]
    GW -->|"Gõ khóa JWT / API Key\nSiết bóp xóm trọ tenant"| App["⚙️ Bảo Kê Rốn Go Middleware\n(Bùa Redis + Nắm thóp Business)"]
    App -->|"Soi mả tiểu tiết:\nSiết cựa User, Bóp nặn Cà Thẻ"| Svc["🗄️ Mỏ Vàng Đáy Rốn (Upstream)\n(DB, Hố Rác Queue, Caches)"]

    style WAF fill:#ff6b6b,color:#fff
    style GW fill:#4a6cf7,color:#fff
    style App fill:#28a745,color:#fff
    style Svc fill:#6c757d,color:#fff

Lột Mặt Nạ Đòn Giả Danh X-Forwarded-For (XFF Spoofing)

Nếu cục mìn bóp cổ rate limiter của mày moi đọc cái thẻ X-Forwarded-For để điểm mặt khách (identify users), thằng nhãi khách bá dơ có thể móc túi xỉa tờ bùa:

GET /api/checkout HTTP/1.1
Host: api.vesviet.com
X-Forwarded-For: 8.8.8.8

Hễ con lính gác proxy cắm rễ chóp ngoải xỏ xiên nhét thêm vô cái thẻ này chẳng cần chùi rửa (without sanitization), ổ server sẽ hứng nguyên cục tạ X-Forwarded-For: 8.8.8.8, <client_real_ip>. Mày mà u mê tin sái cổ cái IP vứt bên trần lề trái (8.8.8.8) thì thằng ranh kia mặc sức hô biến sủa mạo danh bất cứ số IP nào đặng đánh võng lượn lách luật bóp cổ rate limits của mày.

Đòn Đập Vỡ Mặt (Prevention Strategies):

  1. Lột Truồng (Header Stripping): Thằng lính rào chắn reverse proxy phải giật sập lột cạn sất sành sanh ba cái thẻ X-Forwarded-For do chính tay thằng khách dúi vô trước khi nó nhồi tiêm cái mỏ IP gốc gác thật thụ của dòng TCP vào.
  2. Kéo Lưới Vớt Mép Phải (Rightmost IP Extraction): Nhỡ mày bọc lót nhiều thằng cò mồi load balancers giăng xéo nhằng nhịt, thì nhồi luật bắt ứng dụng chỉ móc đúng 1 bãi nhổ chót lọt tận mép phải rặc do tay thằng đệ proxy nội bộ sột rột của mày đút dô (vd: remote_ip = header_values[len(header_values) - num_trusted_proxies]).
  3. Mật Thư PROXY Protocol: Nghỉ chơi lột vỏ HTTP đi mà dò IP. Chơi cái bùa PROXY protocol móc nhét 1 mẩu rác TCP lọt khe phơi ra trọn gói danh tính cội rễ (connection metadata) trước hẳn màn chào hỏi múa mây TLS handshake.

Bóp Cổ Nóng Trong Ruột Bộ Nhớ (In-Memory Rate Limiting): Đánh Nhau Bể Xô Token vs. Xô Lủng Đáy

Answer-first: Xô Nhận Thẻ (Token Bucket) rộng cửa thả rông đón đợt sóng cuộn (bursts) nhờ trò tích góp thẻ qua năm tháng chật ních cái xô (capacity limit). Xô Lủng Đáy (Leaky Bucket) thì ốp luật vắt sữa trơn tru láng o bằng chiêu chèn ép lèn nhét mấy cục rác độ trễ ngắt quãng ép buộc (forced delay gaps) lọt giữa mớ mỏ hú (calls). Ở cái xứ Go chen chúc giẫm đạp vỡ chợ (high-concurrency), trò khóa sập mỏ (global locks) trên đầu rate limiters đẻ ra mẻ đập nhau chém lộn khóa (mutex contention) sùi bọt mép; lôi ra băm thịt chẻ rổ (sharding limiters) hay nã đạn nguyên khối CAS (atomic CAS) mới dẹp loạn được mớ hàng chờ cãi lộn chém khóa đó.

So Găng Ngón Nghề (Algorithm Comparison)

Đồ NghềXô Nhận Thẻ (Token Bucket - x/time/rate)Xô Lủng Đáy (Leaky Bucket - uber-go/ratelimit)
Khuôn Đúc TrafficMở mỏ đớp sóng cuộn (bursts) bạo phát đụng nóc xôNắn bóp khạc nhổ nhè nhè đều vắt (smooths output traffic) ra 1 nhịp chót
Ghim Sổ (State Tracked)Vét cạn rổ thẻ hiện tại, thời khắc chốt đơn chót (last update)Bói giờ hoàng đạo thằng khứa tiếp theo lết tới (expected time)
Đớp Bộ Nhớ (Memory)Lỳ đòn $O(1)$ chóc 1 keyLỳ đòn $O(1)$ chóc 1 key
Vác Đi Đập Nhau Chỗ NàoChõ mỏ phơi mặt đón khách kẹt rác đớp dồn dập lẹBóp họng mớ ống nhòm lết (outbound calls) đâm chọt mấy lão già API ruột đểu chầu chực chửi (fragile)

Choảng Nhau Giành Cùm Khóa (Mutex Contention under Load)

Cái thói đời phàm tục bẩm sinh của lõi golang.org/x/time/rate xọc ngang gọng kìm còng khóa cả 1 cái ổ chung trạ sync.Mutex vào MỖI MỘT nhịp đếm bói:

func (lim *Limiter) AllowN(now time.Time, n int) bool {
    lim.mu.Lock()
    defer lim.mu.Unlock()
    return lim.reserveN(now, n, 0).ok
}

Giữa bãi chiến trường giẫm đạp lồi ruột (high concurrency ngót trăm ngàn nháy request 1 giây), lưỡi dao mổ CPU profiling phanh thây lòi ra mớ lính Go threads rã háng ngáp ruồi há mỏ đợi trong hẻm vắng sync.runtime_Semacquire nguyên cớ bởi bão giành giật đập lộn cắn xé ổ khóa (lock contention) trên cái thòng lọng mutex này.

Chiêu băm nát Chẻ Bô (Sharding Limiter Pattern)

Đặng dập lửa, băm nát 1 cái rổ limiter map chà bá thành n lổ đút độc lập (shards - bô) rập khuôn băm nát thẻ bài khách xài hash:

package limiter

import (
	"hash/fnv"
	"sync"
	"time"
	"golang.org/x/time/rate"
)

type ShardedLimiter struct {
	shards []*limiterShard
	size   uint32
}

type limiterShard struct {
	mu       sync.RWMutex
	limiters map[string]*rate.Limiter
}

func NewShardedLimiter(shardCount int) *ShardedLimiter {
	shards := make([]*limiterShard, shardCount)
	for i := 0; i < shardCount; i++ {
		shards[i] = &limiterShard{
			limiters: make(map[string]*rate.Limiter),
		}
	}
	return &ShardedLimiter{shards: shards, size: uint32(shardCount)}
}

func (sl *ShardedLimiter) getShard(key string) *limiterShard {
	h := fnv.New32a()
	h.Write([]byte(key))
	idx := h.Sum32() % sl.size
	return sl.shards[idx]
}

func (sl *ShardedLimiter) Allow(key string, r rate.Limit, b int) bool {
	shard := sl.getShard(key)
	
	shard.mu.RLock()
	lim, exists := shard.limiters[key]
	shard.mu.RUnlock()

	if !exists {
		shard.mu.Lock()
		// Ngó chừng chẻ đôi móc ngầm lại (Double check lock)
		lim, exists = shard.limiters[key]
		if !exists {
			lim = rate.NewLimiter(r, b)
			shard.limiters[key] = lim
		}
		shard.mu.Unlock()
	}

	return lim.Allow()
}

Hai Môn Phái Xô Lủng Đáy (Leaky Bucket): Xếp Hàng Hốc Rác (Queue) vs Đứt Quãng Lòi Rốn (Time-Gap)

  1. Giáo Phái Xếp Hàng (Queue-Based): Nặn 1 lổ cống bọc đệm (buffered channel) nhét tọng hốt rác rác nhét vô. 1 con lừa cu li (worker consumer) lết xác chui ra rút rỉa ruột lổ cống túc tắc theo nhịp gõ mỏ nhịp nhàng (time.Ticker). Hễ lổ cống đầy ứ hự ọc lên, hốt rác mới tới đút vô là búng dái văng ra sập tiệm liền (fail immediately). Đánh đổi: Hao tiền rách túi đẻ trứng chà bá (allocation overhead). Cấp rổ mương channel với hàng chờ nó nở phình trương rốn đu càng theo cái lũ lụt traffic xô đẩy tới.
  2. Giáo Phái Bấm Giờ (Time-Gap - uber-go/ratelimit): chẳng gom gì sất, chỉ lận lưng đúng con số bói giờ (expected execution timestamp) của cái thằng khách tiếp theo. Hễ 1 thằng ma tới húp lẹ quá ranh, đòn bóp cổ bấu víu rà soát độ hụt giờ (time gap) rồi tròng xích gõ đầu lính thread lăn ra ngủ đơ cán cuốc (sleep): Đánh đổi: Né lẹ đòn đẻ trứng lổ cống hao của ($O(1)$ memory). Bọn threads nghẹn họng tắt còi nằm bẹp dí xài bùa ngủ chay của hót rác scheduler (scheduler sleep), ngậm ít hao tổn xương máu CPU.

Bóp Cổ Nhồi Loạn Cào Cào (Distributed Rate Limiting) Xài Rổ Kéo Redis & Bùa Lua

Answer-first: Đòn bóp cổ loạn cào cào đục lỗ thông não móc nối hụi họ mâm cỗ (quotas) dàn trải ngang ngửa n chóp app nhờ trò kẹp 1 cục trạm phát (central data store). Vác chiêu Đếm Bảng Trượt Cửa Sổ (Sliding Window Log/Counter) ốp nhét chui vô cái rổ xào chẻ Redis (Sorted Set - ZSET) là nắm trọn sổ nam tào đếm nháy mốc thời gian vắt óc từng giao dịch. Đòn cắn xé chém lộn (Race conditions) bị đập vỡ mặt, tận diệt nhờ trò nã chiêu vừa móc mắt vừa ghi sổ lọt thỏm nguyên khối dính nắp rập 1 phay trong đống bùa múa Redis Lua.

                  +-----------------------------------+
                  |        Ổ App Đúc Go Node          |
                  +-----------------------------------+
                       |                         |
                       | Quất EvalSHA / Múa bùa  | (1 Phát Lên Mây Đảo Đầu)
                       v                         v
       +-------------------------------------------------+
       |                  Lò Bát Quái Redis              |
       |  Bày Binh Bố Trận Bùa Lua:                      |
       |  1. ZREMRANGEBYSCORE: Xẻo ném mẹ mớ xác < cửa sổ|
       |  2. ZCARD: Điểm danh lính lọt thỏm trong tròng  |
       |  3. ZADD + PEXPIRE: Nếu lọt nẹp thì khắc bia    |
       +-------------------------------------------------+

Lủng Rổ Cắm Cọc Trong Ổ Redis Cluster (Hash Tags Slot Constraints)

Rúc trong xó xỉnh mâm bát Redis Cluster, bầy mả keys bị đâm chém rải rác lọt 16,384 hố khe hẹp (slots). Vác 1 mẻ múa dao (giao dịch MULTI/EXEC) hay quăng bùa Lua ngứa nghề đòi nhồi nặn chọc ngoáy vô vàn chìa khóa sẽ ăn nguyên cục gạch lủng lỗ mũi báo lọt phốt CROSSSLOT đứt bóng hễ bầy chìa khóa khốn nạn văng miểng nằm ề rác ở n mỏ nodes khác nhau chẳng chung ổ.

Đòn Xỏ Khuyên Thẻ Bài (The Slot Hash Tag Solution)

Đặng hót múa nã đạn đa-chìa-khóa, gói tém gọn bẽn cái lổ rốn móc nối chung rập khuôn ném vào bọc vô 1 cái nón ôm ngoặc nhọn {}. Đầu bò Redis chẳng thèm nhai mớ bùng nhùng, chỉ moi đúng chóc lổ thịt gói chui trong nón nhọn ra băm viên rải hố vọt khe (slot).

  • Thả Rông (Without Hash Tag): rate:127.0.0.1:log và rate:127.0.0.1:metadata bị băm nát đùn ra 2 mả slot trật lất, đẻ ra sập hầm nứt dĩa phân bổ.
  • Đeo Cổ Nón Nhọn (With Hash Tag): {rate:127.0.0.1}:log sáp chĩa {rate:127.0.0.1}:metadata thề sống chết băm chẻ nhõn lổ lòi mả ruột rate:127.0.0.1, đinh đóng cột bấu víu nằm chình ình ề ạch đè chung 1 hố slot và chóc 1 ổ node.

Mẻ Bùa Lua Chui Rúc Rải Thảm Cửa Sổ Trượt Xài Banh Production

-- KEYS[1]: Chìa khóa Cổ Cùm (Limit Key), e.g., "{rate:user_1029}:log"
-- ARGV[1]: Lốc giờ UNIX lúc nhóp nhép (ms) (Current UNIX millisecond timestamp)
-- ARGV[2]: Vạch rào cửa sổ trượt nhồi nhét (ms) (Sliding window duration, e.g., 60000 cho 1 phút)
-- ARGV[3]: Cục cọc nóc mâm cỗ kịch kim đớp được (Max allowed requests)
-- ARGV[4]: Thẻ bài Độc Mã (Unique Request ID) (UUID hay vãi chưởng random) để lột tên thằng khách
local key = KEYS[1]
local now = tonumber(ARGV[1])
local window = tonumber(ARGV[2])
local limit = tonumber(ARGV[3])
local request_id = ARGV[4]

-- Nhát 1: xẻo luôn lụi cổ quăng mẹ hết xác phàm bã thời gian xưa lắc nứt đứt vạch xuất phát cửa sổ
redis.call('ZREMRANGEBYSCORE', key, 0, now - window)

-- Nhát 2: Mót móc đếm số lượng thủ cấp thoi thóp còn sót lọt khe trong nẹp
local count = redis.call('ZCARD', key)

-- Nhát 3: Ngó chừng xoi thử thò đầu vô được hông
if count < limit then
    -- Đóng dấu xăm trán chốt đơn: score = giờ đục, member = thẻ bài nháy
    redis.call('ZADD', key, now, request_id)
    -- Giãn tuổi thọ (TTL) chìa khóa đặng rác thiu khỏi vướng víu bôi dơ hao mồi nhớ
    redis.call('PEXPIRE', key, window)
    return {1, count + 1} -- Ói ra lỏ: {Cho_Lọt=1, Cục_Mỡ_Đớp_Hiện_Tại}
else
    return {0, count}     -- Ói ra lỏ: {Đá_Văng=0, Cục_Mỡ_Đớp_Hiện_Tại}
end

Bộ Giáp Bảo Kê Lõi Go Phanh Phui Bóp Cổ Đỉnh Chóp (Complete Middleware)

Cục lô cốt này bưng bít đúc khuôn chọc gậy mẻ bùa Lua thông qua lính lê dương chóp nhà trồng go-redis/v9, nhào nặn lôi mả trả về mấy cái thẻ HTTP rập khuôn chọc đầu bóp cổ chuẩn lòi họng:

package middleware

import (
	"context"
	"crypto/rand"
	"encoding/hex"
	"net/http"
	"strconv"
	"time"
	"github.com/redis/go-redis/v9"
)

var slidingWindowScript = redis.NewScript(`
	local key = KEYS[1]
	local now = tonumber(ARGV[1])
	local window = tonumber(ARGV[2])
	local limit = tonumber(ARGV[3])
	local request_id = ARGV[4]
	redis.call('ZREMRANGEBYSCORE', key, 0, now - window)
	local count = redis.call('ZCARD', key)
	if count < limit then
		redis.call('ZADD', key, now, request_id)
		redis.call('PEXPIRE', key, window)
		return {1, count + 1}
	else
		return {0, count}
	end
`)

type RedisRateLimiter struct {
	rdb    *redis.Client
	limit  int
	window time.Duration
}

func NewRedisRateLimiter(rdb *redis.Client, limit int, window time.Duration) *RedisRateLimiter {
	return &RedisRateLimiter{
		rdb:    rdb,
		limit:  limit,
		window: window,
	}
}

func (rl *RedisRateLimiter) Middleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		ctx := r.Context()
		
		// Vạch mặt bóp trĩ móc IP (Secure IP - cấm tiệt bóc mả IP giả bằng xài đồ gắt RemoteAddr hay bùa lọt hố L7)
		ip := r.RemoteAddr
		key := "{rate:" + ip + "}:log"
		
		now := time.Now().UnixNano() / int64(time.Millisecond)
		windowMs := rl.window.Milliseconds()
		
		// Xóc dĩa nặn random id đặng bùa ngải lọt khe ZSET chẳng đụng mả (unique)
		randBytes := make([]byte, 8)
		if _, err := rand.Read(randBytes); err != nil {
			http.Error(w, "Cháy nhà rồi toang (Internal system error)", http.StatusInternalServerError)
			return
		}
		reqID := hex.EncodeToString(randBytes)

		// Thụt gậy múa bùa Lua đóng nguyên cục nắp chốt cứng (atomically) vô mặt mũi Redis
		res, err := slidingWindowScript.Run(ctx, rl.rdb, []string{key}, now, windowMs, rl.limit, reqID).Result()
		if err != nil {
			http.Error(w, "Thằng bóp cổ xụi lơ đứt bóng rồi (Rate limiting service unavailable)", http.StatusServiceUnavailable)
			return
		}

		results := res.([]interface{})
		allowed := results[0].(int64)
		count := results[1].(int64)

		// Đóng mộc nặn tem RFC lề thói
		w.Header().Set("X-RateLimit-Limit", strconv.Itoa(rl.limit))
		w.Header().Set("X-RateLimit-Remaining", strconv.FormatInt(int64(rl.limit)-count, 10))

		if allowed == 0 {
			w.Header().Set("Retry-After", strconv.FormatInt(rl.window.Milliseconds()/1000, 10))
			http.Error(w, "Tham Ăn Nhét Họng (Too Many Requests)", http.StatusTooManyRequests)
			return
		}

		next.ServeHTTP(w, r)
	})
}

Mổ Bụng Trà Dư Tửu Hậu (Case Study): Trận Đánh Siết Cổ Sale Sập Sàn Ở Shopee

🔥 [Đòn Cáo Già Chốn Production]: Chiêu Giương Khiên Đỡ Đạn Của Shopee (Request Shielding) Giữa mớ hỗn mang ùa chực đợt bão lốc giật cô hồn sale sập sàn (flash sales), họng sóng lũ cuộn sục phay ghi (write traffic) xé nát vỡ mõm bãi chứa cọc hàng (inventory shards) vọt đứt ngàm trần giới hạn. Shopee dập lửa nắn sóng nặn bóp nhờ trộn bùa Redis Lua nhét kèm lổ hót rác (message queueing):

  1. Dập Cửa Chặn Đứng (Immediate Shielding): Rà kho hàng (inventory) sục rỗng Redis tắp lự. Nhỡ cái bùa ngải Redis thét lên “hết con sạch bách hàng gòi”, ba cái bùa cục súc che thân nội bộ (sync.Map caches) lổ rốn dưới nách mấy thằng app nodes bị lật bài cấm tiệt búng dái sạch (reject all) bọn cô hồn ăn xin tắp lự khỏi phiền hò hét rúc nách đi hỏi vặn thằng Redis chi cho nghẽn mỏ.
  2. Chôn Bọc Vô Đệm Lót Hố (Queue buffering): Ngộ lòi thỏm hố mả còn tí hàng, túm đầu cái bọc rác nhồi nhét tọng sâu đút lọt khe vô cái bọc lót hố rác Kafka (Kafka queue).
  3. Rút Ống Hút Phân Rì Rà (Asynchronous Drain): Cu li móc hố (Consumer workers) bới rác orders nặn đẻ rút ti rỉ rả chầm chậm một nhát an toàn vãi chưởng (safe write speed), bưng bít chốt chặn chẳng thể lọt vỡ mõm ba cái mả database chằng chéo trói xé ruột gan không bao giờ vỡ tim (never overwhelmed). (Móc Bọc Từ: Sổ Làng Công Nghệ Shopee Tech Blog)

Hỏi Nhanh Đáp Gọn (FAQ)

Trị Tận Gốc Cái Bệnh Lươn Lẹo Tráo Trở IP (IP spoofing) Ở Máng Bóp Cổ (rate limiter) Ra Răng?

CẤM TIỆT chọt mũi hửi cái rác X-Forwarded-For mà chưa lôi mấy kẻ bấu víu (proxies) ra tra khảo đâm chém rõ gốc rác (validating). chùi dọn cạo lông cho sạch mớ rác của bọn khách dúi bôi (client headers) ngay ngưỡng cửa lính canh đảo (edge reverse proxy), hoặc dựa lưng khom mình ôm cột PROXY protocol mọc rễ tít lổ sâu hạ tầng (transport layer) rước lọt danh tính mả TCP connection cội nguồn nhẵn thín (validated).

Nháy Hố Nào Ốp Mả Cục Căn Ruột (local in-memory) Tranh Miếng Cùng Mỏ Redis?

  • Rúc Ruột Trong Óc (x/time/rate): Đổ đèo 1 nháy xé gió (High throughput), héo hắt hụt hơi chẳng bận tâm ngứa chân (minimal latency overhead). Bưng ra xài đè ép mớ cùm khoanh vùng 1 vũng process (process-specific) rác rưởi hoặc hễ mày lụi hố ậm ờ nhắm mắt bóp ếch cho từng thằng lính node gác chuồng chia ly độc lập (horizontal node isolation).
  • Mỏ Hàng Xóm Redis: Móc vòi nhằng nhịt chia mâm nhồi cỗ ngập cả bầy nodes (Coordinated limits), chốt kèo dập khung đè nguyên lố dân (global quotas). Rập khuôn đập nát phải xài chóc khi nặn mớ luật đếm xỉa bòn rút cắc bạc theo từng thằng VIP (pricing/tier-based user thresholds).

Bãi Sình Kiến Trúc Bóp Cổ Thằng Hàng Xóm Envoy Ngó Làm Sao?

Envoy phủi chóp vứt mẹ rác quăng chén nặn luật hót hụi bóp cổ gán nợ cho 1 ổ con nợ dịch vụ ngụa (external service) xài vòi họng chọc gRPC filter (envoy.filters.http.ratelimit). Lổ gRPC server hót nặn rập khuôn luật RateLimitService của Lyft, nắn bóp cào phay nguyên dải cờ lê lôi vọt 1 chóp mả Redis cluster mâm cỗ lồi ruột xem thử ói khạc hay bợ cái đống rác request húp nước bóp trĩ (rate-limited).

🔗 Bay Sang Bài Tới: Phần 12: Mỏ Ngôn Ngữ Nhắn Hú Múa Lửa Hò Hét (Communication Protocols) — Đâm Lộn gRPC vs REST vs Phân Xé GraphQL Chốn Ổ Chuột Go Microservices