Nginx 原生模块开发实践

阅读量

Nginx 作为 多进程网络编程的 巅峰之作（那么请问 多线程巅峰、单进程巅峰是？），也是当前最流行的 HTTP Server，其优秀之处毋容置疑；一直到 2011 年左右，Nginx 还仅仅是 反向代理的 首选，后来随着 HTTP 核心的成熟 慢慢用来 替代 Apache 单独作为 HTTP Server；当然这中间也离不开 第三方扩展模块 的日益丰富；从最初的 nginx_lua_module 支持 lua 嵌入，到后来 春来大神 的 OpenResty，集成 LuaJIT，使得 Nginx 生态再次丰富起来

说到第三方扩展，就不得不说一下 Nginx 的 高扩展特性，它从设计上完全就由多个不同功能、不同层次、不同类型且耦合度极低的模块构成，因此，当对某一个模块修复 Bug 或 进行升级的时候，可以专注于模块本身，无需在意其他。而且在 HTTP 模块中，还设计了 HTTP 过滤器模块，也就是说一个正常的 HTTP 模块在处理完成 request 后，会有一串 HTTP 过滤器模块对请求结果进行再处理，这样，当我们开发一个新的 HTTP 模块时，当然也可以复用诸如 HTTP 核心模块、events 模块、log 模块 等不同层次不同类型的模块，这种低耦合度的优秀设计，也给我们 定制模块开发 提供了很大便利

模块/扩展/插件

广义上 Nginx 模块开发 分为 两种

  • 基于原生 的 C Module 开发（ Redis / Memcached / Mongo / Elasticsearch client 端，HTTP Healthcheck 等）
  • 基于 OpenResty 的 Lua Module 开发

前者偏 基础工具，而 后者因为 Lua 的存在让很多想法成为可能，就更加 偏业务，比如之前的 Kong 网关

我们这次从 原生扩展模块 的角度去实现一个简单的 熔断模块 ngx_http_fuse_module，为了便于展示，所以 示例功能 的逻辑上没有太过复杂，不过完全理解以后，万变不离其宗，始终不会逃脱下面这一套流程。。。

模块工作原理

nginx_module_fuse_1.png

Nginx 本身做的工作实际很少，当它接到一个 HTTP 请求时，它仅仅是通过查找配置文件将此次请求映射到一个 location block，而此 location 中所配置的各个指令则会启动不同的模块去完成工作，因此模块可以看做 Nginx 真正的劳动工作者。通常一个 location 中的指令会涉及一个 handler 模块和多个 filter 模块（当然，多个 location 可以复用同一个模块）

  • handler 模块负责处理请求，完成响应内容的生成
  • 而 filter 模块对响应内容进行处理

因此 Nginx 模块开发分为 handler 开发和 filter 开发（我们不考虑load-balancer负载均衡模块），下图展示了一次常规请求和响应的时序图

nginx_module_fuse_2.jpeg

这里需要注意的是 根据处理模块的逻辑决定是否执行 POST 请求这句，意思为 nginx core 模块 本身不会主动去读取请求体，他认为这是个很糟糕很损耗性能的做法，所以这个一般是交给具体的请求处理模块，比如说 ngx_http_fastcgi_module cgi 模块，它会在 ngx_http_fastcgi_handler 请求处理逻辑中根据请求类型去确定是否需要读取 request body，如果需要就调用 ngx_http_read_client_request_body 接口单独读取 请求体，所以在执行的整个链路中，这块是被单独拿出来的：http://nginx.org/en/docs/dev/development_guide.html

熔断模块

模块定义：ngx_http_fuse_module

熔断功能实现逻辑
  • 熔断能力
    • 检测不健康状态码
    • 根据不健康度进行强行熔断，阻隔请求
  • 自愈能力
    • 定期开启 半开通道，放行部分流量
    • 痊愈打开熔断
    • or 不健康保持熔断

流行熔断器可以根据各个精度进行控制，比如 域名级别、路由级别 等，使用 hashtable 分别记录不同级别对应的 不健康统计数据、熔断状态、通道半开标识、放行流量 等数据，但是我们此次示例以 容易理解为主，只设计 location 级别

根据功能我们对这个模块进行配置项设计

1
2
3
fuse_switch on;
# 10秒内不健康请求达到 5 次，即触发熔断阻隔
fuse_setting 10s 5;

而根据 Nginx 模块精细化的处理阶段，我们来确定我们模块的挂载阶段

1
2
3
4
5
6
7
8
9
10
11
NGX_HTTP_POST_READ_PHASE:           读取请求内容阶段
NGX_HTTP_SERVER_REWRITE_PHASE:      Server请求地址重写阶段
NGX_HTTP_FIND_CONFIG_PHASE:         配置查找阶段:
NGX_HTTP_REWRITE_PHASE:             Location请求地址重写阶段
NGX_HTTP_POST_REWRITE_PHASE:        请求地址重写提交阶段
NGX_HTTP_PREACCESS_PHASE:           访问权限检查准备阶段
NGX_HTTP_ACCESS_PHASE:              访问权限检查阶段
NGX_HTTP_POST_ACCESS_PHASE:         访问权限检查提交阶段
NGX_HTTP_TRY_FILES_PHASE:           配置项try_files处理阶段
NGX_HTTP_CONTENT_PHASE:             内容产生阶段
NGX_HTTP_LOG_PHASE:                 日志模块处理阶段

一般情况下，我们自定义的模块，大多数是挂载在 NGX_HTTP_CONTENT_PHASE 阶段的，默认也就是属于这个模块。挂载的动作一般是在模块上下文调用的 postconfiguration 函数中

注意：有几个阶段是特例，它不调用挂载地任何的handler，也就是你就不用挂载到这几个阶段了：

  • NGX_HTTP_FIND_CONFIG_PHASE
  • NGX_HTTP_POST_ACCESS_PHASE
  • NGX_HTTP_POST_REWRITE_PHASE
  • NGX_HTTP_TRY_FILES_PHASE

所以根据我们的功能设计，需要对 response 进行健康度检测，应该挂载在 NGX_HTTP_CONTENT_PHASE 阶段

但是，我们还有一个 熔断的功能，是需要在 request 处理前进行熔断，所以一定要在 NGX_HTTP_TRY_FILES_PHASE 之前进行处理，而根据模块开发的约定习俗，一般挂载在 NGX_HTTP_PREACCESS_PHASE 阶段

所以我们的插件实际上要在不同的 执行阶段 分别进行 逻辑运算处理，这里要注意~~~

定义模块配置结构

首先我们需要一个结构用于存储从配置文件中读进来的相关指令参数，即模块配置信息结构。根据Nginx模块开发规则，这个结构的命名规则为 ngx_http_[module-name]_conf_t，我们这里需要的配置为

1
2
3
4
5
6
7
8
9
10
11
typedef struct
{
    // 是否开启插件，off|on
    ngx_flag_t      enable;
    // 检测周期
    ngx_msec_t      section;
    // 检测周期内不健康请求个数
    ngx_uint_t      err_times;
    // 共享内存句柄
    ngx_shm_zone_t  *shm_zone;
} ngx_http_fuse_conf_t;

由于我们涉及数据存储（不健康个数、时间节点等）逻辑，所以使用了 slab共享内存池（slab 部分我们可以抽个时间单独分享一下），以下为内存存储数据结构

1
2
3
4
5
6
7
8
9
10
11
12
typedef struct {
    // 是否熔断
    ngx_flag_t      is_block;
    // 不健康个数
    ngx_int_t       cumulative_times;
    // 不健康请求发生的开始时间节点
    time_t          recording_time;
    // 通道半开标识
    ngx_flag_t      half_switch;
    // 通道半开时间节点
    time_t          half_switch_time;
} ngx_http_fuse_ctx_t;
定义指令

一个 Nginx 模块往往接收一至多个指令，此次熔断模块接收两个指令，Nginx模块使用一个ngx_command_t数组表示模块所能接收的所有模块，其中每一个元素表示一个条指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
static ngx_command_t ngx_http_fuse_commands[] =
{
    {
        ngx_string("fuse_switch"),
        NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF | NGX_HTTP_LIF_CONF | NGX_CONF_FLAG,
        ngx_conf_set_flag_slot,
        NGX_HTTP_LOC_CONF_OFFSET,
        offsetof(ngx_http_fuse_conf_t, enable),
        NULL
    },
    {
        ngx_string("fuse_setting"),
        NGX_HTTP_LOC_CONF | NGX_CONF_TAKE2,
        ngx_http_fuse_set_conf,
        NGX_HTTP_LOC_CONF_OFFSET,
        0,
        NULL
    },
    ngx_null_command
};
创建合并配置信息

这里首先需要定义一个 ngx_http_module_t 类型的结构体变量，命名规则为 ngx_http_[module-name]_module_ctx，这个结构主要用于定义各个 Hook 函数

一共有 8 个 Hook 注入点，，分别会在不同时刻被 Nginx 调用，由于我们的模块仅仅用于 location 域，这里将不需要的注入点设为 NULL 即可。其中 create_loc_conf 用于初始化一个配置结构体，如为配置结构体分配内存等工作；merge_loc_conf 用于将其父 block 的配置信息合并到此结构体中，也就是实现配置的继承。这两个函数会被 Nginx 自动调用。注意这里的命名规则：ngx_http_[module-name]_[create|merge]_conf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
static ngx_http_module_t ngx_http_fuse_module_ctx =
{
    // preconfiguration: 在创建和读取该模块的配置信息之前被调用
    NULL,
    // postconfiguration: 在创建和读取该模块的配置信息之后被调用
    ngx_http_fuse_init,
    // create_main_conf: 调用该函数创建本模块位于http block的配置信息存储结构。该函数成功的时候，返回创建的配置对象。失败的话，返回NULL
    NULL,
    // init_main_conf:  调用该函数初始化本模块位于http block的配置信息存储结构。该函数成功的时候，返回NGX_CONF_OK。失败的话，返回NGX_CONF_ERROR或错误字符串
    NULL,
    // create_srv_conf: 调用该函数创建本模块位于http server block的配置信息存储结构，每个server block会创建一个。该函数成功的时候，返回创建的配置对象。失败的话，返回NULL。
    NULL,
    // merge_srv_conf: 因为有些配置指令既可以出现在http block，也可以出现在http server block中。那么遇到这种情况，每个server都会有自己存储结构来存储该server的配置，但是在这种情况下http block中的配置与server block中的配置信息发生冲突的时候，就需要调用此函数进行合并，该函数并非必须提供，当预计到绝对不会发生需要合并的情况的时候，就无需提供。当然为了安全起见还是建议提供。该函数执行成功的时候，返回NGX_CONF_OK。失败的话，返回NGX_CONF_ERROR或错误字符串。
    NULL,
    // create_loc_conf: 调用该函数创建本模块位于location block的配置信息存储结构。每个在配置中指明的location创建一个。该函数执行成功，返回创建的配置对象。失败的话，返回NULL。
    ngx_http_fuse_create_conf,
    // merge_loc_conf:  与merge_srv_conf类似，这个也是进行配置值合并的地方。该函数成功的时候，返回NGX_CONF_OK。失败的话，返回NGX_CONF_ERROR或错误字符串。
    ngx_http_fuse_merge_conf
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
static ngx_int_t ngx_http_fuse_init(ngx_conf_t *cf)
{
    // 加入到 filter 模块的执行链表中，按顺序进行执行
    ngx_http_next_header_filter = ngx_http_top_header_filter;
    ngx_http_top_header_filter = ngx_http_fuse_header_filter;
    ngx_http_handler_pt        *h;
    ngx_http_core_main_conf_t  *cmcf;
    // 获取全局配置变量，从中拿到各个 Nginx 各个执行模块的数组
    cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
    h = ngx_array_push(&cmcf->phases[NGX_HTTP_POST_READ_PHASE].handlers);
    if (h == NULL)
    {
        return NGX_ERROR;
    }
    // 将 熔断的 handler 加入到 NGX_HTTP_PREACCESS_PHASE 阶段，强制提升执行级别
    *h = ngx_http_fuse_handler;
    h = ngx_array_push(&cmcf->phases[NGX_HTTP_PREACCESS_PHASE].handlers);
    if (h == NULL)
    {
        return NGX_ERROR;
    }
    return NGX_OK;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 创建并初始化熔断配置
static void *ngx_http_fuse_create_conf(ngx_conf_t *cf)
{
    ngx_http_fuse_conf_t *fusecf;
    fusecf = (ngx_http_fuse_conf_t *)ngx_pcalloc(cf->pool, sizeof(ngx_http_fuse_conf_t));
    if (fusecf == NULL)
    {
        return NULL;
    }
    fusecf->enable      = NGX_CONF_UNSET;
    fusecf->section     = NGX_CONF_UNSET_MSEC;
    fusecf->err_times   = NGX_CONF_UNSET_UINT;
    return fusecf;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// 合并配置
static char *ngx_http_fuse_merge_conf(ngx_conf_t *cf, void *parent, void *child)
{
    // 加入配置链表
    ngx_http_fuse_conf_t *prev = parent;
    ngx_http_fuse_conf_t *conf = child;
    // 初始化配置
    ngx_conf_merge_value(conf->enable, prev->enable, 0);
    ngx_conf_merge_value(conf->section, prev->section, 0);
    ngx_conf_merge_value(conf->err_times, prev->err_times, 0);
    // 初始化共享内存池
    ngx_shm_zone_t *shm_zone;
    ngx_str_t *shm_name;
    shm_name = ngx_palloc(cf->pool, sizeof *shm_name);
    // 设置本次使用内存池标识
    shm_name->len = sizeof("fuse_shared_memory") - 1;
    shm_name->data = (unsigned char *) "fuse_shared_memory";
    shm_zone = ngx_shared_memory_add(cf, shm_name, 8 * ngx_pagesize, &ngx_http_fuse_module);
    if(shm_zone == NULL)
    {
        return NGX_CONF_ERROR;
    }
    // 内存池初始化回调函数
    shm_zone->init = ngx_http_fuse_init_shm_zone;
    conf->shm_zone = shm_zone;
    ngx_conf_merge_ptr_value(conf->shm_zone, prev->shm_zone, NULL);
    return NGX_CONF_OK;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 初始化此模块所使用的内存池数据
static ngx_int_t ngx_http_fuse_init_shm_zone(ngx_shm_zone_t *shm_zone, void *data)
{
    ngx_slab_pool_t *shpool;
    ngx_http_fuse_ctx_t *ctx;
    time_t now;
    now = ngx_time();
    if(data)
    {
        shm_zone->data = data;
        return NGX_OK;
    }
    shpool = (ngx_slab_pool_t *)shm_zone->shm.addr;
    ctx = ngx_slab_alloc(shpool, sizeof *ctx);
    ctx->is_block           = 0;
    ctx->cumulative_times   = 0;
    ctx->recording_time     = 0;
    ctx->half_switch        = 0;
    ctx->half_switch_time   = 0;
    shm_zone->data = ctx;
    return NGX_OK;
}
编写 Handler

handler 我们分为两个部分，header 过滤功能（ngx_http_fuse_header_filter） 和 request 预处理功能（ngx_http_fuse_handler）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
// 主要检测 response 的不健康度及其数据统计
static ngx_int_t ngx_http_fuse_header_filter(ngx_http_request_t *r)
{
    ngx_connection_t *c;
    c = r->connection;
    ngx_http_fuse_conf_t    *conf;
    ngx_shm_zone_t          *shm_zone;
    time_t                  now;
    ngx_flag_t              now_is_block;
    time_t                  now_recording_time;
    ngx_int_t               now_cumulative_times;
    time_t                  now_half_switch_time;
    ngx_flag_t              now_half_switch;
    conf = ngx_http_get_module_loc_conf(r, ngx_http_fuse_module);
    if (conf->enable == 0)
    {
        return ngx_http_next_header_filter(r);
    }
    if(conf->shm_zone == NULL)
    {
        return NGX_DECLINED;
    }
    
    // 从内存中读取数据
    shm_zone                = conf->shm_zone;
    now                     = ngx_time();
    now_is_block            = ((ngx_http_fuse_ctx_t *)shm_zone->data)->is_block;
    now_cumulative_times    = ((ngx_http_fuse_ctx_t *)shm_zone->data)->cumulative_times;
    now_recording_time      = ((ngx_http_fuse_ctx_t *)shm_zone->data)->recording_time;
    now_half_switch         = ((ngx_http_fuse_ctx_t *)shm_zone->data)->half_switch;
    now_half_switch_time    = ((ngx_http_fuse_ctx_t *)shm_zone->data)->half_switch_time;
    // 是否开启半开通道
    if (now_half_switch == 1)
    {
        ((ngx_http_fuse_ctx_t *)shm_zone->data)->half_switch        = 0;
    }
    // 状态码检测
    if (r->headers_out.status == NGX_HTTP_OK)
    {
        ((ngx_http_fuse_ctx_t *)shm_zone->data)->is_block           = 0;
        ((ngx_http_fuse_ctx_t *)shm_zone->data)->cumulative_times   = 0;
    }
    // 这里特殊使用了指定的状态码，实际应该由配置文件指定
    else if (r->headers_out.status == 503)
    {
        if ((now - now_half_switch_time) > 10 && now_half_switch == 0)
        {
            ((ngx_http_fuse_ctx_t *)shm_zone->data)->half_switch        = 1;
            ((ngx_http_fuse_ctx_t *)shm_zone->data)->half_switch_time   = now;
        }
    }
    else
    {
        ((ngx_http_fuse_ctx_t *)shm_zone->data)->recording_time     = now;
        ((ngx_http_fuse_ctx_t *)shm_zone->data)->cumulative_times   = ++now_cumulative_times;
    }
    return ngx_http_next_header_filter(r);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
// request 预处理
static ngx_int_t ngx_http_fuse_handler(ngx_http_request_t *r)
{
    ngx_connection_t *c;
    c = r->connection;
    ngx_http_fuse_conf_t    *conf;
    ngx_shm_zone_t          *shm_zone;
    time_t                  now;
    ngx_flag_t              now_is_block;
    time_t                  now_recording_time;
    ngx_int_t               now_cumulative_times;
    time_t                  now_half_switch_time;
    ngx_flag_t              now_half_switch;
    conf = ngx_http_get_module_loc_conf(r, ngx_http_fuse_module);
    if (conf->enable == 0 || conf->shm_zone == NULL)
    {
        return NGX_DECLINED;
    }
    
    // 内存池中读取数据
    shm_zone = conf->shm_zone;
    now                     = ngx_time();
    now_is_block            = ((ngx_http_fuse_ctx_t *)shm_zone->data)->is_block;
    now_cumulative_times    = ((ngx_http_fuse_ctx_t *)shm_zone->data)->cumulative_times;
    now_recording_time      = ((ngx_http_fuse_ctx_t *)shm_zone->data)->recording_time;
    now_half_switch         = ((ngx_http_fuse_ctx_t *)shm_zone->data)->half_switch;
    now_half_switch_time    = ((ngx_http_fuse_ctx_t *)shm_zone->data)->half_switch_time;
    
    // 是否打开熔断阻隔
    if (now_is_block == 1 && now_half_switch == 0)
    {
        return NGX_HTTP_SERVICE_UNAVAILABLE;
    }
    else
    {
        // 熔断器阻隔判断以及不健康度统计
        if ((now - now_recording_time) <= conf->section)
        {
            if (now_cumulative_times >= conf->err_times)
            {
                now_is_block = 1;
                ((ngx_http_fuse_ctx_t *)shm_zone->data)->is_block           = now_is_block;
                ((ngx_http_fuse_ctx_t *)shm_zone->data)->half_switch_time   = now;
                return NGX_HTTP_SERVICE_UNAVAILABLE;
            }
        }
    }
    return NGX_DECLINED;
}

上面我们已经展示了 熔断模块的各个组成部分，接下来我们对各个部分进行组装，形成 Nginx 可识别的 模块入口

组合Nginx Module
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
ngx_module_t ngx_http_fuse_module =
{
    NGX_MODULE_V1,
    // 挂载点
    &ngx_http_fuse_module_ctx,
    // command 处理
    ngx_http_fuse_commands,
    NGX_HTTP_MODULE,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NGX_MODULE_V1_PADDING
};

安装调试

安装

为了调试，这里特地打开了 debug，并且使用了 -g -O0 跳过编译优化

1
2
3
4
./configure --prefix=/usr/local/nginx --with-debug --with-cc-opt='-g -O0' --add-module=/path/ngx_http_fuse_module
make
make install

调试

我们对 nginx.conf 进行特殊设置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# debug 日志级别
error_log  logs/error.log  debug;
# 去除守护进行
daemon off;
# 单进程模式
worker_processes  1;
master_process off;
# 测试 server 配置
server {
    listen       80;
    server_name  localhost;
    # 配置简易 PHP 请求，使用 fastcgi 模块进行处理请求
    location ~ \.php$ {
        # 熔断模块配置
        fuse_switch on;
        fuse_setting 10s 5;
        
        root /usr/local/nginx/html;
        fastcgi_pass 127.0.0.1:9000;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }
}

1
2
3
4
5
6
cgdb /usr/local/nginx
(gdb) break ngx_http_fuse_create_conf
(gdb) break ngx_http_fuse_merge_conf
(gdb) break ngx_http_fuse_set_conf
(gdb) break ngx_http_fuse_header_filter
......
测试

PHP 测试程序中实现逻辑为，根据传递的参数强行执行 header 返回状态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
[root@9dc4f6f0969b /]# curl -I http://localhost/index.php?_t=200
HTTP/1.1 200 OK
Server: nginx/1.16.1
Date: Fri, 22 Nov 2019 13:44:18 GMT
Content-Type: text/html
Connection: keep-alive
X-Powered-By: PHP/5.4.16
[root@9dc4f6f0969b /]# curl -I http://localhost/index.php?_t=500
HTTP/1.1 500 Internal Server Error
Server: nginx/1.16.1
Date: Fri, 22 Nov 2019 13:44:36 GMT
Content-Type: text/html
Connection: keep-alive
X-Powered-By: PHP/5.4.16
[root@9dc4f6f0969b /]# curl -I http://localhost/index.php?_t=500
......
[root@9dc4f6f0969b /]# curl -I http://localhost/index.php?_t=500
......
[root@9dc4f6f0969b /]# curl -I http://localhost/index.php?_t=500
......
[root@9dc4f6f0969b /]# curl -I http://localhost/index.php?_t=500
......
# 第 5 次请求的时候返回了 模块里面设置的熔断状态码 503
[root@9dc4f6f0969b /]# curl -I http://localhost/index.php?_t=500
HTTP/1.1 503 Service Temporarily Unavailable
Server: nginx/1.16.1
Date: Fri, 22 Nov 2019 13:46:13 GMT
Content-Type: text/html
Content-Length: 197
Connection: keep-alive
# 即使请求参数为 200，理应返回正常请求，由于处于熔断状态，依然返回 503
[root@9dc4f6f0969b /]# curl -I http://localhost/index.php?_t=200
HTTP/1.1 503 Service Temporarily Unavailable
Server: nginx/1.16.1
Date: Fri, 22 Nov 2019 13:46:13 GMT
Content-Type: text/html
Content-Length: 197
Connection: keep-alive

….直到半开通道开启，如果检测到 200 状态码，则打开熔断阻隔，如果检测依然为 不健康状态码，依然熔断

成功实现我们最初设计的简单熔断功能…

优秀的 第三方模块

https://www.nginx.com/resources/wiki/modules/index.html

本文作者： wettper
本文链接： http://www.web-lovers.com/redis-module-fuse.html
版权声明： 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 3.0 许可协议。转载请注明出处！

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

wettper <br /><br /> 现 离职状态 程序猿 <br /><br /> 叫醒我的不止阳光，还有梦想！<br /><br /> 喵喵、念念、健身、吉他！