客戶端 → Nginx(OpenResty) → [Redis Cluster] → 源站
              ↓                    ↑
         Lua緩存邏輯          分布式存儲(chǔ)
         (get/set/stale)      (一致性哈希)

# 安裝OpenResty（內(nèi)置LuaJIT + ngx_lua模塊）
wget https://openresty.org/package/openresty-1.27.1.tar.gz
tar xzf openresty-1.27.1.tar.gz && cd openresty-1.27.1
./configure --with-luajit --with-http_redis2_module --with-http_lua_module
make && make install

# 安裝lua-resty-redis庫(kù)（若未內(nèi)置）
luarocks install lua-resty-redis

local redis = require "resty.redis"
local cjson = require "cjson.safe"

local _M = {}

-- Redis連接池配置
local REDIS_CONF = {
    host = "redis-cluster.internal",
    port = 6379,
    pool_size = 100,        -- 每worker連接池大小
    backlog = 200,          -- 等待隊(duì)列
    connect_timeout = 100,  -- ms
    read_timeout = 200,     -- ms
}

-- 獲取Redis連接（帶連接池）
local function get_redis()
    local red = redis:new()
    red:set_timeouts(REDIS_CONF.connect_timeout, 
                     REDIS_CONF.read_timeout, 
                     REDIS_CONF.read_timeout)
    
    local ok, err = red:connect(REDIS_CONF.host, REDIS_CONF.port)
    if not ok then
        ngx.log(ngx.ERR, "redis connect failed: ", err)
        return nil, err
    end
    
    return red, nil
end

-- 釋放連接到池中
local function release_redis(red)
    local ok, err = red:set_keepalive(10000, REDIS_CONF.pool_size)
    if not ok then
        ngx.log(ngx.ERR, "redis keepalive failed: ", err)
    end
end

-- 讀取緩存
function _M.get(key)
    local red, err = get_redis()
    if not red then return nil, err end
    
    local res, err = red:get(key)
    release_redis(red)
    
    if not res or res == ngx.null then
        return nil, "miss"
    end
    
    return cjson.decode(res), nil
end

-- 寫入緩存（帶TTL）
function _M.set(key, value, ttl)
    local red, err = get_redis()
    if not red then return false, err end
    
    local encoded = cjson.encode(value)
    local ok, err = red:setex(key, ttl, encoded)
    release_redis(red)
    
    return ok ~= nil, err
end

-- 刪除緩存
function _M.delete(key)
    local red, err = get_redis()
    if not red then return false, err end
    
    local ok, err = red:del(key)
    release_redis(red)
    
    return ok ~= nil, err
end

return _M

http {
    # Lua共享字典：用于本地二級(jí)緩存和鎖
    lua_shared_dict local_cache 100m;
    lua_shared_dict cache_locks 10m;
    init_by_lua_block {
        cache_handler = require "cache_handler"
    }
    server {
        listen 80;
        location /api/ {
            content_by_lua_block {
                local key = ngx.var.scheme .. ":" .. ngx.var.host .. ngx.var.uri
                -- 第1層：本地共享字典緩存（微秒級(jí)）
                local local_cache = ngx.shared.local_cache
                local val = local_cache:get(key)
                if val then
                    ngx.header["X-Cache"] = "LOCAL-HIT"
                    ngx.say(val)
                    return
                end
                -- 第2層：Redis外置緩存
                local data, err = cache_handler.get(key)
                if data then
                    -- 回填本地緩存（短TTL，防熱點(diǎn)穿透）
                    local_cache:set(key, cjson.encode(data), 5)
                    ngx.header["X-Cache"] = "REDIS-HIT"
                    ngx.say(cjson.encode(data))
                    return
                end
                -- 第3層：緩存擊穿防護(hù)（分布式鎖）
                local locks = ngx.shared.cache_locks
                local lock_key = "lock:" .. key
                local elapsed, err = locks:add(lock_key, true, 3)
                if elapsed then
                    -- 獲得鎖，回源
                    local res = ngx.location.capture("/internal/backend")
                    if res.status == 200 then
                        local body = res.body
                        -- 寫入Redis（長(zhǎng)TTL）
                        cache_handler.set(key, cjson.decode(body), 300)
                        -- 寫入本地緩存
                        local_cache:set(key, body, 5)
                        ngx.header["X-Cache"] = "MISS"
                        ngx.say(body)
                    else
                        ngx.status = res.status
                        ngx.say(res.body)
                    end
                    locks:delete(lock_key)
                else
                    -- 未獲得鎖，短暫等待后重試或直接回源
                    ngx.sleep(0.1)
                    local retry_data = cache_handler.get(key)
                    if retry_data then
                        ngx.header["X-Cache"] = "LOCK-WAIT-HIT"
                        ngx.say(cjson.encode(retry_data))
                    else
                        -- 降級(jí)：直接回源（不緩存）
                        local res = ngx.location.capture("/internal/backend")
                        ngx.header["X-Cache"] = "BYPASS"
                        ngx.status = res.status
                        ngx.say(res.body)
                    end
                end
            }
        }
        # 內(nèi)部回源location
        location /internal/backend {
            internal;
            proxy_pass http://backend;
            proxy_set_header Host $host;
        }
    }
}

-- ? 錯(cuò)誤：每次請(qǐng)求新建連接
local red = redis:new()
red:connect(...)
-- 請(qǐng)求結(jié)束連接銷毀
-- ? 正確：使用set_keepalive復(fù)用連接
red:set_keepalive(10000, 100)  -- 空閑10s，池大小100

-- ? 推薦：命名空間 + 版本 + 業(yè)務(wù)標(biāo)識(shí)
local key = "api:v2:user:profile:" .. user_id

-- ? 避免：直接使用URI
local key = ngx.var.uri  -- 參數(shù)順序變化導(dǎo)致重復(fù)緩存

-- Redis不可用時(shí)，降級(jí)到本地緩存或直接回源
local data, err = cache_handler.get(key)
if err and (err == "timeout" or err == "connection refused") then
    ngx.log(ngx.WARN, "redis degraded, fallback to backend")
    -- 跳過(guò)緩存，直接回源
    -- 或嘗試讀取過(guò)期的本地緩存作為兜底
end

-- 按前綴批量刪除（Redis SCAN + DEL，非KEYS）
function _M.delete_pattern(pattern)
    local red, err = get_redis()
    if not red then return false, err end
    local cursor = "0"
    repeat
        local res, err = red:scan(cursor, "MATCH", pattern, "COUNT", 100)
        if not res then break end
        cursor = res[1]
        local keys = res[2]
        if #keys > 0 then
            red:del(unpack(keys))
        end
    until cursor == "0"
    release_redis(red)
    return true, nil
end