开发者社区> Se7en> 正文

Nginx 第三方模块使用与开发

简介: Nginx 第三方模块使用与开发
+关注继续查看

Nginx 允许引入第三方模块来扩展 Nginx 的功能。官方网站 NGINX 3rd Party Modules 列出了 Nginx 很多的第三方模块。除此之外,很多很有用的模块也能在 github 等网站上找到。

添加模块

接下来通过添加 njs 模块为例来介绍如何添加第三方模块。njs 是 Nginx + JavaScript 的缩写,简单来说,就是 Nginx 里面可以运行 JavaScript,用 JavaScript 来构建动态的 Web 应用。Nginx NJS 包含两个 Nginx 扩展模块:ngx_http_js_module 和 ngx_stream_js_module。

首先克隆 njs 模块的代码:

git clone https://github.com/nginx/njs.git

查看当前已安装的 Nginx 的编译信息:

[root@nginx-plus1 nginx-1.14.2]# /usr/local/nginx/sbin/nginx -V
nginx version: nginx/1.14.2
built by gcc 4.8.5 20150623 (Red Hat 4.8.5-36) (GCC) 
built with OpenSSL 1.0.2k-fips  26 Jan 2017
TLS SNI support enabled
configure arguments: --with-debug --with-stream --prefix=/usr/local/nginx --with-http_ssl_module

进入 Nginx 源代码目录,执行 ./configure,在最后通过 --add-module 指令加上 njs 模块。执行完成后会在当前目录生成编译所需的相关文件(例如 Makefile 和 objs 目录等)。

cd /root/nginx-1.14.2
# 复制前面nginx -V看到的参数,在最后--add-module加上njs模块的路径
./configure --with-debug --with-stream --prefix=/usr/local/nginx --with-http_ssl_module --add-module=/root/njs/nginx

执行完上面命令后,objs 目录下的 ngx_modules.c 文件中的 ngx_modules 数组中可以看到新增的 njs 模块:

cat /root/nginx-1.14.2/objs/ngx_modules.c

image.png

make

编译完成后注意不需要执行 make install 命令,只需要将生成的 Nginx 二进制文件覆盖原先的二进制文件即可。

cp /root/nginx-1.14.2/objs/nginx /usr/local/nginx/sbin/nginx -f

现在展示如何使用 njs 模块的功能。在 nginx 的 conf 目录下新建 js 目录,用于存放 javascript 代码。在 js 目录下创建 http.js 文件,内容如下:

function summary(r) {
    var a, s, h;
    s = "JS summary\n\n";
    //打印请求方法,HTTP版本,Host,客户端地址,URI
    s += "Method: " + r.method + "\n";
    s += "HTTP version: " + r.httpVersion + "\n";
    s += "Host: " + r.headersIn.host + "\n";
    s += "Remote Address: " + r.remoteAddress + "\n";
    s += "URI: " + r.uri + "\n";
    
    //打印请求头
    s += "Headers:\n";
    for (h in r.headersIn) {
        s += "  header '" + h + "' is '" + r.headersIn[h] + "'\n";
    }
    //打印参数内容
    s += "Args:\n";
    for (a in r.args) {
        s += "  arg '" + a + "' is '" + r.args[a] + "'\n";
    }
    return s;
}
function baz(r) {
    //设置响应状态码
    r.status = 200;
    //设置响应头
    r.headersOut.foo = 1234;
    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();
}
//export default用于导出常量、函数、文件、模块等
export default {foo, summary, baz, hello};

编写 Nginx 配置文件 /usr/local/nginx/conf/nginx.conf:

events {}
http {
    #导入js文件
    js_import js/http.js;
    #设置变量,变量值为调用js文件的相应函数的返回值
    js_set $foo     http.foo;
    js_set $summary http.summary;
    server {
        listen 8000;
        location / {
            add_header X-Foo $foo; #将变量foo的结果添加到响应头中 
            js_content http.baz; #执行其中 JS 内容并输出
        }
        location = /summary {
            return 200 $summary;  #返回变量summary的结果
        }
    }
}

启动 Nginx:

/usr/local/nginx/sbin/nginx

客户端请求 Nginx:

[root@nginx-plus1 ~]# curl localhost:8000 -i
HTTP/1.1 200 OK
Server: nginx/1.14.2
Date: Tue, 15 Jun 2021 14:04:39 GMT
Content-Type: text/plain; charset=utf-8
Connection: keep-alive
foo: 1234
Content-Length: 15
X-Foo: foo
nginxjavascript  
[root@nginx-plus1 ~]# curl localhost:8000/summary?name=chengzw
JS summary
Method: GET
HTTP version: 1.1
Host: localhost:8000
Remote Address: 127.0.0.1
URI: /summary
Headers:
  header 'User-Agent' is 'curl/7.29.0'
  header 'Host' is 'localhost:8000'
  header 'Accept' is '*/*'
Args:
  arg 'name' is 'chengzw'

动态模块

Nginx 在 Nginx 1.9.11(release at 2016-02-09) 版本中新增了动态模块(Dynamic Module) 的支持。动态模块在第一次通过 ./configure --add-dynamic-module 编译后,之后如果要对动态模块进行升级,只需要重新编译动态模块,然后替换在 modules 目录内该动态模块的 .so 文件即可,无需替换 Nginx 二进制文件。

下面还是以 njs 模块的例子来演示如何添加动态模块。使用 --add-dynamic-module 指令以动态模块的方式添加 njs 模块:

./configure --with-debug --with-stream --prefix=/usr/local/nginx --with-http_ssl_module --add-dynamic-module=/root/njs/nginx
# 编译
make

编译完成后注意不需要执行 make install 命令,只需要将生成的 Nginx 二进制文件覆盖原先的二进制文件即可。

cp /root/nginx-1.14.2/objs/nginx /usr/local/nginx/sbin/nginx -f

如果是使用 make install 命令安装,会自动在 Nginx 运行目录下创建 modules 目录,这里我们需要手动创建 modules 目录:

mkdir /usr/local/nginx/modules

查看 modules 目录,可以看到有 http 和 stream 两个 njs 模块对应的文件:

[root@nginx-plus1 nginx]# ll /usr/local/nginx/modules
total 7392
-rwxr-xr-x 1 root root 3825792 Jun 11 08:03 ngx_http_js_module.so
-rwxr-xr-x 1 root root 3738944 Jun 11 08:03 ngx_stream_js_module.so

使用 load_module 指令加载动态模块,注意 load_module 指令必须在所有 block (包括 events、http、stream、mail)之前使用:

# 加载动态模块
load_module modules/ngx_http_js_module.so;
load_module modules/ngx_stream_js_module.so;
events {}
http {
    #导入js文件
    js_import js/http.js;
    #设置变量,变量值为调用js文件的相应函数的返回值
    js_set $foo     http.foo;
    js_set $summary http.summary;
    server {
        listen 8000;
        location / {
            add_header X-Foo $foo; #将变量foo的结果添加到响应头中 
            js_content http.baz; #执行其中 JS 内容并输出
        }
        location = /summary {
            return 200 $summary;  #返回变量summary的结果
        }
    }
}

自定义 HTTP 模块

我们定义一个简单的 HTTP 模块,当客户端发送请求时,返回 Hello World!

模块开发有以下步骤:

  • 1.编写模块基本结构。包括模块配置项,模块上下文,模块配置信息。
  • 2.实现 handler 的挂载函数。根据模块的需求选择正确的挂载方式。
  • 3.编写 handler 处理函数。模块的功能主要通过这个函数来完成。
  • 4.编写编译的文件 config。

定义模块配置项

模块配置项 ngx_command_s 结构体定义在 src/core/ngx_conf_file.h 文件中,其结构如下所示:

struct ngx_command_s {
    // 配置项的名称,例如gzip
    ngx_str_t             name;
    
    // 配置项类型,type将指定配置项可以出现的位置。例如出现在location{}或者server{}中,
    // 以及它可以携带的参数个数
    ngx_uint_t            type;
    
    // 出现了name中定义的配置项后,将会调用该方法处理配置项的参数
    char               *(*set)(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
    
    //该字段被NGX_HTTP_MODULE类型模块所用 (我们编写的基本上都是NGX_HTTP_MOUDLE,只有一些nginx核心模块是非NGX_HTTP_MODULE),
    // 该字段指定当前配置项存储的内存位置。实际上是使用哪个内存池的问题。因为http模块对所有http模块所要保存的配置信息,
    // 划分了main, server和location三个地方进行存储,每个地方都有一个内存池用来分配存储这些信息的内存。
    // 这里可能的值为 NGX_HTTP_MAIN_CONF_OFFSET、NGX_HTTP_SRV_CONF_OFFSET或NGX_HTTP_LOC_CONF_OFFSET。当然也可以直接置为0,就是NGX_HTTP_MAIN_CONF_OFFSET。
    ngx_uint_t            conf;
    
    //指定该配置项值的精确存放位置,一般指定为某一个结构体变量的字段偏移。因为对于配置信息的存储,一般我们都是定义个结构体来存储的。
    // 那么比如我们定义了一个结构体A,该项配置的值需要存储到该结构体的b字段。那么在这里就可以填写为offsetof(A, b)。
    // 对于有些配置项,它的值不需要保存或者是需要保存到更为复杂的结构中时,这里可以设置为0。
    ngx_uint_t            offset;
    
    // 该字段存储一个指针。可以指向任何一个在读取配置过程中需要的数据,以便于进行配置读取的处理。
    // 大多数时候,都不需要,所以简单地设为NULL即可。
    void                 *post;
};

我们定义了一个配置项,该配置项可以出现在 location 配置块中,该配置项没有参数。当在某个配置块中出现 mytest 配置时,Nginx 将会调用 ngx_http_mytest 方法。

/*
定义模块配置项
*/
static ngx_command_t  ngx_http_mytest_commands[] =
{
    {
        ngx_string("mytest"),
        NGX_HTTP_LOC_CONF | NGX_CONF_NOARGS,
        // 当在某个配置块中出现 mytest 配置时,Nginx 将会调用 ngx_http_mytest 方法。
        ngx_http_mytest,
        NGX_HTTP_LOC_CONF_OFFSET,
        0,
        NULL
    },
    ngx_null_command //在ngx_http_hello_commands这个数组定义的最后,都要加一个ngx_null_command作为结尾。
};

定义模块上下文

模块上下文 ngx_http_module_t 结构体定义在 src/http/ngx_http_config.h 文件中。这是一个 ngx_http_module_t 类型的静态变量,这个变量实际上是提供一组回调函数指针,这些函数将被 Nginx 在合适的时间进行调用。其结构如下所示:

typedef struct {
    // 解析配置文件前调用
    ngx_int_t   (*preconfiguration)(ngx_conf_t *cf);
    
    // 完成配置文件的解析后调用
    ngx_int_t   (*postconfiguration)(ngx_conf_t *cf);
    // 当需要创建数据结构用于存储main级别(直属于http{...}块的配置项)的全局配置项时,
    // 可以通过create_main_conf回调方法创建存储全局配置项的结构体
    void       *(*create_main_conf)(ngx_conf_t *cf);
    
    // 常用于初始化main级别配置项
    char       *(*init_main_conf)(ngx_conf_t *cf, void *conf);
    
    // 当需要创建数据结构用于存储srv级别(直属于server{...}块的配置项)的配置项时,
    // 可以通过create_srv_conf回调方法创建存储srv级别配置项的结构体
    void       *(*create_srv_conf)(ngx_conf_t *cf);
    
    // 主要用于合并main级别和srv级别下同名的配置项
    char       *(*merge_srv_conf)(ngx_conf_t *cf, void *prev, void *conf);
     
    // 当需要创建数据结构用于存储loc级别(直属于location{...}块的配置项)的配置项时,
    // 可以通过create_loc_conf回调方法创建存储loc级别配置项的结构体
    void       *(*create_loc_conf)(ngx_conf_t *cf);
    
    // 主要用于合并srv级别和loc级别下同名的配置项
    char       *(*merge_loc_conf)(ngx_conf_t *cf, void *prev, void *conf);
} ngx_http_module_t;

HTTP 框架在读取,重载配置文件时定义了由 ngx_http_module_t 接口描述的 8 个阶段,HTTP 框架在启动过程中会在每个阶段中调用 ngx_http_module_t 中相应的方法。当然,如果 ngx_http_module_t 中的某个回调方法设置为 NULL 空指针时,那么 HTTP 框架是不会调用它的。

本例中我们没有实现 HTTP 框架初始化时会调用的 ngx_http_module_t 中的 8 个方法。

/*
定义模块上下文
*/
static ngx_http_module_t  ngx_http_mytest_module_ctx =
{
    NULL,                              /* preconfiguration */
    NULL,                    /* postconfiguration */
    NULL,                              /* create main configuration */
    NULL,                              /* init main configuration */
    NULL,                              /* create server configuration */
    NULL,                              /* merge server configuration */
    NULL,          /* create location configuration */
    NULL            /* merge location configuration */
};

定义模块

对于开发一个模块来说,我们都需要定义一个 ngx_module_t 类型的变量来说明这个模块本身的信息,从某种意义上来说,这是这个模块最重要的一个信息,它告诉了 Nginx 这个模块的一些信息,上面定义的配置信息,还有模块上下文信息,都是通过这个结构来告诉 Nginx 系统的,也就是加载模块的上层代码,都需要通过定义的这个结构,来获取这些信息。

#define NGX_MODULE_V1          0, 0, 0, 0, 0, 0, 1
#define NGX_MODULE_V1_PADDING  0, 0, 0, 0, 0, 0, 0, 0
// src/core/ngx_core.h
typedef struct ngx_module_s      ngx_module_t;
// src/core/ngx_conf_file.h
struct ngx_module_s {
    // 下面的 ctx_index,index,spare0,spare1,spare2,spare3,version 变量不需要在定义时赋值,
    // 可以用 Nginx 准备好的宏 NGX_MODULE_V1 来定义,它已经定义好了这7个值
    ngx_uint_t            ctx_index;
    ngx_uint_t            index;
    ngx_uint_t            spare0;
    ngx_uint_t            spare1;
    ngx_uint_t            spare2;
    ngx_uint_t            spare3;
    ngx_uint_t            version;
    
    // 指向模块的上下文结构体
    void                 *ctx;
    
    // 模块配置项
    ngx_command_t        *commands;
    
    // 模块的类型,它与ctx指针是紧密相关的。在官方Nginx中,它的取值范围是以下5种:
    // NGINX_HTTP_MODULE,NGINX_CORE_MODULE,NGINX_CONF_MODULE,NGX_EVENT_MODULE,NGX_MAIL_MODULE
    ngx_uint_t            type;
    // 在Nginx启动、停止的过程中,以下7个函数指针表示有7个执行点会分别调用这7种方法。
    // 如果不需要在Nginx启动或者停止的过程中执行它,就简单设置为NULL即可。
    ngx_int_t           (*init_master)(ngx_log_t *log);
    ngx_int_t           (*init_module)(ngx_cycle_t *cycle);
    ngx_int_t           (*init_process)(ngx_cycle_t *cycle);
    ngx_int_t           (*init_thread)(ngx_cycle_t *cycle);
    void                (*exit_thread)(ngx_cycle_t *cycle);
    void                (*exit_process)(ngx_cycle_t *cycle);
    void                (*exit_master)(ngx_cycle_t *cycle);
    // 以下8个字段为保留字段,目前没有使用,可以使用Nginx提供的NGX_MODULE_V1_PADDING 宏来填充。
    uintptr_t             spare_hook0;
    uintptr_t             spare_hook1;
    uintptr_t             spare_hook2;
    uintptr_t             spare_hook3;
    uintptr_t             spare_hook4;
    uintptr_t             spare_hook5;
    uintptr_t             spare_hook6;
    uintptr_t             spare_hook7;
};

定义 mytest 模块,这样 mytest 模块在编译时将会被加入到 ngx_modules 全局数组中。Nginx 在启动时,会调用所有模块的初始化回调方法,这个例子中我们没有实现它们。

/*
定义模块
*/
ngx_module_t  ngx_http_mytest_module =
{
    NGX_MODULE_V1,
    // 模块上下文
    &ngx_http_mytest_module_ctx,           /* module context */
    // 模块配置项
    ngx_http_mytest_commands,              /* module directives */
    // 模块类型
    NGX_HTTP_MODULE,                       /* module type */
    NULL,                                  /* init master */
    NULL,                                  /* init module */
    NULL,                                  /* init process */
    NULL,                                  /* init thread */
    NULL,                                  /* exit thread */
    NULL,                                  /* exit process */
    NULL,                                  /* exit master */
    NGX_MODULE_V1_PADDING
};

模块可以提供一些回调函数给 Nginx,当 Nginx 在创建进程线程或者结束进程线程时进行调用。但大多数模块在这些时刻并不需要做什么,所以都简单赋值为 NULL。

定义 handler 挂载函数

在 Nginx 的 ngx_http_phases 中定义了 HTTP 框架对请求进行处理的 11 个阶段,结构体定义在 src/http/ngx_http_core_module.h :

typedef enum {
    // 1.在接收到完整的HTTP头部后读取请求内容的阶段
    NGX_HTTP_POST_READ_PHASE = 0,
    // 2.在将请求的URI与location表达式匹配之前,修改请求的URI的阶段(所谓的重定向)
    NGX_HTTP_SERVER_REWRITE_PHASE,
    // 3.根据请求的URI寻找匹配的location表达式,
    // 这个阶段只能由ngx_http_core_module模块实现,不建议其他HTTP模块重新定义这一阶段的行为
    NGX_HTTP_FIND_CONFIG_PHASE,
    
    // 4.寻找到匹配的location之后再次利用rewrite修改请求的URI
    NGX_HTTP_REWRITE_PHASE,
    
    // 5.这一阶段是用于在rewrite重写URI后,防止错误的nginx.conf配置导致死循环(递归地修改URI)
    // 因此,这一阶段仅由ngx_http_core_module模块处理。目前,控制死循环的方式很简单,首先检查rewrite的次数,
    // 如果一个请求超过10次重定向,就认为进入了死循环,这时候就会向用户返回500,表示服务器内部错误
    NGX_HTTP_POST_REWRITE_PHASE,
    // 6.决定请求访问权限之前,HTTP模块可以介入处理的阶段
    NGX_HTTP_PREACCESS_PHASE,
    // 7.这个阶段用于让HTTP模块判断是否允许这个请求访问Nginx服务器
    NGX_HTTP_ACCESS_PHASE,
    
    // 8.在NGX_HTTP_ACCESS_PHASE阶段中,当HTTP模块的handler处理函数返回不允许访问的错误代码时(实际就是NGX_HTTP_FORBIDDEN或者NGX_HTTP_UNAUTHORIZED),
    // 这里将负责向用户发送拒绝服务的错误响应,因此,这个阶段实际上是用于给NGX_HTTP_ACCESS_PHASE阶段收尾的
    NGX_HTTP_POST_ACCESS_PHASE,
    // 9.这个阶段完全是为了给try_files配置项而设立的,当Nginx请求静态文件资源时,
    // try_files配置项可以使这个请求顺序地访问多个静态文件资源,如果某一次访问失败,则继续访问try_files中指定的下一个静态资源。
    NGX_HTTP_TRY_FILES_PHASE,
    
    // 10.处理HTTP请求内容的阶段,这是大部分HTTP模块最愿意介入的阶段
    NGX_HTTP_CONTENT_PHASE,
    
    // 11.处理完请求后记录日志的阶段
    NGX_HTTP_LOG_PHASE
} ngx_http_phases;

一般情况下,我们自定义的模块,大多数是挂载在 NGX_HTTP_CONTENT_PHASE 阶段的,默认也就是属于这个模块。

有几个阶段是特例,它们没有 Hook 挂载点(也就意味着,在这几个阶段不允许挂载任何第三方处理逻辑),它们仅由 HTTP 框架实现:

  • NGX_HTTP_FIND_CONFIG_PHASE
  • NGX_HTTP_POST_ACCESS_PHASE
  • NGX_HTTP_POST_REWRITE_PHASE
  • NGX_HTTP_TRY_FILES_PHASE

函数的挂载分为两种方式:一种方式就是按处理阶段挂载,以这种方式挂载的 handler 被称为 content phase handlers;另外一种挂载方式就是按需挂载,以这种方式挂载的 handler 被称为 content handler。

按处理阶段挂载

按处理阶段挂载的动作一般是在模块上下文调用的 postconfiguration 函数中。本例介绍按需挂载,这里不展开说明。

按需挂载

当一个请求进来以后,Nginx 从 NGX_HTTP_POST_READ_PHASE 阶段开始依次执行每个阶段中所有 handler。执行到 NGX_HTTP_CONTENT_PHASE 阶段的时候,如果这个 location 有一个对应的 content handler 模块,那么就去执行这个 content handler 模块真正的处理函数。否则继续依次执行 NGX_HTTP_CONTENT_PHASE 阶段中所有 content phase handlers,直到某个函数处理返回 NGX_OK 或者 NGX_ERROR。

换句话说,当某个 location 处理到 NGX_HTTP_CONTENT_PHASE 阶段时,如果有 content handler 模块,那么 NGX_HTTP_CONTENT_PHASE 挂载的所有 content phase handlers 都不会被执行了。

但是使用这个方法挂载上去的 handler 有一个特点是必须在 NGX_HTTP_CONTENT_PHASE 阶段才能执行到。如果你想自己的 handler 在更早的阶段执行,那就不要使用这种挂载方式。

那么在什么情况会使用这种方式来挂载呢?一般情况下,某个模块对某个 location 进行了处理以后,发现符合自己处理的逻辑,而且也没有必要再调用 NGX_HTTP_CONTENT_PHASE 阶段的其它 handler 进行处理的时候,就动态挂载上这个 handler。

本例我们使用按需挂载的方式。当 Nginx 接收完 HTTP 请求的头部信息时,就会调用 HTTP 框架处理请求。在 ngx_http_mytest 方法中,我们定义了请求的处理方法为 ngx_http_mytest_handler,

/*
按需挂载,ngx_http_mytest_handler方法是真正处理请求的方法
*/
static char * ngx_http_mytest(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
    ngx_http_core_loc_conf_t  *clcf;
    //首先找到mytest配置项所属的配置块,clcf貌似是location块内的数据
//结构,其实不然,它可以是main、srv或者loc级别配置项,也就是说在每个
//http{}和server{}内也都有一个ngx_http_core_loc_conf_t结构体
    clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
    //http框架在处理用户请求进行到NGX_HTTP_CONTENT_PHASE阶段时,如果
//请求的主机域名、URI与mytest配置项所在的配置块相匹配,就将调用我们
//实现的ngx_http_mytest_handler方法处理这个请求
    clcf->handler = ngx_http_mytest_handler;
    return NGX_CONF_OK;
}

定义 handler 处理函数

当出现 mytest 配置项时,ngx_http_mytest 方法会被调用,这时将 ngx_http_core_loc_conf_t 结构的 handler 成员指定为 ngx_http_mytest_handler,另外,HTTP 框架在接收完 HTTP 请求的头部后,会调用 handler 挂载函数指向的 handler 处理函数。下面看一下 handler 成员的原型 ngx_http_handler_pr:

// src/http/ngx_http_request.h
typedef ngx_int_t (*ngx_http_handler_pt)(ngx_http_request_t *r);

从上面这段代码可以看出,实际处理请求的方法 ngx_http_mytest_handler 在接收一个 ngx_http_request_t 类型的参数 r,返回一个 ngx_int_t 类型的结果。

/*
定义handler处理函数,是真正处理请求的方法
*/
static ngx_int_t ngx_http_mytest_handler(ngx_http_request_t *r)
{
    //必须是GET或者HEAD方法,否则返回405 Not Allowed
    if (!(r->method & (NGX_HTTP_GET | NGX_HTTP_HEAD)))
    {
        return NGX_HTTP_NOT_ALLOWED;
    }
    //丢弃请求中的包体
    ngx_int_t rc = ngx_http_discard_request_body(r);
    if (rc != NGX_OK)
    {
        return rc;
    }
    //设置返回的Content-Type。注意,ngx_str_t有一个很方便的初始化宏
//ngx_string,它可以把ngx_str_t的data和len成员都设置好
    ngx_str_t type = ngx_string("text/plain");
    //返回的包体内容
    ngx_str_t response = ngx_string("Hello World!");
    //设置返回状态码
    r->headers_out.status = NGX_HTTP_OK;
    //响应包是有包体内容的,所以需要设置Content-Length长度
    r->headers_out.content_length_n = response.len;
    //设置Content-Type
    r->headers_out.content_type = type;
    //发送http头部
    rc = ngx_http_send_header(r);
    if (rc == NGX_ERROR || rc > NGX_OK || r->header_only)
    {
        return rc;
    }
    //构造ngx_buf_t结构准备发送包体
    ngx_buf_t                 *b;
    b = ngx_create_temp_buf(r->pool, response.len);
    if (b == NULL)
    {
        return NGX_HTTP_INTERNAL_SERVER_ERROR;
    }
    //将Hello World拷贝到ngx_buf_t指向的内存中
    ngx_memcpy(b->pos, response.data, response.len);
    //注意,一定要设置好last指针
    b->last = b->pos + response.len;
    //声明这是最后一块缓冲区
    b->last_buf = 1;
    //构造发送时的ngx_chain_t结构体
    ngx_chain_t  out;
    //赋值ngx_buf_t
    out.buf = b;
    //设置next为NULL
    out.next = NULL;
    //最后一步发送包体,http框架会调用ngx_http_finalize_request方法
//结束请求
    return ngx_http_output_filter(r, &out);
}

定义 config 文件

config 文件其实就是一个可执行的 Shell 脚本。如果只想开发一个 HTTP 模块,那么 config 文件中需要定义以下 3 个变量:

  • ngx_addon_name:仅在configure 执行时使用,一般设置为模块名称。
  • HTTP_MODULES:保存所有的 HTTP 模块名称,每个 HTTP 模块间由空格符相连。在重新设置 HTTP_MODULES 变量时,不要直接覆盖它,因为 configure 调用到自定义的 config 脚本前,已经将各个 HTTP 模块设置到 HTTP_MODULES 变量中了。
  • NGX_ADDON_SRCS:用于指定新增模块的源代码,多个待编译的源代码间以空格符相连。注意:在设置 NGX_ADDON_SRCS 时可以使用 $ngx_addon_dir 变量,它等价于 configure 时执行 --add-module=PATH 的 PATH 参数。
ngx_addon_name=ngx_http_mytest_module
HTTP_MODULES="$HTTP_MODULES ngx_http_mytest_module"
NGX_ADDON_SRCS="$NGX_ADDON_SRCS $ngx_addon_dir/ngx_http_mytest_module.c"

编译和使用模块

将模块源代码文件 ngx_http_mytest_module.c 和 config 文件放在以下目录中:

[root@nginx-plus1 ~]# ll /root/mymodules/mytest/
total 12
-rw-r--r-- 1 root root  164 Jun 16 10:20 config
-rw-r--r-- 1 root root 4567 Jun 16 10:45 ngx_http_mytest_module.c

编译时使用 --add-module 指令添加我们自定义的模块,这里使用 make install 重新安装 Nginx:

cd /root/nginx-1.14.2/
./configure --prefix=/usr/local/nginx --add-module=/root/mymodules/mytest
# 删除原先的Nginx文件
rm -rm /usr/local/nginx
# 编译
make
# 安装
make install

编辑 Nginx 配置文件 /usr/local/nginx/conf/nginx.conf:

worker_processes  1;
events {
    worker_connections  1024;
}
http {
    server {
        listen       80;
        location / {
            mytest;  #使用我们自定义的配置项
        }
    }
}

启动 Nginx:

/usr/local/nginx/sbin/nginx

客户端请求,可以看到响应了我们自定义的内容:

[root@nginx-plus1 ~]# curl localhost
Hello World!

参考链接


版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
Nginx 第三方模块使用与开发
Nginx 第三方模块使用与开发
74 0
使用python builtwith模块分析识别网站开发技术(python2.7)
本文目录 1. 网站开发技术概述 2. 安装builtwith模块 3. 分析网站开发技术 4. 其他
23 0
阿里云服务器端口号设置
阿里云服务器初级使用者可能面临的问题之一. 使用tomcat或者其他服务器软件设置端口号后,比如 一些不是默认的, mysql的 3306, mssql的1433,有时候打不开网页, 原因是没有在ecs安全组去设置这个端口号. 解决: 点击ecs下网络和安全下的安全组 在弹出的安全组中,如果没有就新建安全组,然后点击配置规则 最后如上图点击添加...或快速创建.   have fun!  将编程看作是一门艺术,而不单单是个技术。
17714 0
阿里云服务器如何登录?阿里云服务器的三种登录方法
购买阿里云ECS云服务器后如何登录?场景不同,阿里云优惠总结大概有三种登录方式: 登录到ECS云服务器控制台 在ECS云服务器控制台用户可以更改密码、更换系.
23696 0
阿里云服务器怎么设置密码?怎么停机?怎么重启服务器?
如果在创建实例时没有设置密码,或者密码丢失,您可以在控制台上重新设置实例的登录密码。本文仅描述如何在 ECS 管理控制台上修改实例登录密码。
18727 0
android开发ndk调用第三方so库
版权声明:您好,转载请留下本人博客的地址,谢谢 https://blog.csdn.net/hongbochen1223/article/details/52957421 1.
1235 0
+关注
76
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
OceanBase 入门到实战教程
立即下载
阿里云图数据库GDB,加速开启“图智”未来.ppt
立即下载
实时数仓Hologres技术实战一本通2.0版(下)
立即下载