Nginx+Lua动态加载黑名单的实现方案

http {
    # 定义共享内存区（50MB可存储约100万IP）
    lua_shared_dict ip_blacklist 50m;
    # 初始化脚本（加载Lua模块）
    init_by_lua_block {
        -- 初始化Redis连接
        local redis = require "resty.redis"
        red = redis:new()
        red:set_timeout(1000)  -- 1秒超时
    }
    server {
        listen 80;
        # 黑名单检查入口
        access_by_lua_file /etc/nginx/lua/ip_blacklist.lua;
        location / {
            proxy_pass http://backend;
        }
    }
}

local function load_blacklist()
    local red = ngx.shared.ip_blacklist
    local last_update = red:get("last_update") or 0
    -- 每60秒更新一次（避免频繁请求Redis）
    if ngx.now() - last_update > 60 then
        local redis_conn = require "resty.redis":new()
        local ok, err = redis_conn:connect("redis-host", 6379)
        if not ok then
            ngx.log(ngx.ERR, "Redis连接失败: ", err)
            return
        end
        -- 从Redis获取最新黑名单
        local black_ips, err = redis_conn:smembers("ip_blacklist")
        if not black_ips then
            ngx.log(ngx.ERR, "获取黑名单失败: ", err)
            return
        end
        -- 清空旧数据
        red:flush_all()
        -- 写入新数据
        for _, ip in ipairs(black_ips) do
            red:set(ip, true)  -- IP作为key存储
        end
        -- 记录更新时间
        red:set("last_update", ngx.now())
        redis_conn:close()
    end
end
-- 主执行逻辑
local client_ip = ngx.var.remote_addr
local blacklist = ngx.shared.ip_blacklist
-- 检查是否在黑名单
if blacklist:get(client_ip) then
    ngx.log(ngx.WARN, "拦截黑名单IP: ", client_ip)
    return ngx.exit(403)  -- 返回禁止访问
end
-- 异步更新黑名单（不阻塞请求）
ngx.timer.at(0, load_blacklist)

# 添加IP到黑名单
> SADD ip_blacklist 192.168.1.100
# 从黑名单移除
> SREM ip_blacklist 192.168.1.100
# 查看所有黑名单IP
> SMEMBERS ip_blacklist

-- 在Lua脚本中添加本地缓存
local local_cache = {}
local function is_blacklisted(ip)
    -- 第一层：Lua本地缓存
    if local_cache[ip] ~= nil then
        return local_cache[ip]
    end
    -- 第二层：共享内存
    local val = ngx.shared.ip_blacklist:get(ip)
    local_cache[ip] = val  -- 缓存结果
    return val
end

-- 只同步变更的IP（减少数据传输）
local changes = redis_conn:get("ip_blacklist_changes")
if changes then
    for ip, action in pairs(cjson.decode(changes)) do
        if action == "add" then
            ngx.shared.ip_blacklist:set(ip, true)
        else
            ngx.shared.ip_blacklist:delete(ip)
        end
    end
end

-- 在Nginx日志分析后自动封禁
location /log_analyzer {
    content_by_lua_block {
        local log_parser = require "log_parser"
        local attackers = log_parser.detect_attackers()
        for ip, count in pairs(attackers) do
            if count > 100 then  -- 1分钟内100次请求
                local redis = require "resty.redis":new()
                redis:sadd("ip_blacklist", ip)
            end
        end
    }
}

# 通过Nginx配置分批次更新
map $remote_addr $update_flag {
    default         0;
    "192.168.1.1"   1;   # 管理员IP
    "10.0.0.0/8"    1;   # 内网IP
}
server {
    access_by_lua_block {
        if ngx.var.update_flag == "1" then
            load_blacklist()  -- 强制更新
        end
    }
}

# Prometheus监控指标
nginx_http_lua_blacklist_size{type="ip"} 1024
nginx_http_lua_blocked_requests_total 53289

# 调整共享内存淘汰策略
lua_shared_dict ip_blacklist 100m inactive=2d; # 2天未访问自动清除

-- 添加故障转移逻辑
local redis_hosts = {
    {host="redis1", port=6379},
    {host="redis2", port=6380}
}
for _, server in ipairs(redis_hosts) do
    local ok = redis_conn:connect(server.host, server.port)
    if ok then break end
end

# 优先使用真实IP（防代理层伪造）
real_ip_header X-Forwarded-For;
set_real_ip_from 0.0.0.0/0;

-- 组合频次控制+黑名单
local req_count = ngx.shared.req_count:incr(client_ip, 1)
if req_count > 100 then  -- 每秒100次请求
    ngx.shared.ip_blacklist:set(client_ip, true)
end

location /api/payment {
    access_by_lua_block {
        if ngx.shared.ip_blacklist:get(ip) then
            ngx.exit(444)  -- 静默关闭连接
        end
    }
}

-- 结合IP地理库
local geo = require "geoip"
local country = geo.get_country(client_ip)
if country == "CN" then  -- 允许中国IP
    -- 放行
else
    ngx.shared.ip_blacklist:set(client_ip, true)
end