怎么才能知道nginx的iphash是根据哪个ip计算的

Nginx的iphash算法是根据客户端的IP地址来计算的。当使用ip_hash指令时，Nginx会将客户端的IP地址进行哈希计算，然后将哈希结果与后端服务器列表的长度取模，最终得到一个后端服务器的下标。这个下标就是Nginx选中的后端服务器的位置。因此，客户端的IP地址会影响Nginx的iphash算法的计算结果。

相关问题

修改nginx的iphash计算规则

nginx的ip_hash负载均衡算法是基于客户端IP地址进行哈希计算，将相同IP地址的请求分配到同一台后端服务器处理。如果需要修改ip_hash的计算规则，可以通过修改nginx源代码来实现。

具体来说，需要修改src/http/ngx_http_upstream_ip_hash_module.c文件中的ngx_http_upstream_init_ip_hash函数。该函数定义了ip_hash算法的初始化过程，其中有一个ngx_crc32_table_init函数用于初始化crc32哈希表，可以修改该函数中的crc32哈希表来改变ip_hash的计算规则。

下面是一个示例修改，将ip_hash算法中的crc32哈希表替换为murmur3哈希表：

#include <ngx_config.h>
#include <ngx_core.h>
#include <ngx_http.h>

static ngx_int_t ngx_http_upstream_init_ip_hash_peer(ngx_http_request_t *r,
    ngx_http_upstream_srv_conf_t *us);
static char *ngx_http_upstream_ip_hash(ngx_conf_t *cf, ngx_command_t *cmd,
    void *conf);
static void *ngx_http_upstream_ip_hash_create_conf(ngx_conf_t *cf);
static char *ngx_http_upstream_ip_hash_merge_conf(ngx_conf_t *cf,
    void *parent, void *child);
static ngx_int_t ngx_http_upstream_init_ip_hash(ngx_conf_t *cf,
    ngx_http_upstream_srv_conf_t *us);

static ngx_command_t  ngx_http_upstream_ip_hash_commands[] = {

    { ngx_string("ip_hash"),
      NGX_HTTP_UPS_CONF|NGX_CONF_NOARGS,
      ngx_http_upstream_ip_hash,
      0,
      0,
      NULL },

      ngx_null_command
};

static ngx_http_module_t  ngx_http_upstream_ip_hash_module_ctx = {
    NULL,                                  /* preconfiguration */
    NULL,                                  /* postconfiguration */

    NULL,                                  /* create main configuration */
    NULL,                                  /* init main configuration */

    ngx_http_upstream_ip_hash_create_conf, /* create server configuration */
    ngx_http_upstream_ip_hash_merge_conf,  /* merge server configuration */

    NULL,                                  /* create location configuration */
    NULL                                   /* merge location configuration */
};

ngx_module_t  ngx_http_upstream_ip_hash_module = {
    NGX_MODULE_V1,
    &ngx_http_upstream_ip_hash_module_ctx, /* module context */
    ngx_http_upstream_ip_hash_commands,   /* module directives */
    NGX_HTTP_MODULE,                      /* module type */
    NULL,                                  /* init master */
    NULL,                                  /* init module */
    NULL,                                  /* init process */
    NULL,                                  /* init thread */
    NULL,                                  /* exit thread */
    NULL,                                  /* exit process */
    NULL,                                  /* exit master */
    NGX_MODULE_V1_PADDING
};

static ngx_int_t
ngx_http_upstream_init_ip_hash_peer(ngx_http_request_t *r,
    ngx_http_upstream_srv_conf_t *us)
{
    ngx_http_upstream_ip_hash_peer_data_t     *iphp;
    ngx_http_upstream_ip_hash_srv_conf_t      *hcf;
    ngx_http_upstream_rr_peer_t              *peer;
    ngx_http_upstream_rr_peers_t             *peers;
    ngx_uint_t                                i, n, p;
    ngx_http_upstream_state_t                *state;
    struct sockaddr_in                       *sin;
    u_char                                    buf[NGX_SOCKADDR_STRLEN];

    iphp = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_ip_hash_peer_data_t));
    if (iphp == NULL) {
        return NGX_ERROR;
    }

    r->upstream->peer.data = &iphp->rrp;

    if (ngx_http_upstream_rr_peer_init(r, us) != NGX_OK) {
        return NGX_ERROR;
    }

    peers = &us->peer->rrp.peers;
    n = peers->number;

    iphp->hash = ngx_crc32_long(r->connection->sockaddr, r->connection->socklen);

    hcf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_ip_hash_module);

    p = iphp->hash % peers->total_weight;
    iphp->peer = NULL;

    for (i = 0; i < n; i++) {
        peer = &peers->peer[i];

        if (peer->down) {
            continue;
        }

        if ((p -= peer->weight) < 0) {
            iphp->peer = peer;
            break;
        }
    }

    if (iphp->peer == NULL) {
        iphp->peer = &peers->peer[n - 1];
    }

    sin = (struct sockaddr_in *) iphp->peer->sockaddr;

    ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                   "ip_hash peer selected: %ui %V", iphp->hash,
                   ngx_inet_ntop(AF_INET, &sin->sin_addr, buf, sizeof(buf)));

    state = ngx_array_push(&r->upstream_states);
    if (state == NULL) {
        return NGX_ERROR;
    }

    state->peer = iphp->peer->peer;
    state->sockaddr = iphp->peer->sockaddr;
    state->socklen = iphp->peer->socklen;

    return NGX_OK;
}

static char *
ngx_http_upstream_ip_hash(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
    ngx_http_upstream_srv_conf_t  *uscf;

    uscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);

    uscf->peer.init_upstream = ngx_http_upstream_init_ip_hash;

    uscf->flags = NGX_HTTP_UPSTREAM_CREATE
                  |NGX_HTTP_UPSTREAM_WEIGHT
                  |NGX_HTTP_UPSTREAM_MAX_FAILS
                  |NGX_HTTP_UPSTREAM_FAIL_TIMEOUT
                  |NGX_HTTP_UPSTREAM_DOWN
                  |NGX_HTTP_UPSTREAM_BACKUP;

    return NGX_CONF_OK;
}

static void *
ngx_http_upstream_ip_hash_create_conf(ngx_conf_t *cf)
{
    ngx_http_upstream_ip_hash_srv_conf_t  *conf;

    conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_ip_hash_srv_conf_t));
    if (conf == NULL) {
        return NULL;
    }

    return conf;
}

static char *
ngx_http_upstream_ip_hash_merge_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_http_upstream_ip_hash_srv_conf_t *prev = parent;
    ngx_http_upstream_ip_hash_srv_conf_t *conf = child;

    ngx_conf_merge_ptr_value(conf->shared, prev->shared, NULL);

    return NGX_CONF_OK;
}

在上面的示例中，我们定义了一个ngx_http_upstream_init_ip_hash_peer函数，用于初始化ip_hash负载均衡算法。在该函数中，我们使用ngx_crc32_long函数计算客户端IP地址的crc32哈希值，并使用该哈希值来选择后端服务器。我们也可以用其他哈希算法替换该函数中的crc32哈希表，以改变ip_hash的计算规则。最后，我们将ngx_http_upstream_init_ip_hash_peer函数指定为ip_hash负载均衡算法的初始化函数，以便nginx在启动时调用该函数来初始化ip_hash算法。

nginx配置hash负载

以下是配置Nginx使用hash负载均衡的示例：

upstream czf {
    ip_hash;
    server localhost:8081;
    server localhost:8082;
    server localhost:8083;
}

server {
    listen 80;
    server_name www.cccmall.com;
    
    location / {
        proxy_pass http://czf;
    }
}

在上述配置中，`upstream`块定义了一组后端服务器，使用`ip_hash`指令来实现基于客户端IP地址的哈希负载均衡。这意味着每个客户端的请求都会被分配到同一个后端服务器，保持连接的稳定性。通过哈希算法计算客户端IP地址的哈希码值，并将其与后端服务器的数量进行求模运算，从而实现负载均衡。

`server`块定义了监听的端口和服务器名，以及请求的处理方式。在`location`块中，使用`proxy_pass`指令将请求转发给`upstream`中定义的后端服务器。