1
2

CLOSED → (quá nhiều lỗi) → OPEN → (timeout) → HALF-OPEN → (thành công) → CLOSED
                                                            → (thất bại) → OPEN

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# Token Bucket với Redis (atomic, hoạt động với nhiều server)
import redis, time

r = redis.Redis()

def is_allowed(user_id: str, rate: int = 10, burst: int = 100) -> bool:
    now = time.time()
    key = f"bucket:{user_id}"
    
    pipe = r.pipeline()
    pipe.hgetall(key)
    pipe.expire(key, 60)
    result = pipe.execute()
    
    bucket = result[0]
    tokens = float(bucket.get(b"tokens", burst))
    last_refill = float(bucket.get(b"last_refill", now))
    
    # Nạp token theo thời gian đã trôi qua
    elapsed = now - last_refill
    tokens = min(burst, tokens + elapsed * rate)
    
    if tokens < 1:
        return False  # 429
    
    # Tiêu tốn 1 token
    r.hset(key, mapping={"tokens": tokens - 1, "last_refill": now})
    return True

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# Dùng thư viện 'circuitbreaker'
from circuitbreaker import circuit

@circuit(
    failure_threshold=5,    # Mở sau 5 lỗi liên tiếp
    recovery_timeout=30,    # Chờ 30 giây trước khi thử HALF-OPEN
    expected_exception=Exception
)
def call_payment_api(order_id: str) -> dict:
    response = requests.post("https://payment-service/charge", json={"order": order_id})
    response.raise_for_status()
    return response.json()


def process_order(order_id: str):
    try:
        result = call_payment_api(order_id)
    except CircuitBreakerError:
        # Mạch đang OPEN — không thử nữa. Fail nhanh với fallback.
        return {"status": "pending", "message": "Payment service đang sập. Sẽ thử lại sau."}
    except Exception as e:
        return {"status": "error", "message": str(e)}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import time, random

def call_with_retry(fn, max_retries=3):
    for attempt in range(max_retries):
        try:
            return fn()
        except Exception as e:
            if attempt == max_retries - 1:
                raise  # Lần thử cuối: ném lại lỗi
            wait = (2 ** attempt) + random.uniform(0, 1)  # Exponential + Jitter
            time.sleep(wait)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Không có Bulkhead: tất cả thread dùng chung một pool
# Một endpoint chậm làm cạn kiệt thread của tất cả endpoint khác

# Có Bulkhead: mỗi service quan trọng có pool thread riêng
from concurrent.futures import ThreadPoolExecutor

payment_executor = ThreadPoolExecutor(max_workers=5, thread_name_prefix="payment")
notification_executor = ThreadPoolExecutor(max_workers=10, thread_name_prefix="notif")

# Payment chậm không ảnh hưởng đến notification
future = payment_executor.submit(call_payment_api, order_id)

1
2
3
4
5
6
7

Rate Limiter    -> Đèn Giao thông. Kiểm soát luồng vào. Bảo vệ BẠN khỏi client.
Circuit Breaker -> Hộp Cầu dao. Kiểm soát luồng ra. Bảo vệ BẠN khỏi dependency.

Token Bucket    -> Luồng đều đặn, cho phép bùng phát ngắn.
CLOSED          -> Mọi thứ bình thường. Cho traffic đi qua.
OPEN            -> Dependency lỗi. Dừng gọi. Trả về cache/fallback.
Exponential Backoff -> "Chờ 1s, 2s, 4s, 8s trước khi thử lại." Tránh đám đông sấm sét.