码迷，mamicode.com
首页 > 其他好文 > 详细

2016 -Nginx的负载均衡 - 一致性哈希 (Consistent Hash)

时间：2016-05-27 12:47:57      阅读：234      评论：0      收藏：0      [点我收藏+]

标签：

Nginx版本：1.9.1


算法介绍

 

当后端是缓存服务器时，经常使用一致性哈希算法来进行负载均衡。

使用一致性哈希的好处在于，增减集群的缓存服务器时，只有少量的缓存会失效，回源量较小。

在nginx+ats / haproxy+squid等CDN架构中，nginx/haproxy所使用的负载均衡算法便是一致性哈希。

 

我们举个例子来说明一致性哈希的好处。

假设后端集群包含三台缓存服务器，A、B、C。

请求r1、r2落在A上。

请求r3、r4落在B上。

请求r5、r6落在C上。

使用一致性哈希时，当缓存服务器B宕机时，r1/r2会仍然落在A上，r5/r6会仍然落在C上，

也就是说这两台服务器上的缓存都不会失效。r3/r4会被重新分配给A或者C，并产生回源。

使用其它算法，当缓存服务器B宕机时，r1/r2不再落在A上，r5/r6不再落在C上了。

也就是说A、B、C上的缓存都失效了，所有的请求都要回源。

 

这里不介绍一致性哈希算法的基本原理，如果不了解，先花个10分钟看下这篇文章：

http://www.codeproject.com/Articles/56138/Consistent-hashing

 

在分析模块代码之前，先来看下nginx所实现的一致性哈希算法。

 

1. 初始化upstream块

主要工作是创建和初始化真实节点、创建和初始化虚拟节点。

其中真实节点是使用round robin的方法创建的。

 

Q：总共有多少个虚拟节点，一个真实节点对应多少个虚拟节点？

累加真实节点的权重，算出总的权重值total_weight，虚拟节点的个数一般为total_weight * 160。

一个权重为weight的真实节点，对应的虚拟节点数为weight * 160。

 

Q：对于每一个真实节点，是如何创建其对应的虚拟节点的？

1. 真实节点的server成员是其server指令的第一个参数，首先把它解析为HOST和PORT。

    base_hash = crc32(HOST 0 PORT)

    一个真实节点对应weight * 160个虚拟节点，对于每个虚拟节点来说，base_hash都是一样的。

2. 为了使每个虚拟节点的hash值都不同，又引入了PREV_HASH，它是上一个虚拟节点的hash值。

    hash = crc32(base_hash PREV_HASH)

3. 虚拟节点的server成员，指向真实节点的server成员。如此一来，通过比较虚拟节点和真实节点的

   server成员是否相同，可以判断它们是否是相对应的。

 

创建和初始化好虚拟节点数组后，对其中的虚拟节点按照hash值进行排序，对于hash值相同的虚拟节点，只保留第一个。

经过上述步骤，我们得到一个所有虚拟节点组成的数组，其元素的hash值有序而不重复。也就是说，ring建立起来了。

 

2. 初始话请求的负载均衡数据

根据hash指令第一个参数的实时值KEY，KEY一般是$host$uri之类的，计算出本次请求的哈希值。

hash = crc32(KEY)

根据请求的哈希值，在虚拟节点数组中，找到“顺时针方向”最近的一个虚拟节点，其索引为i。

什么叫顺时针方向最近？就是point[i - 1].hash < hash <= point[i].hash。

本次请求就落在该虚拟节点上了，之后交由其对应的真实节点来处理。

 

3. 选取真实节点

在peer.init中，已经知道请求落在哪个虚拟节点上了。

在peer.get中，需要查找虚拟节点对应的真实节点。

根据虚拟节点的server成员，在真实节点数组中查找server成员相同的、可用的真实节点。

如果找不到，那么沿着顺时针方向，继续查找下一个虚拟节点对应的真实节点。

如果找到了一个，那么就是它了。

如果找到了多个，使用轮询的方法从中选取一个。

 

4. 缺陷和改进

一个虚拟节点和一个真实节点，是依据它们的server成员来关联的。

这会出现一种情况，一个虚拟节点对应了多个真实节点，因为：

如果server指令的第一个参数为域名，可能解析为多个真实节点，那么这些真实节点的server成员都是一样的。

对于一个请求，计算其KEY的hash值，顺时针找到最近的虚拟节点后，发现该虚拟节点对应了多个真实节点。

使用哪个真实节点呢？本模块就使用轮询的方法，来从多个真实节点中选一个。

但我们知道使用一致性哈希的场景中，真实节点一般是缓存服务器。

一个虚拟节点对应多个真实节点，会导致一个文件被缓存在多个缓存服务器上。

这会增加磁盘的使用量，以及回源量，显然不是我们希望看到的。

 

解决这个问题的方法其实很简单，就是虚拟节点和真实节点通过name成员来建立关联。

因为就算对应同一条server配置，server的第一个参数为域名，各个真实节点的name成员也是唯一的。

这样一来，找到了一个虚拟节点，就能找到一个唯一的真实节点，不会有上述问题了。

 

数据结构

 

1. 真实节点

就是采用round robin算法所创建的后端服务器，类型为ngx_http_upstream_rr_peer_t。

需要注意的是，如果server指令的第一个参数是IP和端口，那么一条server指令只对应一个真实节点。

如果server指令的第一个参数是域名，一条server指令可能对应多个真实节点。

它们的server成员是相同的，可以通过name成员区分。

[java] view plain copy
  1. struct ngx_http_upstream_rr_peer_s {  
  2.     struct sockaddr *sockaddr; /* 后端服务器的地址 */  
  3.     socklen_t socklen; /* 地址的长度*/  
  4.     ngx_str_t name; /* 后端服务器地址的字符串，server.addrs[i].name */  
  5.     ngx_str_t server; /* server的名称，server.name */  
  6.        
  7.     ngx_int_t current_weight; /* 当前的权重，动态调整，初始值为0 */  
  8.     ngx_int_t effective_weight; /* 有效的权重，会因为失败而降低 */  
  9.     ngx_int_t weight; /* 配置项指定的权重，固定值 */  
  10.   
  11.     ngx_uint_t conns; /* 当前连接数 */  
  12.   
  13.     ngx_uint_t fails; /* "一段时间内"，已经失败的次数 */  
  14.     time_t accessed; /* 最近一次失败的时间点 */  
  15.     time_t checked; /* 用于检查是否超过了"一段时间" */  
  16.   
  17.     ngx_uint_t max_fails; /* "一段时间内"，最大的失败次数，固定值 */  
  18.     time_t fail_timeout; /* "一段时间"的值，固定值 */  
  19.     ngx_uint_t down; /* 服务器永久不可用的标志 */  
  20.     ...  
  21.     ngx_http_upstream_rr_peer_t *next; /* 指向下一个后端，用于构成链表 */  
  22.     ...  
  23. } ngx_http_upstream_rr_peer_t;  

ngx_http_upstream_rr_peers_t表示一组后端服务器，比如一个后端集群。

[java] view plain copy
  1. struct ngx_http_upstream_rr_peers_s {  
  2.     ngx_uint_t number; /* 后端服务器的数量 */  
  3.     ...  
  4.     ngx_uint_t total_weight; /* 所有后端服务器权重的累加值 */  
  5.   
  6.     unsigned single:1; /* 是否只有一台后端服务器 */  
  7.     unsigned weighted:1; /* 是否使用权重 */  
  8.   
  9.     ngx_str_t *name; /* upstream配置块的名称 */  
  10.   
  11.     ngx_http_upstream_rr_peers_t *next; /* backup服务器集群 */  
  12.     ngx_http_upstream_rr_peer_t *peer; /* 后端服务器组成的链表 */  
  13. };  

 

2. 虚拟节点

一个真实节点，一般会对应weight * 160个虚拟节点。

虚拟节点的server成员，指向它所归属的真实节点的server成员，如此一来找到了一个虚拟节点后，

就能找到其归属的真实节点。

但这里有一个问题，通过一个虚拟节点的server成员，可能会找到多个真实节点，而不是一个。

因为如果server指令的第一个参数为域名，那么多个真实节点的server成员都是一样的。

[java] view plain copy
  1. typedef struct {  
  2.     uint32_t hash; /* 虚拟节点的哈希值 */  
  3.     ngx_str_t *server; /* 虚拟节点归属的真实节点，对应真实节点的server成员 */  
  4. } ngx_http_upstream_chash_point_t;  
  5.   
  6. typedef struct {  
  7.     ngx_uint_t number; /* 虚拟节点的个数 */  
  8.     ngx_http_upstream_chash_point_t point[1]; /* 虚拟节点的数组 */  
  9. } ngx_http_upstream_chash_points_t;  
  10.   
  11. typedef struct {  
  12.     ngx_http_complex_value_t key; /* 关联hash指令的第一个参数，用于计算请求的hash值 */  
  13.     ngx_http_upstream_chash_points_t *points; /* 虚拟节点的数组 */  
  14. } ngx_http_upstream_chash_points_t;  

 

3. 请求的一致性哈希数据

[java] view plain copy
  1. typedef struct {  
  2.     /* the round robin data must be first */  
  3.     ngx_http_upstream_rr_peer_data_t rrp; /* round robin的per request负载均衡数据 */  
  4.     ngx_http_upstream_hash_srv_conf_t *conf; /* server配置块 */  
  5.     ngx_str_t key; /* 对于本次请求，hash指令的第一个参数的具体值，用于计算本次请求的哈希值 */  
  6.     ngx_uint_t tries; /* 已经尝试的虚拟节点数 */  
  7.     ngx_uint_t rehash; /* 本算法不使用此成员 */  
  8.     uint32_t hash; /* 根据请求的哈希值，找到顺时方向最近的一个虚拟节点，hash为该虚拟节点在数组中的索引 */  
  9.     ngx_event_get_peer_pt get_rr_peer; /* round robin算法的peer.get函数 */  
  10. } ngx_http_upstream_hash_peer_data_t;  

round robin的per request负载均衡数据。

[java] view plain copy
  1. typedef struct {  
  2.      ngx_http_upstream_rr_peers_t *peers; /* 后端集群 */  
  3.      ngx_http_upstream_rr_peer_t *current; /* 当前使用的后端服务器 */  
  4.      uintptr_t *tried; /* 指向后端服务器的位图 */  
  5.      uintptr_t data; /* 当后端服务器的数量较少时，用于存放其位图 */  
  6. } ngx_http_upstream_rr_peer_data_t;  

 

指令的解析函数

 

在一个upstream配置块中，如果有hash指令，且它只带一个参数，则使用的负载均衡算法为哈希算法，比如：

hash $host$uri;

在一个upstream配置块中，如果有hash指令，且它带了两个参数，且第二个参数为consistent，则使用的

负载均衡算法为一致性哈希算法，比如：

hash $host$uri consistent;

 

这说明hash指令所属的模块ngx_http_upstream_hash_module同时实现了两种负载均衡算法，而实际上

哈希算法、一致性哈希算法完全可以用两个独立的模块来实现，它们本身并没有多少关联。

哈希算法的实现比较简单，类似之前分析过的ip_hash，接下来分析的是一致性哈希算法。

 

hash指令的解析函数主要做了：

把hash指令的第一个参数，关联到一个ngx_http_complex_value_t变量，之后可以通过该变量获取参数的实时值。

指定此upstream块中server指令支持的属性。

根据hash指令携带的参数来判断是使用哈希算法，还是一致性哈希算法。如果hash指令的第二个参数为"consistent"，

则表示使用一致性哈希算法，指定upstream块的初始化函数uscf->peer.init_upstream。

[java] view plain copy
  1. static char *ngx_http_upstream_hash(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)  
  2. {  
  3.     ngx_http_upstream_hash_srv_conf_t *hcf = conf;  
  4.     ngx_str_t *value;  
  5.     ngx_http_upstream_srv_conf_t *uscf;  
  6.     ngx_http_compile_complex_value_t ccv;  
  7.   
  8.     value = cf->args->elts;  
  9.     ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));  
  10.   
  11.     /* 把hash指令的第一个参数，关联到一个ngx_http_complex_value_t变量， 
  12.      * 之后可以通过该变量获取参数的实时值。 
  13.      */  
  14.     ccv.cf = conf;  
  15.     ccv.value = &value[1];  
  16.     ccv.complex_value = &hcf->key;  
  17.   
  18.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK)  
  19.         return NGX_CONF_ERROR;  
  20.   
  21.     /* 获取所在的upstream{}块 */  
  22.     uscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);  
  23.     if (uscf->peer.init_upstream)  
  24.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0, "load balancing method redefined");  
  25.   
  26.     /* 指定此upstream块中server指令支持的属性 */  
  27.     uscf->flags = NGX_HTTP_UPSTREAM_CREATE  
  28.         | NGX_HTTP_UPSTREAM_WEIGHT  
  29.         | NGX_HTTP_UPSTREAM_MAX_FAILS  
  30.         | NGX_HTTP_UPSTREAM_FAIL_TIMEOUT  
  31.         | NGX_HTTP_UPSTREAM_DOWN;  
  32.   
  33.     /* 根据hash指令携带的参数来判断是使用哈希算法，还是一致性哈希算法。 
  34.      * 每种算法都有自己的upstream块初始化函数。 
  35.       */  
  36.     if (cf->args->nelts == 2)  
  37.         uscf->peer.init_upstream = ngx_http_upstream_init_hash;  
  38.     else if (ngx_strcmp(value[2].data, "consistent") == 0)  
  39.         uscf->peer.init_upstream = ngx_http_upstream_init_chash;  
  40.     else  
  41.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid parameter \"%V\"", &value[2]);  
  42.   
  43.     return NGX_CONF_OK;  
  44. }  

 

初始化upstream块

 

执行完指令的解析函数后，紧接着会调用所有HTTP模块的init main conf函数。

在执行ngx_http_upstream_module的init main conf函数时，会调用所有upstream块的初始化函数。

对于使用一致性哈希的upstream块，其初始化函数（peer.init_upstream）就是上一步中指定

ngx_http_upstream_init_chash，它主要做了：

调用round robin的upstream块初始化函数来创建和初始化真实节点

指定per request的负载均衡初始化函数peer.init

创建和初始化虚拟节点数组，使该数组中的虚拟节点有序而不重复

[java] view plain copy
  1. static ngx_int_t ngx_http_upstream_init_chash(ngx_conf_t *cf, ngx_http_upstream_srv_conf_t *us)  
  2. {  
  3.     u_char *host, *port, c;  
  4.     size_t host_len, port_len, size;  
  5.     uint32_t hash, base_hash;  
  6.     ngx_str_t *server;  
  7.     ngx_uint_t npoints, i, j;  
  8.     ngx_http_upstream_rr_peer_t *peer;  
  9.     ngx_http_upstream_rr_peers_t *peers;  
  10.     ngx_http_upstream_chash_points_t *points;  
  11.     ngx_http_upstream_hash_srv_conf_t *hcf;  
  12.     union {  
  13.         uint32_t value;  
  14.         u_char byte[4];  
  15.     } prev_hash;  
  16.   
  17.     /* 使用round robin的upstream块初始化函数，创建和初始化真实节点 */  
  18.     if (ngx_http_upstream_init_round_robin(cf, us) != NGX_OK)  
  19.         return NGX_ERROR:  
  20.   
  21.     /* 重新设置per request的负载均衡初始化函数 */  
  22.     us->peer.init = ngx_http_upstream_init_chash_peer;  
  23.   
  24.     peers = us->peer.data; /* 真实节点的集群 */  
  25.     npoints = peers->total_weight * 160;  
  26.   
  27.     /* 一共创建npoints个虚拟节点 */  
  28.     size = sizeof(ngx_http_upstream_chash_points_t) +   
  29.         sizeof(ngx_http_upstream_chash_point_t) * (npoints - 1);  
  30.   
  31.     points = ngx_palloc(cf->pool, size);  
  32.     if (points == NULL)  
  33.         return NGX_ERROR;  
  34.   
  35.     points->number = 0;  
  36.   
  37.     /* 初始化所有的虚拟节点 */  
  38.     for (peer = peers->peer; peer; peer = peer->next) {  
  39.         server = &peer->server; /* server指令的第一个参数, server.name */  
  40.           
  41.         /* Hash expression is compatible with Cache::Memcached::Fast: 
  42.          * crc32(HOST 0 PORT PREV_HASH). 
  43.          */  
  44.         if (server->len >= 5 && ngx_strncasecmp(server->data, (u_char *) "unix:", 5) == 0)  
  45.         {  
  46.             host = server->data + 5;  
  47.             host_len = server->len - 5;  
  48.             port = NULL;  
  49.             port_len = 0;  
  50.             goto done;  
  51.         }  
  52.   
  53.         /* 把每个peer的server成员，解析为HOST和PORT */  
  54.         for (j = 0; j < server->len; j++) {  
  55.             c = server->data[server->len - j - 1];  
  56.   
  57.             if (c == ":") {  
  58.                 host = server->data;  
  59.                 host_len = server->len - j - 1;  
  60.                 port = server->data + server->len - j;  
  61.                 port_len = j;  
  62.                 goto done;  
  63.             }  
  64.   
  65.             if (c < ‘0‘ || c > ‘9‘) /* 表示没有指定端口 */  
  66.                 break;  
  67.         }  
  68.   
  69.         host = server->data;  
  70.         host_len = server->len;  
  71.         port = NULL;  
  72.         port_len = 0;  
  73.   
  74.    done:  
  75.         /* 根据解析peer的server成员所得的HOST和PORT，计算虚拟节点的base_hash值 */  
  76.         ngx_crc32_init(base_hash);  
  77.         ngx_crc32_update(&base_hash, host, host_len);  
  78.         ngx_crc32_update(&base_hash, (u_char *) "", 1); /* 空字符串包含字符\0 */  
  79.         ngx_crc32_update(&base_hash, port, port_len);  
  80.           
  81.         /* 对于归属同一个真实节点的虚拟节点，它们的base_hash值相同，而prev_hash不同 */  
  82.         prev_hash.value = 0;  
  83.         npoints = peer->weight * 160;  
  84.   
  85.         for (j = 0; j < npoints; j++) {  
  86.             hash = base_hash;  
  87.             ngx_crc32_update(&hash, prev_hash.byte, 4);  
  88.             ngx_crc32_final(hash);  
  89.   
  90.             points->point[points->number].hash = hash; /* 虚拟节点的哈希值 */  
  91.             points->point[points->number].server = server; /* 虚拟节点所归属的真实节点，对应真实节点的server成员 */  
  92.             points->number++;  
  93.   
  94. #if (NGX_HAVE_LITTLE_ENDIAN)  
  95.            prev_hash.value = hash;  
  96. #else  
  97.            prev_hash.byte[0] = (u_char) (hash & 0xff);  
  98.            prev_hash.byte[1] = (u_char) ((hash >> 8) & 0xff);  
  99.            prev_hash.byte[2] = (u_char) ((hash >> 16) & 0xff);  
  100.            prev_hash.byte[3] = (u_char) ((hash >> 24) & 0xff);  
  101. #endif  
  102.         }     
  103.     }  
  104.   
  105.     /* 使用快速排序，使虚拟节点数组的元素，按照其hash值从小到大有序 */  
  106.     ngx_qsort(points->point, points->number, sizeof(ngx_http_upstream_chash_point_t),  
  107.         ngx_http_upstream_chash_cmp_points);  
  108.   
  109.     /* 如果虚拟节点数组中，有多个元素的hash值相同，只保留第一个 */  
  110.     for (i = 0, j = 1; j < points->number; j++)  
  111.         if (points->point[i].hash != points->point[j].hash)  
  112.             points->point[++i] = points->point[j];  
  113.   
  114.     /* 经过上述步骤后，虚拟节点数组中的元素，有序而不重复 */  
  115.     points->number = i + 1;  
  116.      
  117.     hcf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_hash_module);  
  118.     hcf->points = points; /* 保存虚拟节点数组 */  
  119.   
  120.     return NGX_OK;  
  121. }  
[java] view plain copy
  1. static int ngx_libc_cdel ngx_http_upstream_chash_cmp_points(const void *one, const void *two)  
  2. {  
  3.     ngx_http_upstream_chash_point_t *first = (ngx_http_upstream_chash_point_t *) one;  
  4.     ngx_http_upstream_chash_point_t *second = (ngx_http_upstream_chash_point_t *) two;  
  5.   
  6.     if (first->hash < second->hash)  
  7.         return -1;  
  8.     else if (first->hash > second->hash)  
  9.         return 1;  
  10.     else  
  11.         return 0;  
  12. }  

 

初始化请求的负载均衡数据 

 

收到一个请求后，一般使用的反向代理模块（upstream模块）为ngx_http_proxy_module，

其NGX_HTTP_CONTENT_PHASE阶段的处理函数为ngx_http_proxy_handler，在初始化upstream机制的

ngx_http_upstream_init_request函数中，调用在第二步中指定的peer.init，主要用于初始化请求的负载均衡数据。

对于一致性哈希，peer.init实例为ngx_http_upstream_init_chash_peer，主要做了：

首先调用hash算法的per request负载均衡初始化函数，创建和初始化请求的负载均衡数据。

重新指定peer.get，用于选取一个真实节点来处理本次请求。

获取的本请求对应的hash指令的第一个参数值，计算请求的hash值。

寻找第一个hash值大于等于请求的哈希值的虚拟节点，即寻找“顺时针方向最近”的一个虚拟节点。

[java] view plain copy
  1. static ngx_int_t ngx_http_upstream_init_chash_peer(ngx_http_request_t *r, ngx_http_upstream_srv_conf_t *us)  
  2. {  
  3.     uint32_t hash;  
  4.     ngx_http_upstream_hash_srv_conf_t *hcf;  
  5.     ngx_http_upstream_hash_peer_data_t *hp;  
  6.   
  7.     /* 调用hash算法的per request负载均衡初始化函数，创建和初始化请求的负载均衡数据 */  
  8.     if (ngx_http_upstream_init_hash_peer(r, us) != NGX_OK)  
  9.         return NGX_ERROR;  
  10.   
  11.     /* 重新指定peer.get，用于选取一个真实节点 */  
  12.     r->upstream->peer.get = ngx_http_upstream_get_chash_peer;  
  13.   
  14.     hp = r->upstream->peer.data;  
  15.     hcf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_hash_module);  
  16.   
  17.     /* 根据获取的本请求对应的hash指令的第一个参数值，计算请求的hash值 */  
  18.     hash = ngx_crc32_long(hp->key.data, hp->key.len);  
  19.   
  20.     /* 根据请求的hash值，找到顺时针方向最近的一个虚拟节点，hp->hash记录此虚拟节点 
  21.      * 在数组中的索引。 
  22.      */  
  23.     hp->hash = ngx_http_upstream_find_chash_point(hcf->points, hash);  
  24.   
  25.     return NGX_OK:  
  26. }  

hash算法的per request负载均衡初始化函数。

[java] view plain copy
  1. static ngx_int_t ngx_http_upstream_init_hash_peer(ngx_http_request_t *r, ngx_http_upstream_srv_conf_t *us)  
  2. {  
  3.     ngx_http_upstream_hash_srv_conf_t *hcf;  
  4.     ngx_http_upstream_hash_peer_data_t *hp;  
  5.   
  6.     hp = ngx_palloc(r->pool, sizeof(ngx_http_upstream_hash_peer_data_t));  
  7.     if (hp == NULL)  
  8.         return NGX_ERROR:  
  9.   
  10.     /* 调用round robin的per request负载均衡初始化函数 */  
  11.     r->upstream->peer.data = &hp->rrp;  
  12.     if (ngx_http_upstream_init_round_robin_peer(r, us) != NGX_OK)  
  13.         return NGX_ERROR;  
  14.   
  15.     r->upstream->peer.get = ngx_http_upstream_get_hash_peer;  
  16.     hcf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_hash_module);  
  17.   
  18.    /* 获取本请求对应的hash指令的第一个参数值，用于计算请求的hash值 */  
  19.     if (ngx_http_complex_value(r, &hcf->key, &hp->key) != NGX_OK)  
  20.         return NGX_ERROR;  
  21.     ...  
  22.     hp->conf = hcf;  
  23.     hp->tries = 0;  
  24.     hp->rehash = 0;  
  25.     hp->hash = 0;  
  26.     hp->get_rr_peer = ngx_http_upstream_get_round_robin_peer; /* round robin的peer.get函数 */  
  27.   
  28.     return NGX_OK;  
  29. }  

我们知道虚拟节点数组是有序的，事先已按照虚拟节点的hash值从小到大排序好了。

现在使用二分查找，寻找第一个hash值大于等于请求的哈希值的虚拟节点，即“顺时针方向最近”的一个虚拟节点。

[java] view plain copy
  1. static ngx_uint_t ngx_http_upstream_find_chash_point(ngx_http_upstream_chash_points_t *points, uint32_t hash)  
  2. {  
  3.     ngx_uint_t i, j, k;  
  4.     ngx_http_upstream_chash_point_t *point;  
  5.       
  6.     /* find first point >= hash */  
  7.   
  8.     point = &points->point[0];  
  9.     i = 0;  
  10.     j = points->number;‘  
  11.   
  12.     while(i < j) {  
  13.         k = (i + j) / 2;  
  14.   
  15.         if (hash > point[k].hash)  
  16.             i = k + 1;  
  17.         else if (hash < point[k].hash)  
  18.             j = k;  
  19.          else  
  20.             return k;  
  21.     }  
  22.   
  23.     return i;  
  24. }  

 

选取一个真实节点

 

一般upstream块中会有多个真实节点，那么对于本次请求，要选定哪一个真实节点呢？

对于一致性哈希算法，选取真实节点的peer.get函数为ngx_http_upstream_get_chash_peer。

 

其实在peer.init中，已经找到了该请求对应的虚拟节点了：

根据请求对应的hash指令的第一个参数值，计算请求的hash值。

寻找第一个哈希值大于等于请求的hash值的虚拟节点，即“顺时针方向最近”的一个虚拟节点。

 

在peer.get中，需查找此虚拟节点对应的真实节点。

根据虚拟节点的server成员，在真实节点数组中查找server成员一样的且可用的真实节点。

如果找不到，那么沿着顺时针方向，继续查找下一个虚拟节点对应的真实节点。

如果找到一个真实节点，那么就是它了。

如果找到多个真实节点，使用轮询的方法从中选取一个。

[java] view plain copy
  1. static ngx_http_upstream_get_chash_peer(ngx_peer_connection_t *pc, void *data)  
  2. {  
  3.     ngx_http_upstream_hash_peer_data_t *hp = data; /* 请求的负载均衡数据 */  
  4.     time_t now;  
  5.     intptr_t m;  
  6.     ngx_str_t *server;  
  7.     ngx_int_t total;  
  8.     ngx_uint_t i, n, best_i;  
  9.     ngx_http_upstream_rr_peer_t *peer, *best;  
  10.     ngx_http_upstream_chash_point_t *point;  
  11.     ngx_http_upstream_chash_points_t *points;  
  12.     ngx_http_upstream_hash_srv_conf_t *hcf;  
  13.     ...  
  14.     pc->cached = 0;  
  15.     pc->connection = NULL:  
  16.     now = ngx_time();  
  17.     hcf = hp->conf;  
  18.     points = hcf->points; /* 虚拟节点数组 */  
  19.     point = &points->point[0]; /* 指向第一个虚拟节点 */  
  20.   
  21.     for ( ; ; ) {  
  22.         /* 在peer.init中，已根据请求的哈希值，找到顺时针方向最近的一个虚拟节点， 
  23.          * hash为该虚拟节点在数组中的索引。 
  24.          * 一开始hash值肯定小于number，之后每尝试一个虚拟节点后，hash++。取模是为了防止越界访问。 
  25.          */  
  26.         server = point[hp->hash % points->number].server;  
  27.         best = NULL;  
  28.         best_i = 0;  
  29.         total = 0;  
  30.   
  31.         /* 遍历真实节点数组，寻找可用的、该虚拟节点归属的真实节点(server成员相同)， 
  32.           * 如果有多个真实节点同时符合条件，那么使用轮询来从中选取一个真实节点。 
  33.           */  
  34.         for (peer = hp->rrp.peers->peer, i = 0; peer; peer = peer->next, i++) {  
  35.             /* 检查此真实节点在状态位图中对应的位，为1时表示不可用 */  
  36.             n = i / (8 * sizeof(uintptr_t));  
  37.             m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));  
  38.             if (hp->rrp.tried[n] & m)  
  39.                 continue;              
  40.   
  41.             /* server指令中携带了down属性，表示后端永久不可用 */  
  42.             if (peer->down)  
  43.                 continue;  
  44.   
  45.             /* 如果真实节点的server成员和虚拟节点的不同，表示虚拟节点不属于此真实节点 */  
  46.             if (peer->server.len != server->len ||   
  47.                 ngx_strncmp(peer->server.data, server->data, server->len) != 0)  
  48.                 continue;  
  49.   
  50.            /* 在一段时间内，如果此真实节点的失败次数，超过了允许的最大值，那么不允许使用了 */  
  51.            if (peer->max_fails  
  52.                 && peer->fails >= peer->max_fails  
  53.                 && now - peer->checked <= peer->fail_timeout)  
  54.                 continue;  
  55.           
  56.             peer->current_weight += peer->effective_weight; /* 对每个真实节点，增加其当前权重 */  
  57.             total += peer->effective_weight; /* 累加所有真实节点的有效权重 */  
  58.   
  59.             /* 如果之前此真实节点发生了失败，会减小其effective_weight来降低它的权重。           
  60.              * 此后又通过增加其effective_weight来恢复它的权重。           
  61.              */          
  62.             if (peer->effective_weight < peer->weight)   
  63.                 peer->effective_weight++;  
  64.           
  65.             /* 选取当前权重最大者，作为本次选定的真实节点 */  
  66.             if (best == NULL || peer->current_weight > best->current_weight) {  
  67.                 best = peer;  
  68.                 best_i = i;  
  69.             }  
  70.         }  
  71.   
  72.         /* 如果选定了一个真实节点 */  
  73.         if (best) {  
  74.             best->current_weight -= total; /* 如果使用了轮询，需要降低选定节点的当前权重 */  
  75.             goto found;  
  76.         }  
  77.   
  78.         hp->hash++; /* 增加虚拟节点的索引，即“沿着顺时针方向” */  
  79.         hp->tries++; /* 已经尝试的虚拟节点数 */  
  80.   
  81.         /* 如果把所有的虚拟节点都尝试了一遍，还找不到可用的真实节点 */  
  82.         if (hp->tries >= points->number)  
  83.             return NGX_BUSY;  
  84.     }  
  85.   
  86. found: /* 找到了和虚拟节点相对应的、可用的真实节点了 */  
  87.     hp->rrp.current = best; /* 选定的真实节点 */  
  88.     /* 保存选定的后端服务器的地址，之后会向这个地址发起连接 */  
  89.     pc->sockaddr = peer->sockaddr;  
  90.     pc->socklen = peer->socklen;  
  91.     pc->name = &peer->name;  
  92.     best->conns++;  
  93.   
  94.     /* 更新checked时间 */  
  95.     if (now - best->checked > best->fail_timeout)  
  96.         best->checked = now;  
  97.   
  98.     n = best_i / (8 * sizeof(uintptr_t));  
  99.     m = (uintptr_t) 1 << best_i % (8 * sizeof(uintptr_t));  
  100.   
  101.     /* 对于本次请求，如果之后需要再次选取真实节点，不能再选取同一个了 */      
  102.     hp->rrp->tried[n] |= m;  
  103.   
  104.     return NGX_OK;  
  105. } 

2016 -Nginx的负载均衡 - 一致性哈希 (Consistent Hash)

标签：

原文地址：http://blog.csdn.net/qq_29572055/article/details/51482200
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！