《ngx底层设计和源码分析》—— 限流模块
1. 限流算法
ngx_http_limit_req_module 使用桶算法，
定义一个桶，桶的出口流速固定，入口流速大于出口时，请求被缓存在桶中，
定义桶的容积，当请求超过容积，则丢弃请求。
limit_req_zone ： 定义一个桶，且定义桶的出口流速
limit_req ： 定义使用桶，和桶的容积
使用示例
2. 源码解析
2.1 ngx_http_limit_req_zone
保存桶属性，申请分配一个共享块
43 typedef struct {
44 ngx_http_limit_req_shctx_t *sh; // 共享块上的 桶
45 ngx_slab_pool_t *shpool; // 共享块内存池
46 /* integer value, 1 corresponds to 0.001 r/s */
47 ngx_uint_t rate; // 桶的出口流速
48 ngx_http_complex_value_t key; // 桶的节点 key值
49 ngx_http_limit_req_node_t *node; // 最近命中此桶的 请求的节点 // 这里是否会有 并发冲突？
50 } ngx_http_limit_req_ctx_t;
863 static char *
864 ngx_http_limit_req_zone(ngx_conf_t *cf, ngx_command_t *cmd, void *conf )
865 {
873 ngx_http_limit_req_ctx_t *ctx;
970 ctx->rate = rate * 1000 / scale; // 流速精度为毫秒级
971
972 shm_zone = ngx_shared_memory_add(cf, &name, size,
973 &ngx_http_limit_req_module);
986
987 shm_zone->init = ngx_http_limit_req_init_zone;
988 shm_zone->data = ctx;
989
990 return NGX_CONF_OK;
991 }
共享块上有 一个红黑树 和 一个队列
红黑树用于根据 key 快速找到请求节点
队列为LRU队列，用于回收最长时间未使用的内存，防止共享块被耗尽
722 static ngx_int_t
723 ngx_http_limit_req_init_zone(ngx_shm_zone_t *shm_zone, void *data)
724 {
732 if (octx) {
746 ctx->sh = octx->sh;
747 ctx->shpool = octx->shpool;
748
749 return NGX_OK;
750 }
762 ctx->sh = ngx_slab_alloc(ctx->shpool, sizeof(ngx_http_limit_req_shctx_t));
763 if (ctx->sh == NULL) {
764 return NGX_ERROR;
765 }
766
767 ctx->shpool->data = ctx->sh;
768
769 ngx_rbtree_init(&ctx->sh->rbtree, &ctx->sh->sentinel,
770 ngx_http_limit_req_rbtree_insert_value);
771
772 ngx_queue_init(&ctx->sh->queue);
785
786 return NGX_OK;
787 }
可以看出桶是 http{} 块定义，且桶无法区分 节点是来自 哪个server {} 或 哪个 location{}，
所以 传入给 桶的 节点，使用的 key 需要包含 host uri remote_ip 等信息。
2.2 limit_req 使用限制器
用户在需要 限流的 location 下使用 limit_req 指令，添加限制器到 ngx_http_limit_req_conf_t->limits 数组
61 typedef struct {
62 /* ngx_http_limit_req_limit_t * */
63 // limiters for current location
64 ngx_array_t limits;
65 ngx_uint_t limit_log_level;
66 ngx_uint_t delay_log_level;
67 ngx_uint_t status_code;
68 ngx_flag_t dry_run;
69 } ngx_http_limit_req_conf_t;
999 static char *
1000 ngx_http_limit_req(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1001 {
1002 ngx_http_limit_req_conf_t *lrcf = conf;
1023 shm_zone = ngx_shared_memory_add(cf, &s, 0,
1024 &ngx_http_limit_req_module);
1090 limit = ngx_array_push(&lrcf->limits);
1091 if (limit == NULL) {
1092 return NGX_CONF_ERROR;
1093 }
1094
1095 limit->shm_zone = shm_zone;
1096 limit->burst = burst * 1000;
1097 limit->delay = delay * 1000;
1098
1099 return NGX_CONF_OK;
1100 }
2.3 请求处理
在 NGX_HTTP_PREACCESS_PHASE 阶段 处理
1122 static ngx_int_t
1123 ngx_http_limit_req_init(ngx_conf_t *cf)
1124 {
1125 ngx_http_handler_pt *h;
1126 ngx_http_core_main_conf_t *cmcf;
1127
1128 cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module );
1129
1130 h = ngx_array_push(&cmcf->phases[NGX_HTTP_PREACCESS_PHASE].handler s);
1131 if (h == NULL) {
1132 return NGX_ERROR;
1133 }
1134
1135 *h = ngx_http_limit_req_handler;
1136
1137 return NGX_OK;
1138 }
对请求进行处理，可能 丢弃，延迟，通过
199 static ngx_int_t
200 ngx_http_limit_req_handler(ngx_http_request_t *r)
201 {
225 // 使用本location下所有限流器，依次检查
// 出现 桶溢出，NGX_BUSY 时跳出 for {}
// 若所有 桶 都没有溢出，返回 NGX_OK,跳出 for{}
226 for (n = 0; n < lrcf->limits.nelts; n++) {
227
228 limit = &limits[n];
229
230 ctx = limit->shm_zone->data;
231
232 if (ngx_http_complex_value(r, &ctx->key, &key) != NGX_OK) {
233 ngx_http_limit_req_unlock(limits, n);
234 return NGX_HTTP_INTERNAL_SERVER_ERROR;
235 }
236
237 if (key.len == 0) {
238 continue;
239 }
240
241 if (key.len > 65535) {
242 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
243 "the value of the \"%V\" key "
244 "is more than 65535 bytes: \"%V\"",
245 &ctx->key.value, &key);
246 continue;
247 }
248
249 hash = ngx_crc32_short(key.data, key.len);
250
251 ngx_shmtx_lock(&ctx->shpool->mutex);
252
253 /*
254 * NGX_OK : pass the all limiter
255 * NGX_AGAIN : pass limiter, check the next limiter
256 * NGX_BUSY : trigger limit, need to discard
257 * NGX_ERROR : error, need to discard
258 */
259 rc = ngx_http_limit_req_lookup(limit, hash, &key, &excess,
260 (n == lrcf->limits.nelts - 1));
261
262 ngx_shmtx_unlock(&ctx->shpool->mutex);
267
268 if (rc != NGX_AGAIN) {
269 break;
270 }
271 }
273 if (rc == NGX_DECLINED) {
274 return NGX_DECLINED;
275 }
276 // 请求溢出，直接丢弃
277 if (rc == NGX_BUSY || rc == NGX_ERROR) {
278
287 ngx_http_limit_req_unlock(limits, n);
288
289 if (lrcf->dry_run) {
290 r->main->limit_req_status = NGX_HTTP_LIMIT_REQ_REJECTED_DR Y_RUN;
291 return NGX_DECLINED;
292 }
293
294 r->main->limit_req_status = NGX_HTTP_LIMIT_REQ_REJECTED;
295
296 return lrcf->status_code;
297 }
299 /* rc == NGX_AGAIN || rc == NGX_OK */
300
301 if (rc == NGX_AGAIN) {
302 excess = 0;
303 }
304 // 请求没有溢出，查看 是否需要延迟处理（当桶的出口流速小于 入口流速）
305 delay = ngx_http_limit_req_account(limits, n, &excess, &limit);
306 // 不需要延迟处理，交给下一个模块
307 if (!delay) {
308 r->main->limit_req_status = NGX_HTTP_LIMIT_REQ_PASSED;
309 return NGX_DECLINED;
310 }
// 延迟处理
333 r->read_event_handler = ngx_http_test_reading;
334 r->write_event_handler = ngx_http_limit_req_delay;
335
336 r->connection->write->delayed = 1;
337 ngx_add_timer(r->connection->write, delay);
338
339 return NGX_AGAIN;
340 }
查看请求是否溢出
415 static ngx_int_t
416 ngx_http_limit_req_lookup(ngx_http_limit_req_limit_t *limit, ngx_uint_ t hash,
417 ngx_str_t *key, ngx_uint_t *ep, ngx_uint_t account)
418 {
427 now = ngx_current_msec;
428
429 ctx = limit->shm_zone->data;
430
431 node = ctx->sh->rbtree.root;
432 sentinel = ctx->sh->rbtree.sentinel;
433 // 遍历树
434 while (node != sentinel) {
435
436 if (hash < node->key) {
437 node = node->left;
438 continue;
439 }
440
441 if (hash > node->key) {
442 node = node->right;
443 continue;
444 }
445
446 /* hash == node->key */
447 // 找到节点
448 lr = (ngx_http_limit_req_node_t *) &node->color;
449
450 rc = ngx_memn2cmp(key->data, lr->data, key->len, (size_t) lr->len);
451
452 if (rc == 0) {
// 当请求命中树，将节点移动到 LRU队列 首部，以保持 LRU队列 尾部为 最长时间没有被访问节点
453 // move the recently accessed node to the head of the LRU queue
454 ngx_queue_remove(&lr->queue);
455 ngx_queue_insert_head(&ctx->sh->queue, &lr->queue);
456 // 计算对桶容量的消耗
457 ms = (ngx_msec_int_t) (now - lr->last);
458
459 if (ms < -60000) {
460 ms = 1;
461
462 } else if (ms < 0) {
463 ms = 0;
464 }
466 // ctx->rate * ms : num of accessible
467 // + 1000 : num of accesses consumed
468 // lr->excess : sum of overflow num
469 // excess : last overflow num
470 excess = lr->excess - ctx->rate * ms / 1000 + 1000;
471
472 if (excess < 0) {
473 excess = 0;
474 }
475
476 *ep = excess;
477 // 当消耗大于桶的容积，则溢出
478 // req overflow
479 if ((ngx_uint_t) excess > limit->burst) {
480 return NGX_BUSY;
481 }
482 // 没有超过桶的容积，
// 若含有其他限流器，则返回 NGX_AGAIN,以检查下一个限流器
// 若为最后一个限流器，则返回NGX_OK
483 // pass the last limiter, update time and excess
484 // return NGX_OK
485 if (account) {
486 lr->excess = excess;
487
488 if (ms) {
489 lr->last = now;
490 }
491
492 return NGX_OK;
493 }
// 对本节点进行标记，表明本节点刚刚被访问过
495 // increase num of visits
496 lr->count++;
497
498 ctx->node = lr;
499
500 return NGX_AGAIN;
501 }
502
503 node = (rc < 0) ? node->left : node->right;
504 }
// 若没有命中树，则添加新节点
506 // add new node
507
508 *ep = 0;
509
510 size = offsetof(ngx_rbtree_node_t, color)
511 + offsetof(ngx_http_limit_req_node_t, data)
512 + key->len;
513 // 回收长时间没有使用过的节点
514 // recover expired mem
515 ngx_http_limit_req_expire(ctx, 1);
516
517 node = ngx_slab_alloc_locked(ctx->shpool, size);
518
519 if (node == NULL) {
520 ngx_http_limit_req_expire(ctx, 0);
521
522 node = ngx_slab_alloc_locked(ctx->shpool, size);
523 if (node == NULL) {
524 ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
525 "could not allocate node%s", ctx->shpool->lo g_ctx);
526 return NGX_ERROR;
527 }
528 }
529
530 node->key = hash;
531
532 lr = (ngx_http_limit_req_node_t *) &node->color;
533
534 lr->len = (u_short) key->len;
535 lr->excess = 0;
536
537 ngx_memcpy(lr->data, key->data, key->len);
538
539 ngx_rbtree_insert(&ctx->sh->rbtree, node);
540
541 ngx_queue_insert_head(&ctx->sh->queue, &lr->queue);
542
543 if (account) {
544 lr->last = now;
545 lr->count = 0;
546 return NGX_OK;
547 }
548
549 lr->last = 0;
550 lr->count = 1;
551
552 ctx->node = lr;
553
554 return NGX_AGAIN;
555 }
回收最长时间未访问的节点
655 static void
656 ngx_http_limit_req_expire(ngx_http_limit_req_ctx_t *ctx, ngx_uint_t n)
657 {
665 now = ngx_current_msec;
666
667 /*
668 * n == 1 deletes one or two zero rate entries
669 * n == 0 deletes oldest entry by force
670 * and one or two zero rate entries
671 */
672 // n == 1 : 回收 超过60秒没有请求命中，且为桶缓存的节点，最多2个
// n == 0 : 强制回收一个，再 按n==1，可能再回收 2个
673 while (n < 3) {
675 if (ngx_queue_empty(&ctx->sh->queue)) {
676 return;
677 }
678 // 获得最老的节点
679 // get oldest node
680 q = ngx_queue_last(&ctx->sh->queue);
681
682 lr = ngx_queue_data(q, ngx_http_limit_req_node_t, queue);
683 // 若 lr->count>0 表示该节点最近才被命中，则说明所有的节点都不应该被回收
684 if (lr->count) {
685
686 /*
687 * There is not much sense in looking further,
688 * because we bump nodes on the lookup stage.
689 */
690
691 return;
692 }
// n != 0 时，检查本节点是否可以避免回收
694 if (n++ != 0) {
695
696 ms = (ngx_msec_int_t) (now - lr->last);
697 ms = ngx_abs(ms);
698
699 if (ms < 60000) {
700 return;
701 }
702
703 excess = lr->excess - ctx->rate * ms / 1000;
704
705 if (excess > 0) {
706 return;
707 }
708 }
// 回收节点
710 ngx_queue_remove(q);
711
712 node = (ngx_rbtree_node_t *)
713 ((u_char *) lr - offsetof(ngx_rbtree_node_t, color));
714
715 ngx_rbtree_delete(&ctx->sh->rbtree, node);
716
717 ngx_slab_free_locked(ctx->shpool, node);
718 }
719 }
检查请求是否延迟处理
558 static ngx_msec_t
559 ngx_http_limit_req_account(ngx_http_limit_req_limit_t *limits, ngx_uin t_t n,
560 ngx_uint_t *ep, ngx_http_limit_req_limit_t **limit)
561 {
// ep 为最后一个限流器的 延迟结果
568 excess = *ep;
569
570 if ((ngx_uint_t) excess <= (*limit)->delay) {
571 max_delay = 0;
572
573 } else {
574 ctx = (*limit)->shm_zone->data;
575 max_delay = (excess - (*limit)->delay) * 1000 / ctx->rate;
576 }
// 遍历所有限流器，找到最到 延迟值
578 while (n--) {
// 在 ngx_http_limit_req_lookup 时，将 本请求对应的红黑树节点指针保存在了 ctx->node，
// 所有可以 不进行 遍历，直接获得节点。
579 ctx = limits[n].shm_zone->data;
580 lr = ctx->node;
581
582 if (lr == NULL) {
583 continue;
584 }
585
586 ngx_shmtx_lock(&ctx->shpool->mutex);
587
588 now = ngx_current_msec;
589 ms = (ngx_msec_int_t) (now - lr->last);
590
591 if (ms < -60000) {
592 ms = 1;
593
594 } else if (ms < 0) {
595 ms = 0;
596 }
597
598 excess = lr->excess - ctx->rate * ms / 1000 + 1000;
599
600 if (excess < 0) {
601 excess = 0;
602 }
603
604 if (ms) {
605 lr->last = now;
606 }
607
608 lr->excess = excess;
609 lr->count--;
610
611 ngx_shmtx_unlock(&ctx->shpool->mutex);
612
613 ctx->node = NULL;
614
615 if ((ngx_uint_t) excess <= limits[n].delay) {
616 continue;
617 }
618
619 delay = (excess - limits[n].delay) * 1000 / ctx->rate;
620
621 if (delay > max_delay) {
622 max_delay = delay;
623 *ep = excess;
624 *limit = &limits[n];
625 }
626 }
627
628 return max_delay;
629 }
3. 总结
此模块展示了 共享块的使用，
由于共享块是 全局的（无法区分根据配置上下文区分（server{} location{}））,
所以所有 server{} location{} 的 传来的数据 都应该可以 记录到共享块的容器，
为了区分，这些 数据，必须使用 key。
为了高效回收共享块内存，使用 LRU 链表，
LRU链表就是 把 最近命中的节点放到 链表首部，那么链表尾部就是最长时间未被使用的节点，则最应该没释放。
ngx对红黑树的节点的使用
ngx_http_limit_req_node_t->data[1] 是柔性数组，所以分配空间是数组长度为 key->len
ngx计算请求是否过载 也是十分巧妙
470 excess = lr->excess - ctx->rate * ms / 1000 + 1000;
lr->excess 是桶当前剩余 容量
ctx->rate * ms/1000 : 桶的出口流速*时间 = 这段时间内桶增加的容量
+ 1000 : 单次访问消耗的 容量
所以最后得到 本次请求后，桶剩余的容量，
若容量大于容积，则溢出，则丢弃，
若容量大于0，则延迟处理，
若容量小于0，则立即处理。
