NGINX njs从基础配置到高级特性实战

http {
    # 1. 导入 njs 脚本文件（核心指令：js_import）
    js_import http.js;

    # 2. 自定义 nginx 变量（js_set 绑定 njs 函数）
    js_set $foo     http.foo;
    js_set $summary http.summary;

    server {
        listen 8000;
        charset utf-8;

        # 3. 自定义 content 处理器（js_content 绑定 njs 函数）
        location / {
            add_header x-foo $foo; # 使用自定义变量
            js_content http.baz;    # 接管响应内容
        }

        # 直接返回自定义变量值
        location = /summary {
            return 200 $summary;
        }

        # 简单的文本响应
        location = /hello {
            js_content http.hello;
        }
    }
}

// 1. 自定义变量处理器：返回固定值
function foo(r) {
    r.log("执行 foo 变量处理器"); // 写入 nginx 日志
    return "foo-value";
}

// 2. 自定义变量处理器：生成请求摘要信息
function summary(r) {
    let s = "请求摘要信息\n\n";
    // 读取请求对象（r）的核心属性
    s += "请求方法：" + r.method + "\n";
    s += "http 版本：" + r.httpversion + "\n";
    s += "请求主机：" + r.headersin.host + "\n";
    s += "客户端ip：" + r.remoteaddress + "\n";
    s += "请求uri：" + r.uri + "\n";
    
    // 遍历请求头
    s += "请求头：\n";
    for (let h in r.headersin) {
        s += `  ${h}: ${r.headersin[h]}\n`;
    }
    
    // 遍历查询参数（r.args 自动解析 url 查询字符串）
    s += "查询参数：\n";
    for (let a in r.args) {
        s += `  ${a}: ${r.args[a]}\n`;
    }
    return s;
}

// 3. 自定义 content 处理器：分步构建响应
function baz(r) {
    r.status = 200; // 设置响应状态码
    // 设置响应头
    r.headersout['content-type'] = "text/plain; charset=utf-8";
    r.headersout['content-length'] = 15;
    // 发送响应头
    r.sendheader();
    // 分段发送响应体
    r.send("nginx");
    r.send("java");
    r.send("script");
    // 结束响应
    r.finish();
}

// 4. 简化的响应方式：直接返回状态码+内容
function hello(r) {
    r.return(200, "hello njs!");
}

// 导出函数（供 nginx 配置调用）
export default { foo, summary, baz, hello };

# nginx 配置
location /filter {
    proxy_pass http://localhost:8080;
    # 清除 content-length（避免长度不匹配）
    js_header_filter http.clearcontentlength;
    # 响应体过滤器：转小写
    js_body_filter http.lowercasefilter;
}

// http.js 新增函数
function clearcontentlength(r) {
    delete r.headersout['content-length'];
}

function lowercasefilter(r, data, flags) {
    // 逐块处理响应体，转小写后传递给下一个过滤器
    r.sendbuffer(data.tolowercase(), flags);
}

# nginx 配置
location = /fetch {
    js_content http.fetch;
    js_fetch_trusted_certificate /path/to/isrg_root_x1.pem;
    js_fetch_keepalive 32; # 连接池最大空闲连接数
}

// http.js 新增异步函数
async function fetch(r) {
    try {
        // 并行调用两个接口
        let results = await promise.all([
            ngx.fetch('https://nginx.org/'),
            ngx.fetch('https://nginx.org/en/')
        ]);
        // 解析响应并返回
        let response = [];
        for (let res of results) {
            response.push({
                status: res.status,
                body: await res.text()
            });
        }
        r.return(200, json.stringify(response, null, 2), {
            'content-type': 'application/json; charset=utf-8'
        });
    } catch (e) {
        r.return(500, `请求失败：${e.message}`);
    }
}

# nginx 配置：创建 1mb 共享字典，60s 超时，支持淘汰旧数据
js_shared_dict_zone zone=mydict:1m timeout=60s evict;

// http.js 操作共享字典
function setdict(r) {
    // 设置键值对
    let result = ngx.shared.mydict.set(r.args.key, r.args.value);
    r.return(200, `设置结果：${result}`);
}

function getdict(r) {
    // 获取键值对
    let value = ngx.shared.mydict.get(r.args.key);
    r.return(200, `获取结果：${value || '不存在'}`);
}

# nginx 配置：每分钟在所有 worker 进程执行定时任务
location @periodic {
    js_periodic http.periodictask interval=60s worker_affinity=all;
    js_fetch_trusted_certificate /path/to/isrg_root_x1.pem;
}

// http.js 定时任务函数
async function periodictask(s) {
    try {
        // 定时拉取页面并写入日志
        let res = await ngx.fetch('https://nginx.org/en/docs/njs/');
        let body = await res.text();
        ngx.log(ngx.info, `定时任务执行：页面长度 ${body.length}`);
    } catch (e) {
        ngx.log(ngx.err, `定时任务失败：${e.message}`);
    }
}