nginx upstream ip - hash 부하 균형 실현 (IP hash 요청)

nginx 요청 ip hash 부하 균형 은 8195 ° ip hash 간단 한 원 리 는 요청 단의 IP 에 따라 IP 정보 와 관련 된 hash 값 을 생 성 하 는 것 입 니 다.요청 단 에 따라 요청 IP 가 같 지 않 기 때문에 생 성 된 hash 값 도 다 릅 니 다.    이하 ngxhttp_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 랜 덤 부하 균형 을 추가 합 니 다.