brew tap openresty/brew
brew install openresty

checking for GeoIP library ... not found
checking for GeoIP library in /usr/local/ ... not found
checking for GeoIP library in /usr/pkg/ ... not found
checking for GeoIP library in /opt/local/ ... not found
checking for GeoIP library in /opt/homebrew/ ... not found

./configure: error: the GeoIP module requires the GeoIP library.
You can either do not enable the module or install the library.

# 编辑 openresty 的安装脚本
brew edit openresty/brew/openresty

# 将下面的行注释掉后保存并退出
# args << "--with-http_geoip_module"

# 重新安装
brew reinstall openresty

openresty -h
nginx version: openresty/1.29.2.1
Usage: nginx [-?hvVtTq] [-s signal] [-p prefix]
             [-e filename] [-c filename] [-g directives]

Options:
  -?,-h         : this help
  -v            : show version and exit
  -V            : show version and configure options then exit
  -t            : test configuration and exit
  -T            : test configuration, dump it and exit
  -q            : suppress non-error messages during configuration testing
  -s signal     : send signal to a master process: stop, quit, reopen, reload
  -p prefix     : set prefix path (default: /usr/local/Cellar/openresty/1.29.2.1_1/nginx/)
  -e filename   : set error log file (default: /usr/local/var/log/nginx/error.log)
  -c filename   : set configuration file (default: /usr/local/etc/openresty/nginx.conf)
  -g directives : set global directives out of configuration file

# 安装目录
/usr/local/opt/openresty
# 配置文件目录
/usr/local/etc/openresty/

sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://openresty.org/package/amazon/openresty.repo
sudo yum install -y openresty

# 安装目录
/usr/local/openresty
# 配置文件目录
/usr/local/openresty/nginx/conf

worker_processes  1;
events {
    worker_connections 1024;
}
http {
    server {
        listen 8080;
        location / {
            default_type text/html;
            # 这是 OpenResty 提供的 Lua 指令: 在 HTTP 请求的 Content 阶段 执行 Lua 代码，用于生成响应内容。
            content_by_lua_block {
                -- ngx: OpenResty 提供的全局对象，封装了 Nginx API，可用于：写响应、读请求、操作 header、访问共享内存、控制状态码
                -- ngx.say(...): 向 HTTP 响应体写入内容，自动追加换行符 \n，可多次调用
                -- 等价于：ngx.print("<p>hello, world</p>\n")
                ngx.say("<p>hello, world</p>")
            }
        }
    }
}

HTTP/1.1 200 OK
Content-Type: text/html

<p>hello, world</p>

openresty -p `pwd` -c ./test-nginx.conf

curl http://127.0.0.1:8080
# 结果
<p>hello, world</p>

rewrite  →  access  →  content  →  log

server {
    listen 8080;

    # 方式1.content_by_lua_block ：lua 内嵌代码块
    location /hello-lua {
        default_type 'text/plain';
        content_by_lua_block {
        ngx.say("Hello World! Lua & Nginx .")
        }
    }

    # 方式2.content_by_lua_file ：lua 脚本文件路径
    location /hello-lua-file {
        default_type 'text/html';
        content_by_lua_file ./lua/hello.lua;
    }

    # 方式3.access_by_lua 在请求访问阶段处理用于访问控制 ：lua 字符串
    location /hello-lua-access {
        default_type 'text/html';
        access_by_lua '
        local message = "403 - Hello World! Lua & Nginx  access_by_lua"
        ngx.say(message)
        ';
    }

    # 方式4.content_by_lua 在内容处理阶段接受请求并输出响应：lua 字符串
    location /hello-lua-content {
        default_type 'text/html';
        content_by_lua "ngx.print('Hello World!')";
    }
}

GET /api?user=tom&age=18

# 示例请求
POST /api
Content-Type: application/x-www-form-urlencoded

user=tom&age=18

# 示例请求
POST /api
Content-Type: application/json

{"user":"tom","age":18}

维度：客户端 IP
窗口：60 秒
阈值：10 次
算法：固定窗口计数器(0秒-60秒的每个整分钟内)，实现复杂度极低，性能极高，但有边界突刺问题，可以使用滑动窗口算法(第一次访问后的最近 60 秒内)
存储：Redis

rate:{client_ip}:{minute_timestamp}
# TTL：70 秒（防止残留）

# 指定 Nginx Worker 进程数量，生产环境：等于 CPU 核心数，建议配置为 auto，自动适配
worker_processes auto;
# 指定错误日志路径，所有错误都会写入该日志文件，包括 Lua ngx.log(ngx.ERR, ...)
error_log logs/error.log;
# 定义事件模型参数
events {
    # 单个 Worker 最大并发连接数
    worker_connections  1024;
}

http {
    # Lua 模块加载路径
    # 语法规则
    #  ?.lua 表示模块文件名占位符。
    #  ;; 表示 保留默认路径，否则会覆盖系统默认路径。
    lua_package_path "/usr/local/openresty/lualib/?.lua;;";

    # ----------------------------
    # Redis 原子限流 Lua 脚本
    # ----------------------------

    # 创建一块 共享内存区，名称：redis_scripts，大小：1MB（Worker 之间共享内存）
    # 常用于：缓存 Lua 脚本、Token、计数器、配置信息
    lua_shared_dict redis_scripts 1m;

    # Worker 初始化阶段加载 Lua，在 每个 Worker 启动时执行一次
    # 适合：加载配置、初始化缓存、预加载脚本、启动定时器
    init_worker_by_lua_block {
        -- 将 Lua 脚本加载到 Nginx Worker 内存
        local script = [[
            -- 对指定 Key 进行自增
            local cnt = redis.call("INCR", KEYS[1])
            -- 如果是第一次创建 Key
            if cnt == 1 then
                -- 设置 Key 过期时间(秒)
                redis.call("EXPIRE", KEYS[1], ARGV[1])
            end
            -- 返回当前计数
            return cnt
        ]]
        -- 将 Lua 脚本存入共享内存，避免每次请求拼接 Lua 脚本字符串，提升性能
        local dict = ngx.shared.redis_scripts
        -- Key：rate_limit_lua，Value：Lua 脚本
        dict:set("rate_limit_lua", script)
    }

    server {
        listen 8080;

        location /api {
            # 在 content 阶段执行 Lua，完全由 Lua 生成响应内容
            content_by_lua_block {
                -- 加载 OpenResty 官方 Redis 客户端
                local redis = require "resty.redis"
                -- 创建 Redis 对象
                local red = redis:new()
                -- Redis 连接信息
                local redis_ip = "127.0.0.1"
                local redis_port = 6379
                local redis_timeout = 500
                local redis_user = "admin"
                local redis_pass = "123456"

                -- 关闭redis连接的工具方法，其实是放入连接池
                local function close_redis(red)
                    local pool_max_idle_time = 10000 -- 连接的空闲时间，单位是毫秒
                    local pool_size = 100 --连接池大小
                    -- 将连接放回连接池，后续请求可复用
                    local ok, err = red:set_keepalive(pool_max_idle_time, pool_size)
                    if not ok then
                        -- 失败时记录错误日志
                        ngx.log(ngx.ERR, "放入redis连接池失败: ", err)
                    end
                end

                -- 超时（毫秒）
                red:set_timeout(redis_timeout)

                -- 建立 Redis 连接，若连接池有空闲连接会复用
                local ok, err = red:connect(redis_ip, redis_port)
                if not ok then
                    ngx.log(ngx.ERR, "redis connect failed: ", err)
                    -- 连接失败返回 500 错误码
                    return ngx.exit(500)
                end

                -- ACL 认证（仅新连接）
                -- 判断是否是新连接，避免重复认证浪费性能
                if red:get_reused_times() == 0 then
                    local ok, err = red:auth(redis_user, redis_pass)
                    if not ok then
                        ngx.log(ngx.ERR, "redis auth failed: ", err)
                        -- 认证失败返回 500 错误码
                        return ngx.exit(500)
                    end
                end

                -- 客户端 IP，这里 remote_addr 是nginx的内置变量
                local client_ip = ngx.var.remote_addr or "unknown"

                -- 当前分钟窗口
                local now = ngx.time() -- 获取当前时间戳（秒）
                local minute = math.floor(now / 60) -- 转换为分钟窗口编号

                -- Redis Key: 每个 IP 每分钟一个计数器
                local key = "rate:" .. client_ip .. ":" .. minute

                -- 从共享字典读取 Lua 脚本
                local dict = ngx.shared.redis_scripts
                local script = dict:get("rate_limit_lua")

                -- 执行 Redis Lua（原子）
                local ttl = 70
                local cnt, err = red:eval(script, 1, key, ttl)
                if not cnt then
                    ngx.log(ngx.ERR, "redis eval failed: ", err)
                    return ngx.exit(500)
                end

                -- 限流判断
                local limit = 10
                if cnt > limit then
                    ngx.status = 429
                    ngx.say("Too Many Requests, limit=", limit)
                    return ngx.exit(429)  -- 返回 HTTP 429（Too Many Requests）。
                end

                -- 放回连接池
                close_redis(red)

                -- 正常返回
                ngx.say("OK, request count=", cnt)
            }
        }
    }
}

openresty -p `pwd` -c ./redis-nginx.conf

for i in {1..15}; do
  curl http://localhost:8080/api
done
# 结果
OK, request count=1
OK, request count=2
OK, request count=3
OK, request count=4
OK, request count=5
OK, request count=6
OK, request count=7
OK, request count=8
OK, request count=9
OK, request count=10
Too Many Requests, limit=10
Too Many Requests, limit=10
Too Many Requests, limit=10
Too Many Requests, limit=10
Too Many Requests, limit=10

# 指定 Nginx Worker 进程数量，生产环境：等于 CPU 核心数，建议配置为 auto，自动适配
worker_processes auto;
# 指定错误日志路径，所有错误都会写入该日志文件，包括 Lua ngx.log(ngx.ERR, ...)
error_log logs/error.log;
# 定义事件模型参数
events {
    # 单个 Worker 最大并发连接数
    worker_connections  1024;
}

http {
    # Lua 模块加载路径
    # 语法规则
    #  ?.lua 表示模块文件名占位符。
    #  ;; 表示 保留默认路径，否则会覆盖系统默认路径。
    lua_package_path "/usr/local/openresty/lualib/?.lua;;";

    # ----------------------------
    # Redis 原子限流 Lua 脚本
    # ----------------------------

    # 创建一块 共享内存区，名称：redis_scripts，大小：1MB（Worker 之间共享内存）
    # 常用于：缓存 Lua 脚本、Token、计数器、配置信息
    lua_shared_dict redis_scripts 1m;

    # Worker 初始化阶段加载 Lua，在 每个 Worker 启动时执行一次
    # 适合：加载配置、初始化缓存、预加载脚本、启动定时器
    init_worker_by_lua_block {
        -- 将 Lua 脚本加载到 Nginx Worker 内存
        local script = [[
            -- 对指定 Key 进行自增
            local cnt = redis.call("INCR", KEYS[1])
            -- 如果是第一次创建 Key
            if cnt == 1 then
                -- 设置 Key 过期时间(秒)
                redis.call("EXPIRE", KEYS[1], ARGV[1])
            end
            -- 返回当前计数
            return cnt
        ]]
        -- 将 Lua 脚本存入共享内存，避免每次请求拼接 Lua 脚本字符串，提升性能
        local dict = ngx.shared.redis_scripts
        -- Key：rate_limit_lua，Value：Lua 脚本
        dict:set("rate_limit_lua", script)
    }

    server {
        listen 8080;

        location /api {
            # 关键修改点：改为加载 Lua 文件
            content_by_lua_file /Users/hanqf/Desktop/openresty/lua/rate_limit.lua;
        }
    }
}

# 指定 Nginx Worker 进程数量，生产环境：等于 CPU 核心数，建议配置为 auto，自动适配
worker_processes auto;
# 指定错误日志路径，所有错误都会写入该日志文件，包括 Lua ngx.log(ngx.ERR, ...)
error_log logs/error.log;
# 定义事件模型参数
events {
    # 单个 Worker 最大并发连接数
    worker_connections  1024;
}

http {
    # Lua 模块加载路径
    # 语法规则
    #  ?.lua 表示模块文件名占位符。
    #  ;; 表示 保留默认路径，否则会覆盖系统默认路径。
    lua_package_path "/usr/local/openresty/lualib/?.lua;;";

    # ----------------------------
    # Redis 原子限流 Lua 脚本
    # ----------------------------

    # 创建一块 共享内存区，名称：redis_scripts，大小：1MB（Worker 之间共享内存）
    # 常用于：缓存 Lua 脚本、Token、计数器、配置信息
    lua_shared_dict redis_scripts 1m;

    # Worker 初始化阶段加载 Lua，在 每个 Worker 启动时执行一次
    # 适合：加载配置、初始化缓存、预加载脚本、启动定时器
    init_worker_by_lua_block {
        -- 将 Lua 脚本加载到 Nginx Worker 内存
        local script = [[
            -- 对指定 Key 进行自增
            local cnt = redis.call("INCR", KEYS[1])
            -- 如果是第一次创建 Key
            if cnt == 1 then
                -- 设置 Key 过期时间(秒)
                redis.call("EXPIRE", KEYS[1], ARGV[1])
            end
            -- 返回当前计数
            return cnt
        ]]
        -- 将 Lua 脚本存入共享内存，避免每次请求拼接 Lua 脚本字符串，提升性能
        local dict = ngx.shared.redis_scripts
        -- Key：rate_limit_lua，Value：Lua 脚本
        dict:set("rate_limit_lua", script)
    }

    # 后端服务
    upstream backend {
        server 127.0.0.1:9000;
    }

    server {
        listen 8080;

        location /api {
             # 限流在 access 阶段执行
            access_by_lua_file /Users/hanqf/Desktop/openresty/lua/rate_limit.lua;

            # 通过后转发给后端服务
            proxy_pass http://backend;

            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }
    }
}

限制：最近 60 秒内 ≤ 10 次请求

# KEY:rate:IP，SCORE:时间戳，MEMBER:任意唯一值，可以依旧使用时间戳，或者 时间戳_随机数，防止重复
ZADD rate:192.168.1.10 1620000000 1620000000