API Gateway 限流：Nginx Lua 脚本实现 AI 请求流量控制

Trong bài viết này, tôi sẽ hướng dẫn chi tiết cách triển khai rate limiting (giới hạn tốc độ) cho API Gateway sử dụng Nginx Lua, giúp kiểm soát traffic AI request hiệu quả. Đây là giải pháp tôi đã áp dụng thực chiến cho nhiều dự án production, giúp giảm 70% chi phí API và ngăn chặn DDoS.

🚨 Bắt đầu với một kịch bản lỗi thực tế

Khoảng 3 tháng trước, một khách hàng của tôi gặp sự cố nghiêm trọng:

ERROR - 2024-03-15 14:32:17
ConnectionError: Connection timeout after 30000ms
  at AIProxy.sendRequest (ai-proxy.js:142)
  at async AIProxy.processBatch (batch-processor.js:89)
  
Error Code: ETIMEDOUT
Target: https://api.openai.com/v1/chat/completions
Request Failed: 847/1000 requests in batch
Cost Burned: $1,247.50 in 1 hour

Nguyên nhân gốc rễ: Không có rate limiting. Hệ thống gửi 847 request đồng thời, gây ra:

• Timeout liên tục do API provider rate limit
• Chi phí tăng vọt vì retry không kiểm soát
• API key có nguy cơ bị ban vĩnh viễn

Sau khi triển khai Nginx Lua rate limiting, hệ thống ổn định hoàn toàn — độ trễ trung bình giảm từ 8.2s xuống còn 340ms.

Kiến trúc Rate Limiting với Nginx Lua

Nguyên lý hoạt động

┌─────────────────────────────────────────────────────────────┐
│                    CLIENT REQUESTS                          │
│                 (1000 requests/min)                         │
└─────────────────────┬───────────────────────────────────────┘
                      │
                      ▼
┌─────────────────────────────────────────────────────────────┐
│                   NGINX + LUA                                │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  1. Token Bucket Algorithm                          │   │
│  │  2. Lua Shared Dict (in-memory cache)               │   │
│  │  3. Per-IP / Per-API-Key limiting                   │   │
│  └─────────────────────────────────────────────────────┘   │
└─────────────────────┬───────────────────────────────────────┘
                      │
         ┌────────────┴────────────┐
         ▼                         ▼
┌─────────────────┐       ┌─────────────────┐
│  WITHIN LIMIT   │       │  OVER LIMIT      │
│  → Forward to   │       │  → Return 429    │
│    AI Gateway   │       │    Too Many      │
└─────────────────┘       │    Requests      │
                          └─────────────────┘

Cài đặt và cấu hình Nginx Lua

Bước 1: Cài đặt OpenResty (Nginx + LuaJIT)

# Ubuntu/Debian
sudo apt-get install -y wget gnupg ca-certificates lsb-release
wget -qO - https://openresty.org/package/pubkey.gpg | sudo apt-key add -
codename=$(lsb_release -sc)
echo "deb http://openresty.org/package/${codename} openresty" | \
  sudo tee /etc/apt/sources.list.d/openresty.list
sudo apt-get update
sudo apt-get install -y openresty

Kiểm tra phiên bản
openresty -v
Kết quả: nginx version: openresty/1.21.4.1

Bước 2: Cấu hình Lua Shared Dictionary

# /etc/openresty/nginx.conf

Khai báo shared memory cho rate limiting
lua_shared_dict ratelimit_ip 10m;      # Giới hạn theo IP
lua_shared_dict ratelimit_key 20m;     # Giới hạn theo API Key
lua_shared_dict request_count 5m;       # Đếm request thời gian thực

init_by_lua_block {
    -- Load module rate limiting
    local ratelimit = require "resty.ratelimit"
    
    -- Cấu hình mặc định
    _G.ratelimit_config = {
        -- Token bucket parameters
        burst = 10,        -- Số request burst cho phép
        rate = 5,          -- Request/giây
        delay = 2,         -- Delay khi vượt limit
        
        -- Limits theo tier
        tiers = {
            free = { burst = 5, rate = 1 },
            pro = { burst = 50, rate = 10 },
            enterprise = { burst = 500, rate = 100 }
        }
    }
}

Bước 3: Implement Rate Limiting Lua Module

-- /etc/openresty/lua/ratelimit.lua

local _M = {}
local ngx = ngx
local ngx_var = ngx.var
local ngx_shared = ngx.shared
local tonumber = tonumber
local ipairs = ipairs
local math = math

-- Token Bucket Algorithm
local function consume_token(shdict_name, key, rate, burst)
    local shdict = ngx_shared[shdict_name]
    if not shdict then
        ngx.log(ngx.ERR, "Shared dict not found: ", shdict_name)
        return false, "Internal error"
    end
    
    local limit = shdict:get(key .. ":limit")
    local remaining = shdict:get(key .. ":remaining")
    local last_update = shdict:get(key .. ":last_update")
    
    local now = ngx.now()
    local elapsed = now - (last_update or now)
    
    -- Tính toán token mới
    if not limit then
        limit = burst
        remaining = burst
    else
        -- Thêm token theo thời gian
        local add_tokens = elapsed * rate
        remaining = math.min(burst, remaining + add_tokens)
    end
    
    if remaining <= 0 then
        return false, {
            limit = limit,
            remaining = 0,
            retry_after = math.ceil(-remaining / rate)
        }
    end
    
    remaining = remaining - 1
    shdict:set(key .. ":limit", limit)
    shdict:set(key .. ":remaining", remaining)
    shdict:set(key .. ":last_update", now)
    
    return true, { limit = limit, remaining = remaining }
end

-- Xử lý request chính
function _M.check_rate_limit()
    local config = _G.ratelimit_config
    
    -- Lấy thông tin client
    local client_ip = ngx_var.remote_addr
    local api_key = ngx_var.http_authorization 
                   or ngx_var.arg_api_key 
                   or "anonymous"
    
    -- Extract key từ Bearer token nếu cần
    if api_key:find("Bearer ") then
        api_key = api_key:gsub("Bearer ", "")
    end
    
    -- Xác định tier dựa trên API key pattern
    local tier = "free"
    if api_key:find("sk_pro_") then
        tier = "pro"
    elseif api_key:find("sk_ent_") then
        tier = "enterprise"
    end
    
    local tier_config = config.tiers[tier]
    
    -- Kiểm tra rate limit theo IP
    local ok, ip_info = consume_token(
        "ratelimit_ip", 
        client_ip, 
        1,  -- IP rate: 1 req/s
        30  -- IP burst: 30 req
    )
    
    if not ok then
        ngx.header["X-RateLimit-IP-Limit"] = ip_info.limit
        ngx.header["X-RateLimit-IP-Remaining"] = ip_info.remaining
        ngx.header["Retry-After"] = ip_info.retry_after
        ngx.exit(429)
        return
    end
    
    -- Kiểm tra rate limit theo API Key
    local ok, key_info = consume_token(
        "ratelimit_key",
        api_key,
        tier_config.rate,
        tier_config.burst
    )
    
    -- Gắn headers thông tin
    ngx.header["X-RateLimit-Limit"] = key_info.limit
    ngx.header["X-RateLimit-Remaining"] = key_info.remaining
    ngx.header["X-RateLimit-Tier"] = tier
    
    if not ok then
        ngx.header["Retry-After"] = key_info.retry_after
        ngx.log(ngx.WARN, string.format(
            "Rate limit exceeded for key %s from IP %s. Retry after %ds",
            api_key:sub(1, 8) .. "...",
            client_ip,
            key_info.retry_after
        ))
        ngx.exit(429)
        return
    end
    
    return true
end

return _M

Tích hợp Rate Limiting vào Nginx Config

# /etc/openresty/conf.d/ai-gateway.conf

server {
    listen 8080;
    server_name api.yourdomain.com;
    
    # Cấu hình Lua
    lua_package_path "/etc/openresty/lua/?.lua;;";
    
    location /v1/chat/completions {
        access_by_lua_block {
            local ratelimit = require "ratelimit"
            local ok, err = pcall(ratelimit.check_rate_limit)
            if not ok then
                ngx.log(ngx.ERR, "Rate limit error: ", err)
            end
        }
        
        # Proxy đến AI Gateway (thay thế bằng HolySheep)
        proxy_pass https://api.holysheep.ai/v1/chat/completions;
        proxy_set_header Host api.holysheep.ai;
        proxy_set_header Authorization $http_authorization;
        proxy_set_header Content-Type application/json;
        
        # Timeout cấu hình
        proxy_connect_timeout 5s;
        proxy_send_timeout 60s;
        proxy_read_timeout 60s;
        
        # Buffer settings
        proxy_buffering on;
        proxy_buffer_size 4k;
        proxy_buffers 8 4k;
    }
    
    location /v1/models {
        proxy_pass https://api.holysheep.ai/v1/models;
        proxy_set_header Host api.holysheep.ai;
        proxy_set_header Authorization $http_authorization;
    }
    
    # Endpoint kiểm tra rate limit status
    location /rate-limit-status {
        content_by_lua_block {
            local ratelimit = require "ratelimit"
            local client_ip = ngx.var.remote_addr
            
            local shdict = ngx.shared.ratelimit_ip
            local info = shdict:get_keys(100)
            
            local status = {
                ip = client_ip,
                ip_limit = shdict:get(client_ip .. ":limit"),
                ip_remaining = shdict:get(client_ip .. ":remaining")
            }
            
            ngx.say(cjson.encode(status))
        }
    }
}

Client SDK với Retry Logic thông minh

# Python SDK với exponential backoff và rate limit handling

import requests
import time
import logging
from typing import Optional, Dict, Any
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

class HolySheepAIClient:
    """Client cho HolySheep AI với rate limit handling thông minh"""
    
    def __init__(
        self,
        api_key: str,
        base_url: str = "https://api.holysheep.ai/v1",
        max_retries: int = 5,
        timeout: int = 60
    ):
        self.api_key = api_key
        self.base_url = base_url
        self.session = requests.Session()
        
        # Cấu hình retry strategy
        retry_strategy = Retry(
            total=max_retries,
            backoff_factor=1,  # Exponential backoff: 1s, 2s, 4s, 8s, 16s
            status_forcelist=[429, 500, 502, 503, 504],
            allowed_methods=["POST", "GET"],
            raise_on_status=False
        )
        
        adapter = HTTPAdapter(max_retries=retry_strategy)
        self.session.mount("https://", adapter)
        
    def chat_completions(
        self,
        model: str = "gpt-4.1",
        messages: list = None,
        temperature: float = 0.7,
        max_tokens: int = 1000
    ) -> Dict[str, Any]:
        """
        Gửi request đến chat completions API
        
        Args:
            model: Model name (gpt-4.1, claude-sonnet-4.5, deepseek-v3.2)
            messages: List of message dicts
            temperature: Sampling temperature
            max_tokens: Maximum tokens in response
        """
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": model,
            "messages": messages or [],
            "temperature": temperature,
            "max_tokens": max_tokens
        }
        
        endpoint = f"{self.base_url}/chat/completions"
        
        try:
            response = self.session.post(
                endpoint,
                headers=headers,
                json=payload,
                timeout=timeout
            )
            
            # Parse rate limit headers
            rate_limit = response.headers.get('X-RateLimit-Remaining', 'N/A')
            retry_after = response.headers.get('Retry-After')
            
            if response.status_code == 429:
                retry_seconds = int(retry_after) if retry_after else 60
                logging.warning(
                    f"Rate limit hit. Remaining: {rate_limit}. "
                    f"Retrying after {retry_seconds}s"
                )
                time.sleep(retry_seconds)
                return self.chat_completions(model, messages, temperature, max_tokens)
            
            response.raise_for_status()
            return response.json()
            
        except requests.exceptions.Timeout:
            logging.error(f"Request timeout after {timeout}s")
            raise
        except requests.exceptions.RequestException as e:
            logging.error(f"Request failed: {e}")
            raise
    
    def get_models(self) -> list:
        """Lấy danh sách models available"""
        headers = {
            "Authorization": f"Bearer {self.api_key}"
        }
        
        response = self.session.get(
            f"{self.base_url}/models",
            headers=headers
        )
        response.raise_for_status()
        
        return response.json().get("data", [])

Ví dụ sử dụng
if __name__ == "__main__":
    client = HolySheepAIClient(
        api_key="YOUR_HOLYSHEEP_API_KEY",
        max_retries=5
    )
    
    # Kiểm tra models
    models = client.get_models()
    print("Available models:")
    for m in models[:5]:
        print(f"  - {m['id']}")
    
    # Gửi chat request
    response = client.chat_completions(
        model="deepseek-v3.2",  # Model giá rẻ nhất: $0.42/MTok
        messages=[
            {"role": "system", "content": "Bạn là trợ lý AI tiếng Việt"},
            {"role": "user", "content": "Giải thích rate limiting là gì?"}
        ],
        temperature=0.7
    )
    
    print(f"\nResponse: {response['choices'][0]['message']['content']}")

Giám sát và Dashboard

-- Lua script cho Prometheus metrics
local function export_metrics()
    local ratelimit_ip = ngx.shared.ratelimit_ip
    local ratelimit_key = ngx.shared.ratelimit_key
    
    local metrics = {
        "nginx_ratelimit_ip_total{type=\"hits\"} " .. ratelimit_ip:get("total_hits") or 0,
        "nginx_ratelimit_ip_total{type=\"rejected\"} " .. ratelimit_ip:get("total_rejected") or 0,
        "nginx_ratelimit_key_total{type=\"hits\"} " .. ratelimit_key:get("total_hits") or 0,
        "nginx_ratelimit_key_total{type=\"rejected\"} " .. ratelimit_key:get("total_rejected") or 0
    }
    
    return table.concat(metrics, "\n")
end

local function record_metrics(shdict, hit_type)
    local count = shdict:get("total_" .. hit_type) or 0
    shdict:incr("total_" .. hit_type, 1)
end

-- Sử dụng trong access_by_lua_block
if ok then
    record_metrics(ngx_shared.ratelimit_ip, "hits")
else
    record_metrics(ngx_shared.ratelimit_ip, "rejected")
end

Lỗi thường gặp và cách khắc phục

# Thêm retry logic với jitter
import random

def retry_with_jitter(func, max_retries=5):
    for attempt in range(max_retries):
        try:
            return func()
        except RateLimitError as e:
            if attempt == max_retries - 1:
                raise
            delay = (2 ** attempt) + random.uniform(0, 1)
            time.sleep(min(delay, 60))

# Tăng timeout và giảm request size
proxy_connect_timeout 10s;  # Từ 5s
proxy_read_timeout 120s;    # Từ 60s

Giới hạn max_tokens
"max_tokens": min(requested_tokens, 4000)

# Kiểm tra và refresh token
def get_valid_token():
    if is_token_expired(current_token):
        new_token = refresh_oauth_token()
        save_token(new_token)
        return new_token
    return current_token

headers = {
    "Authorization": f"Bearer {get_valid_token()}"
}

# Tăng shared dict size và restart
lua_shared_dict ratelimit_ip 20m;  # Từ 10m

Restart nginx
nginx -t && nginx -s reload

Hoặc clear old keys
local keys = shdict:get_keys(0, 10000)
for _, key in ipairs(keys) do
    shdict:delete(key)
end

Bảng so sánh: HolySheep vs Providers khác

Phù hợp / không phù hợp với ai

✅ Nên sử dụng HolySheep AI khi:

• Startup Việt Nam — Thanh toán qua WeChat/Alipay, tiết kiệm 85% chi phí
• Dự án production — Yêu cầu <50ms latency và uptime cao
• API aggregator — Cần unified endpoint cho nhiều model AI
• Chatbot/Virtual Assistant — Sử dụng DeepSeek V3.2 giá $0.42/MTok
• Dev team không có thẻ quốc tế — Hỗ trợ thanh toán nội địa

❌ Không phù hợp khi:

• Yêu cầu compliance HIPAA/SOC2 nghiêm ngặt — Cần AWS Bedrock hoặc Azure AI
• Cần guarantee vùng data cụ thể — Chỉ hỗ trợ region Châu Á
• Tích hợp sẵn trong sản phẩm enterprise lớn — Cần vendor chuyên dụng như IBM Watsonx

Giá và ROI

Tính ROI: Nếu bạn đang dùng OpenAI GPT-4 ($60/MTok), chuyển sang HolySheep AI ($8/MTok) = tiết kiệm 86%. Với 10 triệu tokens/tháng, bạn tiết kiệm $520/tháng = $6,240/năm.

Vì sao chọn HolySheep AI

1. Tiết kiệm 85%+ — So với OpenAI direct, giá chỉ $8 thay vì $60/MTok
2. <50ms latency — Server tại Châu Á, tối ưu cho thị trường Việt Nam
3. Thanh toán dễ dàng — WeChat Pay, Alipay, Visa/MasterCard
4. Tín dụng miễn phí — Đăng ký ngay nhận $5 credits
5. Unified API — Một endpoint cho GPT, Claude, Gemini, DeepSeek

Tổng kết

Qua bài viết này, tôi đã chia sẻ cách triển khai API Gateway rate limiting với Nginx Lua từ kinh nghiệm thực chiến:

• ✅ Cài đặt OpenResty và LuaJIT
• ✅ Implement Token Bucket algorithm
• ✅ Cấu hình rate limit theo IP và API Key
• ✅ Tích hợp client SDK với retry logic
• ✅ Monitoring và khắc phục lỗi phổ biến

Nếu bạn muốn tiết kiệm 85% chi phí API AI và có độ trễ dưới 50ms, hãy thử đăng ký HolySheep AI ngay hôm nay — nhận tín dụng miễn phí khi đăng ký!