如何在Nginx中实现动态请求过滤规则

http {
    # 引入动态规则文件（IP封禁、路径拦截）
    include /etc/nginx/conf.d/dynamic_filter/*.conf;

    server {
        listen 80;
        server_name localhost;

        # ========== 1. IP封禁规则 ==========
        if ($blocked_ip) {
            return 403 "IP已被封禁";
        }

        # ========== 2. 路径拦截规则 ==========
        if ($blocked_path) {
            return 503 "接口临时维护";
        }

        # ========== 3. 请求方法限制 ==========
        if ($disallowed_method) {
            return 405 "不支持的请求方法";
        }

        # 正常转发请求到后端服务
        location / {
            proxy_pass http://127.0.0.1:8080;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
        }
    }
}

# 1. IP封禁规则（map 指令：匹配客户端IP，返回1则封禁）
map $remote_addr $blocked_ip {
    default 0;          # 默认不封禁
    192.168.1.100 1;    # 封禁IP 192.168.1.100
    10.0.0.5 1;         # 封禁IP 10.0.0.5
}

# 2. 路径拦截规则（map 指令：匹配请求路径，返回1则拦截）
map $request_uri $blocked_path {
    default 0;
    /api/test 1;        # 拦截路径 /api/test
    /admin 1;           # 拦截路径 /admin
}

# 3. 请求方法限制（仅允许 GET/POST）
map $request_method $disallowed_method {
    default 1;          # 默认拦截
    GET 0;              # 放行 GET
    POST 0;             # 放行 POST
}

# 编辑 block_rules.conf，添加新IP
echo "map \$remote_addr \$blocked_ip {
    default 0;
    192.168.1.100 1;
    10.0.0.5 1;
    172.16.0.8 1; # 新增封禁IP
}" > /etc/nginx/conf.d/dynamic_filter/block_rules.conf

nginx -s reload

# 访问被封禁IP的接口，返回403
curl -x 127.0.0.1:80 http://localhost/api/test -H "X-Real-IP: 192.168.1.100"
# 返回：IP已被封禁（状态码403）

# 用 PUT 方法访问，返回405
curl -X PUT http://localhost/api/test
# 返回：不支持的请求方法（状态码405）

map $remote_addr $blocked_ip {
    default 0;
    192.168.1.100 1;
}
map $request_uri $blocked_path {
    default 0;
    /api/test 1;
}

#!/bin/bash
# 配置中心地址
NACOS_URL="http://127.0.0.1:8848/nacos/v1/cs/configs?dataId=nginx_block_rules.conf&group=DEFAULT_GROUP"
# Nginx 规则文件路径
RULE_FILE="/etc/nginx/conf.d/dynamic_filter/block_rules.conf"
# 临时文件
TMP_FILE="/tmp/nginx_block_rules.tmp"

# 1. 从 Nacos 拉取最新规则
curl -s $NACOS_URL -o $TMP_FILE

# 2. 对比规则是否变更（避免重复热加载）
if ! diff $TMP_FILE $RULE_FILE > /dev/null; then
    # 3. 更新规则文件
    cp $TMP_FILE $RULE_FILE
    # 4. 验证 Nginx 配置语法
    nginx -t
    if [ $? -eq 0 ]; then
        # 5. 语法正确，热加载配置
        nginx -s reload
        echo "$(date)：规则更新并热加载成功" >> /var/log/nginx/rule_update.log
    else
        echo "$(date)：配置语法错误，放弃热加载" >> /var/log/nginx/rule_update.log
    fi
fi

# 6. 删除临时文件
rm -f $TMP_FILE

# 编辑 crontab
crontab -e

# 添加定时任务（每10秒执行）
*/10 * * * * /bin/bash /usr/local/bin/update_nginx_rules.sh

# CentOS
yum install openresty -y
# Ubuntu
apt install openresty -y

http {
    # 加载 Lua 模块
    lua_package_path "/usr/local/openresty/lualib/?.lua;;";
    lua_package_cpath "/usr/local/openresty/lualib/?.so;;";

    server {
        listen 80;
        server_name localhost;

        # 每个请求执行 Lua 过滤脚本
        access_by_lua_block {
            -- 1. 引入自定义过滤脚本
            local filter = require("dynamic_filter")
            -- 2. 执行过滤逻辑（返回 true 则拦截）
            local blocked = filter.check_rules(ngx.var.remote_addr, ngx.var.request_uri, ngx.var.request_method)
            if blocked then
                ngx.status = 403
                ngx.say("请求被拦截")
                ngx.exit(403)
            end
        }

        # 转发请求到后端
        location / {
            proxy_pass http://127.0.0.1:8080;
        }
    }
}

local redis = require "resty.redis"

-- 检查过滤规则
function _M.check_rules(client_ip, request_uri, request_method)
    -- 1. 连接 Redis（存储动态规则）
    local red = redis:new()
    red:set_timeout(1000) -- 1秒超时
    local ok, err = red:connect("127.0.0.1", 6379)
    if not ok then
        ngx.log(ngx.ERR, "Redis 连接失败：", err)
        return false -- 连接失败时放行
    end

    -- 2. 从 Redis 获取封禁IP列表
    local blocked_ips = red:smembers("nginx:blocked_ips")
    for _, ip in ipairs(blocked_ips) do
        if client_ip == ip then
            red:close()
            return true -- IP 封禁，拦截请求
        end
    end

    -- 3. 从 Redis 获取拦截路径列表
    local blocked_paths = red:smembers("nginx:blocked_paths")
    for _, path in ipairs(blocked_paths) do
        if request_uri == path then
            red:close()
            return true -- 路径拦截
        end
    end

    -- 4. 关闭 Redis 连接
    red:close()
    return false -- 规则通过，放行
end

return _M

# 1. 封禁IP（添加到 Redis 集合）
redis-cli SADD nginx:blocked_ips 192.168.1.100

# 2. 拦截路径
redis-cli SADD nginx:blocked_paths /api/test

# 3. 解封IP
redis-cli SREM nginx:blocked_ips 192.168.1.100

# apisix/config.yaml
routes:
  - id: 1
    uri: /*
    upstream:
      nodes:
        "127.0.0.1:8080": 1
    plugins:
      ip-restriction:
        blacklist:
          - 192.168.1.100
          - 10.0.0.5

curl -X PUT http://127.0.0.1:9180/apisix/admin/routes/1 \
-H "X-API-KEY: edd1c9f034335f136f87ad84b625c8f1" \
-d '{
  "uri": "/*",
  "upstream": {"nodes": {"127.0.0.1:8080": 1}},
  "plugins": {
    "ip-restriction": {"blacklist": ["192.168.1.100", "10.0.0.5", "172.16.0.8"]}
  }
}'