加权轮询 (Weighted Round Robin) 下篇

最后更新于:2022-04-01 10:13:41

Nginx版本:1.9.1 我的博客:[http://blog.csdn.net/zhangskd](http://blog.csdn.net/zhangskd)   上篇blog讲述了加权轮询算法的原理、以及负载均衡模块中使用的数据结构,接着我们来看看加权轮询算法的具体实现。   **指令的解析函数**   如果upstream配置块中没有指定使用哪种负载均衡算法,那么默认使用加权轮询。 也就是说使用加权轮询算法,并不需要特定的指令,因此也不需要实现指令的解析函数。 而实际上,和其它负载均衡算法不同(比如ip_hash),加权轮询算法并不是以模块的方式实现的, 而是作为Nginx框架的一部分。   **初始化upstream块**   在执行ngx_http_upstream_module的init main conf函数时,会遍历所有upstream配置块,调用它们 事先指定的初始化函数。对于一个upstream配置块,如果没有指定初始化函数,则调用加权轮询算法 提供的upstream块初始化函数 - ngx_http_upstream_init_round_robin。   来看下ngx_http_upstream_module。 ~~~ ngx_http_module_t ngx_http_upstream_module_ctx = { ... ngx_http_upstream_init_main_conf, /* init main configuration */ ... }; ~~~ ~~~ static char *ngx_http_upstream_init_main_conf(ngx_conf_t *cf, void *conf) { ... /* 数组的元素类型是ngx_http_upstream_srv_conf_t */ for (i = 0; i < umcf->upstreams.nelts; i++) { /* 如果没有指定upstream块的初始化函数,默认使用round robin的 */ init = uscfp[i]->peer.init_upstream ? uscfp[i]->peer.init_upstream : ngx_http_upstream_init_round_robin; if (init(cf, uscfp[i] != NGX_OK) { return NGX_CONF_ERROR; } } ... } ~~~ ngx_http_upstream_init_round_robin做的工作很简单: 指定请求的负载均衡初始化函数,用于初始化per request的负载均衡数据。 创建和初始化后端集群、备份集群。 ~~~ ngx_int_t ngx_http_upstream_init_round_robin (ngx_conf_t *cf, ngx_http_upstream_srv_conf_t *us) { ngx_url_t u; ngx_uint_t i, j, n, w; ngx_http_upstream_server_t *server; ngx_http_upstream_rr_peer_t *peer, **peerp; ngx_http_upstream_rr_peers_t *peers, *backup; /* 指定请求的负载均衡初始化函数,用于初始化per request的负载均衡数据 */ us->peer.init = ngx_http_upstream_init_round_robin_peer; /* upstream配置块的servers数组,在解析配置文件时就创建好了 */ if (us->servers) { server = us->servers->elts; n = 0; w = 0; /* 数组元素类型为ngx_http_upstream_server_t,对应一条server指令 */ for (i = 0; i < us->servers->nelts; i++) { if (server[i].backup) continue; n += server[i].naddrs; /* 所有后端服务器的数量 */ w += server[i].naddrs * server[i].weight; /* 所有后端服务器的权重之和 */ } if (n == 0) { /* 至少得有一台后端吧 */ ... return NGX_ERROR; } /* 创建一个后端集群的实例 */ peers = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peers_t)); ... /* 创建后端服务器的实例,总共有n台 */ peer = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peer_t) * n); ... /* 初始化集群 */ peers->single = (n == 1); /* 是否只有一台后端 */ peers->number = n; /* 后端服务器的数量 */ peers->weight = (w != n); /* 是否使用权重 */ peers->total_weight = w; /* 所有后端服务器权重的累加值 */ peers->name = &us->host; /* upstream配置块的名称 */ n = 0; peerp = &peers->peer; /* 初始化代表后端的结构体ngx_http_upstream_peer_t. * server指令后跟的是域名的话,可能对应多台后端. */ for(i = 0; i < us->servers->nelts; i++) { if (server[i].backup) continue; for (j = 0; j < server[i].naddrs; j++) { peer[n].sockaddr = server[i].addrs[j].sockaddr; /* 后端服务器的地址 */ peer[n].socklen = server[i].addrs[j].socklen; /* 地址的长度*/ peer[n].name = server[i].addrs[j].name; /* 后端服务器地址的字符串 */ peer[n].weight = server[i].weight; /* 配置项指定的权重,固定值 */ peer[n].effective_weight = server[i].weight; /* 有效的权重,会因为失败而降低 */ peer[n].current_weight = 0; /* 当前的权重,动态调整,初始值为0 */ peer[n].max_fails = server[i].max_fails; /* "一段时间内",最大的失败次数,固定值 */ peer[n].fail_timeout = server[i].fail_timeout; /* "一段时间"的值,固定值 */ peer[n].down = server[i].down; /* 服务器永久不可用的标志 */ peer[n].server = server[i].name; /* server的名称 */ /* 把后端服务器组成一个链表,第一个后端的地址保存在peers->peer */ *peerp = &peer[n]; peerp = &peer[n].next; n++; } } us->peer.data = peers; /* 保存后端集群的地址 */ } /* backup servers */ /* 创建和初始化备份集群,peers->next指向备份集群,和上述流程类似,不再赘述 */ ... /* an upstream implicitly defined by proxy_pass, etc. */ /* 如果直接使用proxy_pass指令,没有定义upstream配置块 */ if (us->port == 0) { ... return NGX_ERROR; } ngx_memzero(&u, sizeof(ngx_url_t)); u.host = us->host; u.port = us->port; /* 根据URL解析域名 */ if (ngx_inet_resolve_host(cf->pool, &u) != NGX_OK) { ... return NGX_ERROR; } n = u.naddrs; /* 共有n个后端 */ /* 接下来创建后端集群,并进行初始化,和上述流程类似,这里不再赘述 */ ... return NGX_OK; } ~~~   **初始化请求的负载均衡数据**   当收到一个请求后,一般使用的反向代理模块(upstream模块)为ngx_http_proxy_module, 其NGX_HTTP_CONTENT_PHASE阶段的处理函数为ngx_http_proxy_handler,在初始化upstream机制的 函数ngx_http_upstream_init_request中,调用在第二步中指定的peer.init,主要用于: 创建和初始化该请求的负载均衡数据块 指定r->upstream->**peer.get**,用于从集群中选取一台后端服务器(这是我们最为关心的) 指定r->upstream->**peer.free**,当不用该后端时,进行数据的更新(不管成功或失败都调用) 指定r->upstream->peer.tries,请求最多允许尝试这么多个后端 ~~~ ngx_int_t ngx_http_upstream_init_round_robin_peer(ngx_http_request_t *r, ngx_http_upstream_srv_conf_t *us) { ngx_uint_t n; ngx_http_upstream_rr_peer_data_t *rrp; /* 创建请求的负载均衡数据块 */ rrp = r->upstream->peer.data; if (rrp == NULL) { rrp = ngx_palloc(r->pool, sizeof(ngx_http_upstream_rr_peer_data_t)); if (rrp == NULL) return NGX_ERROR; r->upstream->peer.data = rrp; /* 保存请求负载均衡数据的地址 */ } rrp->peers = us->peer.data; /* upstream块的后端集群 */ rrp->current = NULL; n = rrp->peers->number; /* 后端的数量 */ /* 如果存在备份集群,且其服务器数量超过n */ if (rrp->peers->next && rrp->peers->next->number > n) { n = rrp->peers->next->number; } /* rrp->tried指向后端服务器的位图,每一位代表一台后端的状态,0表示可用,1表示不可用。 * 如果后端数较少,直接使用rrp->data作为位图。如果后端数较多,则需要申请一块内存。 */ if (n <= 8 *sizeof(uintptr_t)) { rrp->tried = &rrp->data; rrp->data = 0; } else { n = ( n + (8 * sizeof(uintptr_t) - 1)) / (8 * sizeof(uintptr_t)); /* 向上取整 */ rrp->tried = ngx_pcalloc(r->pool, n * sizeof(uintptr_t)); if (rrp->tried == NULL) { return NGX_ERROR; } } r->upstream->peer.get = ngx_http_upstream_get_round_robin_peer; /* 指定peer.get,用于从集群中选取一台后端服务器 */ r->upstream->peer.free = ngx_http_upstream_free_round_robin_peer; /* 指定peer.free,当不用该后端时,进行数据的更新 */ r->upstream->peer.tries = ngx_http_upstream_tries(rrp->peers); /* 指定peer.tries,是请求允许尝试的后端服务器个数 */ ... return NGX_OK; } #define ngx_http_upstream_tries(p) ((p)->number + ((p)->next ? (p)->next->number : 0)) ~~~   **选取一台后端服务器**   一般upstream块中会有多台后端,那么对于本次请求,要选定哪一台后端呢? 这时候第三步中r->upstream->peer.get指向的函数就派上用场了: 采用加权轮询算法,从集群中选出一台后端来处理本次请求。 选定后端的地址保存在pc->sockaddr,pc为主动连接。 函数的返回值: NGX_DONE:选定一个后端,和该后端的连接已经建立。之后会直接发送请求。 NGX_OK:选定一个后端,和该后端的连接尚未建立。之后会和后端建立连接。 NGX_BUSY:所有的后端(包括备份集群)都不可用。之后会给客户端发送502(Bad Gateway)。 ~~~ ngx_int_t ngx_http_upstream_get_round_robin_peer(ngx_peer_connection_t *pc, void *data) { ngx_http_upstream_rr_peer_data_t *rrp = data; /* 请求的负载均衡数据 */ ngx_int_t rc; ngx_uint_t i, n; ngx_http_upstream_rr_peer_t *peer; ngx_http_upstream_rr_peers_t *peers; ... pc->cached = 0; pc->connection = NULL; peers = rrp->peers; /* 后端集群 */ ... /* 如果只有一台后端,那就不用选了 */ if (peers->single) { peer = peers->peer; if (peer->down) goto failed; rrp->current = peer; } else { /* there are several peers */ /* 调用ngx_http_upstream_get_peer来从后端集群中选定一台后端服务器 */ peer = ngx_http_upstream_get_peer(rrp); if (peer == NULL) goto failed; ... } /* 保存选定的后端服务器的地址,之后会向这个地址发起连接 */ pc->sockaddr = peer->sockaddr; pc->socklen = peer->socklen; pc->name = &peer->name; peer->conns++; /* 增加选定后端的当前连接数 */ ... return NGX_OK; failed: /* 如果不能从集群中选取一台后端,那么尝试备用集群 */ if (peers->next) { ... rrp->peers = peers->next; n = (rrp->peers->number + (8 * sizeof(uintptr_t) - 1)) / (8 * sizeof(uintptr_t)); for (i = 0; i < n; i++) rrp->tried[i] = 0; /* 重新调用本函数 */ rc = ngx_http_upstream_get_round_robin_peer(pc, rrp); if (rc != NGX_BUSY) return rc; } /* all peers failed, mark them as live for quick recovery */ for (peer = peers->peer; peer; peer = peer->next) { peer->fails = 0; } pc->name = peers->name; return NGX_BUSY; } ~~~ ngx_http_upstream_get_peer用于从集群中选取一台后端服务器。 ~~~ static ngx_http_upstream_rr_peer_t *ngx_http_upstream_get_peer(ngx_http_upstream_rr_peer_data_t *rrp) { time_t now; uintptr_t m; ngx_int_t total; ngx_uint_t i, n, p; ngx_http_upstream_rr_peer_t *peer, *best; now = ngx_time(); best = NULL; total = 0; ... /* 遍历集群中的所有后端 */ for (peer = rrp->peers->peer, i = 0; peer; peer = peer->next, i++) { n = i / (8 * sizeof(uintptr_t)); m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t)); /* 检查该后端服务器在位图中对应的位,为1时表示不可用 */ if (rrp->tried[n] & m) continue; /* 永久不可用的标志 */ if (peer->down) continue; /* 在一段时间内,如果此后端服务器的失败次数,超过了允许的最大值,那么不允许使用此后端了 */ if (peer->max_fails && peer->fails >= peer->max_fails && now - peer->checked <= peer->fail_timeout) continue; peer->current_weight += peer->effective_weight; /* 对每个后端,增加其当前权重 */ total += peer->effective_weight; /* 累加所有后端的有效权重 */ /* 如果之前此后端发生了失败,会减小其effective_weight来降低它的权重。 * 此后在选取后端的过程中,又通过增加其effective_weight来恢复它的权重。 */ if (peer->effective_weight < peer->weight) peer->effective_weight++; /* 选取当前权重最大者,作为本次选定的后端 */ if (best == NULL || peer->current_weight > best->current_weight) { best = peer; p = i; } } if (best == NULL) /* 没有可用的后端 */ return NULL; rrp->current = best; /* 保存本次选定的后端 */ n = p / (8 * sizeof(uintptr_t)); m = (uintptr_t) 1 << p % (8 * sizeof(uintptr_t)); /* 对于本次请求,如果之后需要再次选取后端,不能再选取这个后端了 */ rrp->tried[n] |= m; best->current_weight -= total; /* 选定后端后,需要降低其当前权重 */ /* 更新checked时间 */ if (now - best->checked > best->fail_timeout) best->checked = now; return best; } ~~~ **释放一台后端服务器**   当不再使用一台后端时,需要进行收尾处理,比如统计失败的次数。 这时候会调用第三步中r->upstream->peer.get指向的函数。函数参数state的取值: 0,请求被成功处理 NGX_PEER_FAILED,连接失败 NGX_PEER_NEXT,连接失败,或者连接成功但后端未能成功处理请求   一个请求允许尝试的后端数为pc->tries,在第三步中指定。当state为后两个值时: 如果pc->tries不为0,需要重新选取一个后端,继续尝试,此后会重复调用r->upstream->peer.get。 如果pc->tries为0,便不再尝试,给客户端返回502错误码(Bad Gateway)。 ~~~ void ngx_http_upstream_free_round_robin_peer(ngx_peer_connection_t *pc, void *data, ngx_uint_t state) { ngx_http_upstream_rr_peer_data_t *rrp = data; /* 请求的负载均衡数据 */ time_t now; ngx_http_upstream_rr_peer_t *peer; ... peer = rrp->current; /* 当前使用的后端服务器 */ if (rrp->peers->single) { peer->conns--; /* 减少后端的当前连接数 */ pc->tries = 0; /* 不能再继续尝试了 */ return; } /* 如果连接后端失败了 */ if (state & NGX_PEER_FAILED) { now = ngx_time(); peer->fails++; /* 一段时间内,已经失败的次数 */ peer->accessed = now; /* 最近一次失败的时间点 */ peer->checked = now; /* 用于检查是否超过了“一段时间” */ /* 当后端出错时,降低其有效权重 */ if (peer->max_fails) peer->effective_weight -= peer->weight / peer->max_fails; /* 有效权重的最小值为0 */ if (peer->effective_weight < 0) peer->effective_weight = 0; } else { /* mark peer live if check passed */ /* 说明距离最后一次失败的时间点,已超过fail_timeout了,清零fails */ if (peer->accessed < peer->checked) peer->fails = 0; } peer->conns--; /* 更新后端的当前连接数 */ if (pc->tries) pc->tries--; /* 对于一个请求,允许尝试的后端个数 */ } ~~~   **判断后端是否可用**   **相关的变量的定义** ngx_uint_t fails; /* 一段时间内,已经失败的次数 */ time_t accessed; /* 最近一次失败的时间点 */ time_t checked; /* 用于检查是否超过了“一段时间” */ ngx_uint_t max_fails; /* 一段时间内,允许的最大的失败次数,固定值 */ time_t fail_timeout; /* “一段时间”的长度,固定值 */ ~~~ ngx_http_upstream_get_peeer /* 在一段时间内,如果此后端服务器的失败次数,超过了允许的最大值, * 那么在此后的一段时间内不允许使用此后端了。 */ if (peer->max_fails && peer->fails >= peer->max_fails && now - peer->checked <= peer->fail_timeout) continue; ... /* 选定本后端了 */ if (now - best->checked > best->fail_timeout) best->checked = now; ~~~ ~~~ ngx_http_upstream_free_round_robin_peer if (state & NGX_PEER_FAILED) { peer->fails++; peer->accessed = now; peer->checked = now; ... } else if (peer->accessed < peer->checked) peer->fails = 0; ~~~ 相关变量的更新 accessed:释放peer时,如果发现后端出错了,则更新为now。 checked:释放peer时,如果发现后端出错了,则更新为now。选定该peer时,如果now - checked > fail_timeout,则更新为now。 fails:释放peer时,如果本次成功了且accessed < checked,说明距离最后一次失败的时间点,已超过fail_timeout了,清零fails。   **上述变量的准备定义** fails并不是“一段时间内”的失败次数,而是两两间时间间隔小于“一段时间”的连续失败次数。 max_fails也不是“一段时间内”允许的最大失败次数,而是两两间的时间间隔小于“一段时间”的最大失败次数。 举例说明,假设fail_timeout为10s,max_fails为3。 10s内失败3次,肯定会导致接下来的10s不可用。 27s内失败3次,也可能导致接下来的10s不可用,只要3次失败两两之间的时间间隔为9s。   下图用来简要说明    ![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2016-03-22_56f0c8a54d085.jpg)    
';