nginx upstream ip-hash负载均衡的实现(请求IP hash)

nginx 请求ip hash负载均衡
  ip hash简单的原理就是根据请求端的IP来生成跟IP信息相关的hash值；对于不同的请求端，由于请求IP不会相同，因此生成的hash值也会不同。
  以下是ngx_http_upstream_ip_hash_module的主要结构。

typedef struct {
    /* the round robin data must be first */

    //轮询负载的数据
    ngx_http_upstream_rr_peer_data_t   rrp;
    //计算得到的hash值
    ngx_uint_t                         hash;
   //请求IP地址的长度(这里包含了ipv4和ipv6)
    u_char                             addrlen;
    //请求地址
    u_char                            *addr;
    //尝试的次数
    u_char                             tries;
    //默认的获取upstream server的函数指针
    ngx_event_get_peer_pt              get_rr_peer;
} ngx_http_upstream_ip_hash_peer_data_t

ip hash的处理流程
1.ip hash处理配置初始化

static char *
ngx_http_upstream_ip_hash(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
    ngx_http_upstream_srv_conf_t  *uscf;
    //得到upstream server的配置信息
    uscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);

    if (uscf->peer.init_upstream) {
     /*这里判断初始化指针已经被设置过了*/
        ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
                           "load balancing method redefined");
    }
   /*设置配置upstream server 的初始化函数*/
    uscf->peer.init_upstream = ngx_http_upstream_init_ip_hash;
   /*
   设置判断的标志位信息
   */
    uscf->flags = NGX_HTTP_UPSTREAM_CREATE
                  |NGX_HTTP_UPSTREAM_WEIGHT
                  |NGX_HTTP_UPSTREAM_MAX_CONNS
                  |NGX_HTTP_UPSTREAM_MAX_FAILS
                  |NGX_HTTP_UPSTREAM_FAIL_TIMEOUT
                  |NGX_HTTP_UPSTREAM_DOWN;

    return NGX_CONF_OK;
}

static ngx_int_t
ngx_http_upstream_init_ip_hash(ngx_conf_t *cf, ngx_http_upstream_srv_conf_t *us)
{
    //设置配置的upstream server配置的信息（权重 最大连接数等等）
    if (ngx_http_upstream_init_round_robin(cf, us) != NGX_OK) {
        return NGX_ERROR;
    }
    /*
    设置upstream server连接动作发生前的初始化函数指针
    */
    us->peer.init = ngx_http_upstream_init_ip_hash_peer;

    return NGX_OK;
}

2.根据配置的信息 初始化在upstream server连接动作发生前的信息

static ngx_int_t
ngx_http_upstream_init_ip_hash_peer(ngx_http_request_t *r,
    ngx_http_upstream_srv_conf_t *us)
{
    ...
    /*为ip hash 结构分配内存*/
    iphp = ngx_palloc(r->pool, sizeof(ngx_http_upstream_ip_hash_peer_data_t));
    if (iphp == NULL) {
        return NGX_ERROR;
    }
    /*
    设置upstream server的配置信息 这里传递的是指针
    */
    r->upstream->peer.data = &iphp->rrp;
    /*根据ip hash配置的信息对upstream server集合进行初始化*/
    if (ngx_http_upstream_init_round_robin_peer(r, us) != NGX_OK) {
        return NGX_ERROR;
    }
/*将获取upstream server的方法设置为ip hash的方式获取*/
    r->upstream->peer.get = ngx_http_upstream_get_ip_hash_peer;

    switch (r->connection->sockaddr->sa_family) {
/*根据 sa_family族信息判断请求端的ip是ipv4还是ipv6的*/
    case AF_INET:
       /*设置ipv4的ip信息*/
        sin = (struct sockaddr_in *) r->connection->sockaddr;
        iphp->addr = (u_char *) &sin->sin_addr.s_addr;
        iphp->addrlen = 3;
        break;

#if (NGX_HAVE_INET6)
    /*设置ipv6的ip信息*/
    case AF_INET6:
        sin6 = (struct sockaddr_in6 *) r->connection->sockaddr;
        iphp->addr = (u_char *) &sin6->sin6_addr.s6_addr;
        iphp->addrlen = 16;
        break;
#endif

    default:
        /*默认的是一个空的地址*/
        iphp->addr = ngx_http_upstream_ip_hash_pseudo_addr;
        iphp->addrlen = 3;
    }
/*设置初始的ip为89*/
    iphp->hash = 89;
    iphp->tries = 0;
    //这里设置默认获取upstream server的方式为轮询获取
    iphp->get_rr_peer = ngx_http_upstream_get_round_robin_peer;

    return NGX_OK;
}

3.根据请求端的ip信息来建立hash规则获取upstream server

static ngx_int_t
ngx_http_upstream_get_ip_hash_peer(ngx_peer_connection_t *pc, void *data)
{
    ngx_http_upstream_ip_hash_peer_data_t  *iphp = data;
    ...
    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
                   "get ip hash peer, try: %ui", pc->tries);

    /* TODO: cached */
    /*设置upstream server集合的写锁*/
    ngx_http_upstream_rr_peers_wlock(iphp->rrp.peers);
    /*尝试的次数超过了20次或者只有一个uostream server*/
    if (iphp->tries > 20 || iphp->rrp.peers->single) {
        ngx_http_upstream_rr_peers_unlock(iphp->rrp.peers);
        //这里使用默认的轮询方式获取upstream server
        return iphp->get_rr_peer(pc, &iphp->rrp);
    }

    now = ngx_time();

    pc->cached = 0;
    pc->connection = NULL;
    //这里是初始设置的hash值 应该是89 可称作种子hash
    hash = iphp->hash;

    for ( ;; ) {

        for (i = 0; i < (ngx_uint_t) iphp->addrlen; i++) {
        /*根据ip信息 及种子hash计算得到hash值*/
            hash = (hash * 113 + iphp->addr[i]) % 6271;
        }
        //由计算得到的hash值与upstream server集合区约数得到权重
        w = hash % iphp->rrp.peers->total_weight;
        //这里是第一个upstream server
        peer = iphp->rrp.peers->peer;
        p = 0;

        while (w >= peer->weight) {
        /*计算得到的权重不得超过配置的权重值
         超过了就会使用下一个upstream server*/
            w -= peer->weight;
            peer = peer->next;
            p++;
        }

        /*
        这里取得upstream server是否有使用过的信息
        */
        n = p / (8 * sizeof(uintptr_t));
        m = (uintptr_t) 1 << p % (8 * sizeof(uintptr_t));

        if (iphp->rrp.tried[n] & m) {
          //使用过 会尝试下一个upstream server
            goto next;
        }

        ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
                       "get ip hash peer, hash: %ui %04XL", p, (uint64_t) m);

        if (peer->down) {
        //upstream 标记为下线 不使用
            goto next;
        }

        if (peer->max_fails
            && peer->fails >= peer->max_fails
            && now - peer->checked <= peer->fail_timeout)
        { /*
           upstream server连接失败次数超过了设置的阈值 选择下一个
          */
            goto next;
        }

        if (peer->max_conns && peer->conns >= peer->max_conns) {
        /*
         超过了配置的最大连接数 选择下一个
        */
            goto next;
        }

        break;

    next:

        if (++iphp->tries > 20) {
        /*尝试的次数超过了20次 释放锁 选择使用默认的轮询方式取得upstream server*/
            ngx_http_upstream_rr_peers_unlock(iphp->rrp.peers);
            return iphp->get_rr_peer(pc, &iphp->rrp);
        }
    }
    //将计算得到的upstream server设置成当前的 连接动作会使用这个upstream server作为连接的目标
    iphp->rrp.current = peer;
    //设置连接套接字的地址信息
    pc->sockaddr = peer->sockaddr;
    pc->socklen = peer->socklen;
    pc->name = &peer->name;
    //增加一个uostream server的连接次数
    peer->conns++;

    if (now - peer->checked > peer->fail_timeout) {
    /*
    由于成功找到了 更新检查的时间
    */
        peer->checked = now;
    }
    //所需的操作完成 释放upstream server集合的锁
    ngx_http_upstream_rr_peers_unlock(iphp->rrp.peers);

    /*标记已经尝试过*/ 
    iphp->rrp.tried[n] |= m;
    //更新种子hash值
    iphp->hash = hash;

    return NGX_OK;
}

这里附加一个实现的随机方式负载均衡模块的github地址nginx 随机负载均衡