Nginx 負載均衡-加權輪詢策略剖析

本文介紹的是客戶端請求在多個后端服務器之間的均衡，注意與客戶端請求在多個nginx進程之間的均衡相區別（Nginx根據每個工作進程的當前壓力調整它們獲取監聽套接口的幾率，那些當前比較空閑的工作進程有更多機會獲取到監聽套接口，從而客戶端的請求到達后也就相應地被它捕獲並處理）。如果Nginx是以反向代理的形式配置運行，那么對請求的實際處理需要轉發到后端服務器運行，如果后端服務器有多台，如何選擇一台合適的后端服務器來處理當前請求，就是本文要說的負載均衡。這兩種均衡互不沖突並且能同時生效。

nginx不單可以作為強大的web服務器，也可以作為一個反向代理服務器，而且nginx還可以按照調度規則實現動態、靜態頁面的分離，可以按照輪詢、ip哈希、URL哈希、權重等多種方式對后端服務器做負載均衡，同時還支持后端服務器的健康檢查。

如果只有一台服務器時,這個服務器掛了,那么對於網站來說是個災難.因此，這時候的負載均衡就會大顯身手了,它會自動剔除掛掉的服務器.

負載均衡模塊簡介

負載均衡模塊Load-balance是輔助模塊，主要為Upstream模塊服務，目標明確且單一：如何從多台后端服務器中選擇出一台合適的服務器來處理

當前的請求。

Load-blance模塊中4個關鍵回調函數：

表1

 

回調指針	函數功能	round_robin模塊	IP_hash模塊
uscf->peer.init_upstream	解析配置文件過程中調用，根據upstream里各個server配置項做初始准備工作，另外的核心工作是設置回調指針us->peer.init。配置文件解析完后不再被調用	ngx_http_upstream_init_round_robin 設置：us->peer.init = ngx_http_upstream_init_round_robin_peer;	ngx_http_upstream_init_ip_hash 設置：us->peer.init = ngx_http_upstream_init_ip_hash_peer;
us->peer.init	在每一次Nginx准備轉發客戶端請求到后端服務器前都會調用該函數。該函數為本次轉發選擇合適的后端服務器做初始准備工作，另外的核心工作是設置回調指針r->upstream->peer.get和r->upstream->peer.free等	ngx_http_upstream_init_round_robin_peer 設置：r->upstream->peer.get = ngx_http_upstream_get_round_robin_peer; r->upstream->peer.free = ngx_http_upstream_free_round_robin_peer;	ngx_http_upstream_init_ip_hash_peer 設置：r->upstream->peer.get = ngx_http_upstream_get_ip_hash_peer; r->upstream->peer.free為空
r->upstream->peer.get	在每一次Nginx准備轉發客戶端請求到后端服務器前都會調用該函數。該函數實現具體的位本次轉發選擇合適的后端服務器的算法邏輯，即完成選擇獲取合適后端服務器的功能	ngx_http_upstream_get_round_robin_peer 加權選擇當前權值最高的后端服務器	ngx_http_upstream_get_ip_hash_peer 根據IP哈希值選擇后端服務器
r->upstream->peer.free	在每一次Nginx完成與后端服務器之間的交互后都會調用該函數。	ngx_http_upstream_free_round_robin_peer 更新相關數值，比如rrp->current	空

 

負載均衡配置指令

nginx負載均衡模塊ngx_http_upstream_module允許定義一組服務器，這組服務器可以被proxy_pass，fastcgi_pass和memcached_pass這些指令引用。

配置例子：

upstream backend {
    server backend1.example.com       weight=5;
    server backend2.example.com:8080;
    server unix:/tmp/backend3;
 
    server backup1.example.com:8080   backup;
    server backup2.example.com:8080   backup;
}
 
server {
    location / {
        proxy_pass http://backend;
    }
}

語法：upstream name {...}

default：－

所屬指令：http

 

定義一組用於實現nginx負載均衡的服務器，它們可以偵聽在不同的端口。另外，可以混合使用偵聽TCP與UNIX-domain套接字文件。

 

例子：

 upstream backend {
    server backend1.example.com weight=5;
    server 127.0.0.1:8080       max_fails=3 fail_timeout=30s;
    server unix:/tmp/backend3;
}

默認情況下，請求被分散在使用加權輪詢的nginx負載均衡服務器上。在上面的例子中，每七個請求按下面分配：五個請求發送給backend1.example.com，127.0.0.1:8080和unix:/tmp/backend3各自分配一個。如果在於服務器通信時發生了一個錯誤，這個請求會被傳遞給下一個服務器，以此類推至道所有的功能服務器都嘗試過。如果不能從所有的這些nginx負載均衡服務器上獲得回應，客戶端將會獲得最后一個鏈接的服務器的處理結果。

語法：server 地址 [參數]；

default：－

所屬指令：upstream

 

設置一個nginx負載均衡服務器的地址和其他參數。一個地址可以被指定為域名或IP地址，和一個可選的端口，或者被定為UNIX-domain套接字文件的路徑，使用"unix:"作為前綴。如果端口沒指定，則使用80端口。一個被解析到多個IP地址的域名本質上指定了多個服務器。

 

可以定義下面的參數：

 

weight=number

  設置服務器的權限，默認是1

max_fails=number

  設置在fail_timeout參數設置的時間內最大失敗次數，如果在這個時間內，所有針對該服務器的請求

  都失敗了，那么認為該服務器會被認為是停機了，停機時間是fail_timeout設置的時間。默認情況下，

  不成功連接數被設置為1。被設置為零則表示不進行鏈接數統計。那些連接被認為是不成功的可以通過

  proxy_next_upstream, fastcgi_next_upstream，和memcached_next_upstream指令配置。http_404

  狀態不會被認為是不成功的嘗試。

fail_time=time

  設置

    多長時間內失敗次數達到最大失敗次數會被認為服務器停機了

    服務器會被認為停機的時間長度

  默認情況下，超時時間被設置為10S

 

backup

  標記該服務器為備用服務器。當主服務器停止時，請求會被發送到它這里。

 

down

  標記服務器永久停機了；與指令ip_hash一起使用。

 

例子：

upstream backend {
    server backend1.example.com     weight=5;
    server 127.0.0.1:8080           max_fails=3 fail_timeout=30s;
    server unix:/tmp/backend3;
 
    server backup1.example.com:8080 backup;
}

語法：ip_hash;

default:-

所屬指令：upstream

指定nginx負載均衡器組使用基於客戶端ip的負載均衡算法。IPV4的前3個八進制位和所有的IPV6地址被用作一個hash key。這個方法確保了相同客戶端的請求一直發送到相同的服務器上除非這個服務器被認為是停機。這種情況下，請求會被發送到其他主機上，然后可能會一直發送到這個主機上。

  注意：在版本1.3.2中開始支持IPV6地址。

如果nginx負載均衡器組里面的一個服務器要臨時移除，它應該用參數down標記，來防止之前的客戶端IP還往這個服務器上發請求。

例子：

upstream backend {
    ip_hash;
 
    server backend1.example.com;
    server backend2.example.com;
    server backend3.example.com down;
    server backend4.example.com;
}

  注意：在nginx版本1.3.1之前，不能在ip_hash中使用權重（weight）

語法：keepalive 連接數；

default：－

所屬模塊：upstream

這個指令在版本1.1.4中出現

nginx負載均衡器的活動鏈接數緩存。

連接數（keepalive的值）指定了每個工作進程中保留的持續連接到nginx負載均衡器緩存的最大值。如果超過這個設置值的閑置進程想鏈接到nginx負載均衡器組，最先連接的將被關閉。

應該注意：keepalive指令不限制nginx工作進程可以連接到nginx負載均衡器可以開啟的最大公工作進程，如果

有需要的話，新進程還是會被發起。連接數應該被設置足夠低來滿足nginx負載均衡器處理新進的連接。

帶有持續連接（keepalive connections）的memcached upstream的配置例子

upstream memcached_backend {
    server 127.0.0.1:11211;
    server 10.0.0.2:11211;
 
    keepalive 32;
}
 
server {
    ...
 
    location /memcached/ {
        set $memcached_key $uri;
        memcached_pass memcached_backend;
    }
 
}

nginx負載均衡器內置變量（Embedded Variables）

nginx負載均衡模塊ngx_http_upstream_module支持下列內置變量：

$upstream_addr

保存一個服務器的IP地址和端口號或者UNIX-domain套接字文件的路徑。如果在處理請求過程中使用了多個服

務器，那么它們的地址將以逗號分割，例如 ：“192.168.1.1:80, 192.168.1.2:80, unix:/tmp/sock”。如果一個內置

的從一個服務器組到另一個服務器組的重定向使用X-Accel-Redirect” or error_page ，那么那些服務器組

以冒號隔開，例如“192.168.1.1:80, 192.168.1.2:80, unix:/tmp/sock : 192.168.10.1:80, 192.168.10.2:80”。

$upstream_response_time

保存nginx負載均衡服務器響應時間，以毫秒計。多個響應也以逗號和冒號隔開。

$upstream_status

保存nginx負載均衡服務器響應代碼。多個響應代碼也以逗號或冒號隔開。

$upstream_http_...

保存nginx負載均衡服務器響應頭字段。例如，the “Server” response header field is made available through the $upstream_http_server variable.注意，只有最后一個服務器響應頭字段被保存。

負載均衡策略

nginx的負載均衡策略可以划分為兩大類：內置策略和擴展策略。內置策略包含加權輪詢和ip hash，在默認情況下這兩種策略會編譯進nginx內核，只需在nginx配置中指明參數即可。擴展策略有很多，如fair、通用hash、consistent hash等，默認不編譯進nginx內核，是第三方模塊。

 

nginx 的 upstream目前支持 4 種方式的分配 ：

1)輪詢（默認） 

      每個請求按時間順序逐一分配到不同的后端服務器，如果后端服務器down掉，能自動剔除。 

2)weight 

      指定輪詢幾率，weight和訪問比率成正比，用於后端服務器性能不均的情況。 

2)ip_hash 

      每個請求按訪問ip的hash結果分配，這樣每個訪客固定訪問一個后端服務器，可以解決session的問題。  

3)fair（第三方） 

      按后端服務器的響應時間來分配請求，響應時間短的優先分配。  

4)url_hash（第三方）

 

Nginx默認采用round_robin加權算法。如果要選擇其他的負載均衡算法，必須在upstream的配置上下文中通過配置指令ip_hash明確指定（該配置項最好放在其他server指令等的前面，以便檢查server的配置選項是否合理）。比如采用Ip_hash的upstream配置如下所示：

upstream load_balance{
    ip_hash;
    server localhost:8001;
    server localhost:8002;
}

當整個http配置塊被Nginx解析完畢之后，會調用各個http模塊對應的初始函數。對於模塊ngx_http_upstream_module而言，對應的main配置初始函數是ngx_http_upstream_init_main_conf()，在這個函數中有這樣一段代碼：

for (i = 0; i < umcf->upstreams.nelts; i++) {

        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;
        }
}

默認采用加權輪詢策略的原因就是在於上述代碼中的init賦值一行。如果用戶沒有做任何策略選擇，那么執行的策略初始函數為ngx_http_upstream_init_round_robin，也就是加權輪詢策略。否則的話執行的是uscfp[i]->peer.init_upstream指針函數，如果有配置執行ip_hash ，那么就是ngx_http_upstream_init_ip_hash()。

加權輪詢策略

全局准備工作

需要注意的是，配置文件中出現的參數只能和某些策略配合使用，所以如果發現某參數沒有生效，則應該檢查這一點。在配置解析的過程中，這些選項設置都被轉換為Nginx內對於的變量值，對應的結構體ngx_http_upstream_server_t如下（ngx_http_upstream.h）：

typedef struct {
    ngx_addr_t                      *addrs;//指向存儲IP地址的數組的指針，host信息(對應的是 ngx_url_t->addrs )
    ngx_uint_t                       naddrs;//與第一個參數配合使用，數組元素個數(對應的是 ngx_url_t->naddrs )
    ngx_uint_t                       weight;
    ngx_uint_t                       max_fails;
    time_t                           fail_timeout;

    unsigned                         down:1;
    unsigned                         backup:1;
} ngx_http_upstream_server_t;

這個階段的函數是ngx_http_upstream_init_round_robin()，其主要完成的工作詳見表1.

首先是設置了一個回調指針，這個函數用來針對每個請求選擇后端服務器之前做一些初始化工作：

us->peer.init = ngx_http_upstream_init_round_robin_peer;

us類型是ngx_http_upstream_srv_conf_t：

typedef struct ngx_http_upstream_srv_conf_s  ngx_http_upstream_srv_conf_t;

struct ngx_http_upstream_srv_conf_s {
    ngx_http_upstream_peer_t         peer;
    void                           **srv_conf;//在 ngx_http_upstream()函數中被設置，指向的是本層的srv_conf

    ngx_array_t                     *servers;  /*array of ngx_http_upstream_server_t */

    ngx_uint_t                       flags;//調用函數時ngx_http_upstream_add() 指定的標記
    ngx_str_t                        host;//在函數 ngx_http_upstream_add() 中設置（e.g. upstream backend中的backend）
    u_char                          *file_name;//"/usr/local/nginx/conf/nginx.conf"
    ngx_uint_t                       line;//proxy在配置文件中的行號
    in_port_t                        port;//使用的端口號（ngx_http_upstream_add()函數中添加, 指向ngx_url_t-->port，通常在函數ngx_parse_inet_url()中解析）
    in_port_t                        default_port;//默認使用的端口號（ngx_http_upstream_add()函數中添加, 指向ngx_url_t-->default_port）
    ngx_uint_t                       no_port;  /* unsigned no_port:1 */
};

而ngx_http_upstream_peer_t ：

typedef struct {
    //使用負載均衡的類型，默認采用 ngx_http_upstream_init_round_robin（）
    ngx_http_upstream_init_pt        init_upstream;
    //使用的負載均衡類型的初始化函數
    ngx_http_upstream_init_peer_pt   init;
    //us->peer.data = peers; 指向的是 ngx_http_upstream_rr_peers_t（函數 ngx_http_upstream_init_round_robin()中設置）
    void                            *data;
} ngx_http_upstream_peer_t;

ngx_http_upstream_init_peer_pt  是函數指針類型：

typedef ngx_int_t (*ngx_http_upstream_init_peer_pt)(ngx_http_request_t *r,
    ngx_http_upstream_srv_conf_t *us);

服務器類型ngx_http_upstream_server_t見前面的解釋。

如果upstream中服務器為空，那么默認使用proxy_pass。將利用函數ngx_inet_resolve_host依據us參數中的host和port進行解析。將結果保存在一個ngx_url_t類型的變量中：

typedef struct {
    ngx_str_t                 url;					//保存IP地址+端口信息（e.g. 192.168.124.129:8011 或 money.163.com）
    ngx_str_t                 host;					//保存IP地址信息
    ngx_str_t                 port_text;				//保存port字符串
    ngx_str_t                 uri;					//uri部分，在函數ngx_parse_inet_url()中設置

    in_port_t                 port;					//端口，e.g. listen指令中指定的端口（listen 192.168.124.129:8011）
    in_port_t                 default_port;				//默認端口（當no_port字段為真時，將默認端口賦值給port字段， 默認端口通常是80）
    int                       family;					//address family, AF_xxx

    unsigned                  listen:1;				//是否為指監聽類的設置
    unsigned                  uri_part:1;
    unsigned                  no_resolve:1;				//根據情況決定是否解析域名（將域名解析到IP地址）
    unsigned                  one_addr:1;				//等於1時，僅有一個IP地址

    unsigned                  no_port:1;				//標識url中沒有顯示指定端口(為1時沒有指定)
    unsigned                  wildcard:1;				//標識是否使用通配符（e.g. listen *:8000;）

    socklen_t                 socklen;				//sizeof(struct sockaddr_in)
    u_char                    sockaddr[NGX_SOCKADDRLEN];		//sockaddr_in結構指向它

    ngx_addr_t               *addrs;				//數組大小是naddrs字段；每個元素對應域名的IP地址信息(struct sockaddr_in)，在函數中賦值（ngx_inet_resolve_host()）
    ngx_uint_t                naddrs;				//url對應的IP地址個數,IP格式的地址將默認為1

    char                     *err;					//錯誤信息字符串
} ngx_url_t;

此函數會創建后端服務器列表，並且將非后備服務器與后備服務器分開進行各自單獨的鏈表。每一個后端服務器用一個結構體ngx_http_upstream_rr_peer_t與之對應（ngx_http_upstream_round_robin.h）：

typedef struct {
    struct sockaddr                *sockaddr;//后端服務器地址
    socklen_t                       socklen;//后端服務器地址長度
    ngx_str_t                       name;//后端名稱

    ngx_int_t                       current_weight;//當前權重，nginx會在運行過程中調整此權重
    ngx_int_t                       effective_weight;
    ngx_int_t                       weight;//配置的權重

    ngx_uint_t                      fails;//已嘗試失敗次數
    time_t                          accessed;//檢測失敗時間，用於計算超時
    time_t                          checked;

    ngx_uint_t                      max_fails;//最大失敗次數
    time_t                          fail_timeout;//多長時間內出現max_fails次失敗便認為后端down掉了

    ngx_uint_t                      down;          /* unsigned  down:1; *///指定某后端是否掛了

#if (NGX_HTTP_SSL)
    ngx_ssl_session_t              *ssl_session;   /* local to a process */
#endif
} ngx_http_upstream_rr_peer_t;

列表最前面需要帶有一些head信息，用結構體ngx_http_upstream_rr_peers_t與之對應：

typedef struct ngx_http_upstream_rr_peers_s  ngx_http_upstream_rr_peers_t;

struct ngx_http_upstream_rr_peers_s {
    ngx_uint_t                      number;//隊列中服務器數量

 /* ngx_mutex_t                    *mutex; */

    ngx_uint_t                      total_weight;//所有服務器總權重

    unsigned                        single:1;//為1表示后端服務器總共只有一台，用於優化，此時不需要再做選擇
    unsigned                        weighted:1;//為1表示總的權重值等於服務器數量

    ngx_str_t                      *name;

    ngx_http_upstream_rr_peers_t   *next;//后備服務器列表掛載在這個字段下

    ngx_http_upstream_rr_peer_t     peer[1];
};

函數的完整代碼如下（ngx_http_upstream_round_robin.c）：

//函數：初始化服務器負載均衡表	
//參數：
//us：ngx_http_upstream_main_conf_t結構體中upstreams數組元素
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_peers_t  *peers, *backup;

    //回調指針設置
    us->peer.init = ngx_http_upstream_init_round_robin_peer;

    //服務器數組指針不為空
    if (us->servers) {
        server = us->servers->elts;

        n = 0;
        w = 0;

	//遍歷所有服務器
        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) {
            ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
                          "no servers in upstream \"%V\" in %s:%ui",
                          &us->host, us->file_name, us->line);
            return NGX_ERROR;
        }

	//為非后備服務器分配空間
        peers = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peers_t)
                              + sizeof(ngx_http_upstream_rr_peer_t) * (n - 1));
        if (peers == NULL) {
            return NGX_ERROR;
        }

	//非后備服務器列表頭中各屬性設置
        peers->single = (n == 1);
        peers->number = n;
        peers->weighted = (w != n);
        peers->total_weight = w;
        peers->name = &us->host;

        n = 0;

	//后備服務器列表中各服務器項設置
        for (i = 0; i < us->servers->nelts; i++) {
            for (j = 0; j < server[i].naddrs; j++) {
                if (server[i].backup) {
                    continue;
                }

                peers->peer[n].sockaddr = server[i].addrs[j].sockaddr;
                peers->peer[n].socklen = server[i].addrs[j].socklen;
                peers->peer[n].name = server[i].addrs[j].name;
                peers->peer[n].max_fails = server[i].max_fails;
                peers->peer[n].fail_timeout = server[i].fail_timeout;
                peers->peer[n].down = server[i].down;
                peers->peer[n].weight = server[i].weight;
                peers->peer[n].effective_weight = server[i].weight;
                peers->peer[n].current_weight = 0;
                n++;
            }
        }

	//非后備服務器列表掛載的位置
        us->peer.data = peers;

        /* backup servers */
	//后備服務器
        n = 0;
        w = 0;

        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_OK;
        }

	//后備服務器列表地址空間分配
        backup = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peers_t)
                              + sizeof(ngx_http_upstream_rr_peer_t) * (n - 1));
        if (backup == NULL) {
            return NGX_ERROR;
        }

        peers->single = 0;
	//后備服務器列表頭中各屬性設置
        backup->single = 0;
        backup->number = n;
        backup->weighted = (w != n);
        backup->total_weight = w;
        backup->name = &us->host;

        n = 0;

	//后備服務器列表中各服務器項設置
        for (i = 0; i < us->servers->nelts; i++) {
            for (j = 0; j < server[i].naddrs; j++) {
                if (!server[i].backup) {
                    continue;
                }

                backup->peer[n].sockaddr = server[i].addrs[j].sockaddr;
                backup->peer[n].socklen = server[i].addrs[j].socklen;
                backup->peer[n].name = server[i].addrs[j].name;
                backup->peer[n].weight = server[i].weight;
                backup->peer[n].effective_weight = server[i].weight;
                backup->peer[n].current_weight = 0;
                backup->peer[n].max_fails = server[i].max_fails;
                backup->peer[n].fail_timeout = server[i].fail_timeout;
                backup->peer[n].down = server[i].down;
                n++;
            }
        }

	//后備服務器掛載
        peers->next = backup;

        return NGX_OK;
    }

    //us參數中服務器指針為空，例如用戶直接在proxy_pass等指令后配置后端服務器地址
    /* an upstream implicitly defined by proxy_pass, etc. */

    if (us->port == 0) {
        ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
                      "no port in upstream \"%V\" in %s:%ui",
                      &us->host, us->file_name, us->line);
        return NGX_ERROR;
    }

    ngx_memzero(&u, sizeof(ngx_url_t));

    u.host = us->host;
    u.port = us->port;

    //IP地址解析
    if (ngx_inet_resolve_host(cf->pool, &u) != NGX_OK) {
        if (u.err) {
            ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
                          "%s in upstream \"%V\" in %s:%ui",
                          u.err, &us->host, us->file_name, us->line);
        }

        return NGX_ERROR;
    }

    n = u.naddrs;

    peers = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peers_t)
                              + sizeof(ngx_http_upstream_rr_peer_t) * (n - 1));
    if (peers == NULL) {
        return NGX_ERROR;
    }

    peers->single = (n == 1);
    peers->number = n;
    peers->weighted = 0;
    peers->total_weight = n;
    peers->name = &us->host;

    for (i = 0; i < u.naddrs; i++) {
        peers->peer[i].sockaddr = u.addrs[i].sockaddr;
        peers->peer[i].socklen = u.addrs[i].socklen;
        peers->peer[i].name = u.addrs[i].name;
        peers->peer[i].weight = 1;
        peers->peer[i].effective_weight = 1;
        peers->peer[i].current_weight = 0;
        peers->peer[i].max_fails = 1;
        peers->peer[i].fail_timeout = 10;
    }

    us->peer.data = peers;

    /* implicitly defined upstream has no backup servers */

    return NGX_OK;
}

選擇后端服務器

針對一個客戶端請求的初始化工作

全局初始化完成之后，當一個客戶端請求過來時，Nginx就要選擇合適的后端服務器來處理該請求。在正式開始選擇前，Nginx還要單獨為本輪選擇做一些初始化（針對一個客戶端請求，nginx會進行多次嘗試選擇，嘗試全部失敗后才返回502錯誤，所以注意一輪選擇與一次選擇的區別）。

在前面的函數ngx_http_upstream_init_round_robin()中設置的回調函數us->peer.init，它的調用位置是函數ngx_http_upstream_init_request中（ngx_http_upstream.c）：

static void
ngx_http_upstream_init_request(ngx_http_request_t *r)
{
...
if (uscf->peer.init(r, uscf) != NGX_OK) {
        ngx_http_upstream_finalize_request(r, u,
                                           NGX_HTTP_INTERNAL_SERVER_ERROR);
        return;
    }

    ngx_http_upstream_connect(r, u);
}

即在針對每個請求選擇后端服務器之前被調用。

下面看看函數ngx_http_upstream_init_round_robin_peer()完成了哪些工作。

它除了完成初始化工作之外，另外的核心工作是設置回調指針。

函數ngx_http_upstream_init_round_robin_peer的完整代碼（ngx_http_upstream_round_robin.c）：

//函數：
//功能：針對每個請求選擇后端服務器前做一些初始化工作
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;
    rrp->current = 0;

    //n取值為：非后備服務器和后備服務器列表中個數較大的那個值
    n = rrp->peers->number;

    if (rrp->peers->next && rrp->peers->next->number > n) {
        n = rrp->peers->next->number;
    }

    //如果n小於一個指針變量所能表示的范圍
    if (n <= 8 * sizeof(uintptr_t)) {
	//直接使用已有的指針類型的data變量做位圖（tried是位圖，用來標識在一輪選擇中，各個后端服務器是否已經被選擇過）
        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;
    r->upstream->peer.free = ngx_http_upstream_free_round_robin_peer;
    r->upstream->peer.tries = rrp->peers->number;
#if (NGX_HTTP_SSL)
    r->upstream->peer.set_session =
                               ngx_http_upstream_set_round_robin_peer_session;
    r->upstream->peer.save_session =
                               ngx_http_upstream_save_round_robin_peer_session;
#endif

    return NGX_OK;
}

對后端服務器進行一次選擇

對后端服務器做一次選擇的邏輯在函數ngx_http_upstream_get_round_robin_peer內，流程圖如下：

代碼如下：

//函數：
//功能：對后端服務器做一次選擇
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;

    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
                   "get rr peer, try: %ui", pc->tries);

    /* ngx_lock_mutex(rrp->peers->mutex); */

    pc->cached = 0;
    pc->connection = NULL;

    //如果只有一台后端服務器，Nginx直接選擇並返回
    if (rrp->peers->single) {
        peer = &rrp->peers->peer[0];

        if (peer->down) {
            goto failed;
        }

    } else {
	//有多台后端服務器
        /* there are several peers */
	//按照各台服務器的當前權值進行選擇
        peer = ngx_http_upstream_get_peer(rrp);

        if (peer == NULL) {
            goto failed;
        }

        ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
                       "get rr peer, current: %ui %i",
                       rrp->current, peer->current_weight);
    }

    //設置連接的相關屬性
    pc->sockaddr = peer->sockaddr;
    pc->socklen = peer->socklen;
    pc->name = &peer->name;

    /* ngx_unlock_mutex(rrp->peers->mutex); */

    if (pc->tries == 1 && rrp->peers->next) {
        pc->tries += rrp->peers->next->number;
    }

    return NGX_OK;

    //選擇失敗，轉向后備服務器
failed:

    peers = rrp->peers;

    if (peers->next) {

        /* ngx_unlock_mutex(peers->mutex); */

        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0, "backup servers");

        rrp->peers = peers->next;
        pc->tries = rrp->peers->number;

        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;
        }

        /* ngx_lock_mutex(peers->mutex); */
    }

    /* all peers failed, mark them as live for quick recovery */

    for (i = 0; i < peers->number; i++) {
        peers->peer[i].fails = 0;
    }

    /* ngx_unlock_mutex(peers->mutex); */

    pc->name = peers->name;

    //如果后備服務器也選擇失敗，則返回NGX_BUSY
    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;
    ngx_http_upstream_rr_peer_t  *peer, *best;

    now = ngx_time();

    best = NULL;
    total = 0;

    for (i = 0; i < rrp->peers->number; i++) {
	//計算當前服務器的標記位在位圖中的位置
        n = i / (8 * sizeof(uintptr_t));
        m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));

	//已經選擇過，跳過
        if (rrp->tried[n] & m) {
            continue;
        }

	//當前服務器對象
        peer = &rrp->peers->peer[i];

	//當前服務器已宕機，排除
        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;

        if (peer->effective_weight < peer->weight) {
            peer->effective_weight++;
        }

        if (best == NULL || peer->current_weight > best->current_weight) {
            best = peer;
        }
    }

    if (best == NULL) {
        return NULL;
    }

    //所選擇的服務器在服務器列表中的位置
    i = best - &rrp->peers->peer[0];

    rrp->current = i;

    n = i / (8 * sizeof(uintptr_t));
    m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));

    //位圖相應位置置位
    rrp->tried[n] |= m;

    best->current_weight -= total;
    best->checked = now;

    return best;
}

要理解這個函數的工作原理，先要區分下表示服務的ngx_http_upstream_rr_peer_t結構體中的一下三個成員變量：

    ngx_int_t                       current_weight;
    ngx_int_t                       effective_weight;
    ngx_int_t                       weight;

網上搜索到的解釋：

effective_weight相當於質量(來源於配置的weight)，current_weight相當於重量。前者反應本質，一般是不變的。current_weight是運行時的動態權值，它的變化基於effective_weight。但是effective_weight在其對應的peer服務異常時，會被調低，當服務恢復正常時，effective_weight會逐漸恢復到實際值（配置的weight）。

下面我們結合具體的代碼來看。

它們在函數ngx_http_upstream_init_round_robin中被初始化：

 for (i = 0; i < us->servers->nelts; i++) {
            for (j = 0; j < server[i].naddrs; j++) {
                if (server[i].backup) {
                    continue;
                }

                peers->peer[n].weight = server[i].weight;
                peers->peer[n].effective_weight = server[i].weight;
                peers->peer[n].current_weight = 0;
                n++;
            }
        }

        /* backup servers */
        for (i = 0; i < us->servers->nelts; i++) {
            for (j = 0; j < server[i].naddrs; j++) {
                if (!server[i].backup) {
                    continue;
                }

                backup->peer[n].weight = server[i].weight;
                backup->peer[n].effective_weight = server[i].weight;
                backup->peer[n].current_weight = 0;

                n++;
            }
        }

     /* an upstream implicitly defined by proxy_pass, etc. */
    for (i = 0; i < u.naddrs; i++) {
        peers->peer[i].weight = 1;
        peers->peer[i].effective_weight = 1;
        peers->peer[i].current_weight = 0;
    }

可以看到weight、effective_weight都是初始化為配置項中的weight值。current_weight初始化為0.

下面分析這三個變量在負載均衡過程中的變化。

weight的值在整個運行過程中不發生變化。

total變量記錄了針對一個服務列表的一次輪詢過程中輪詢到的所有服務的effective_weight總和。在每一次針對服務列表的輪詢之前會置為為0.

遍歷服務列表的過程中，每遍歷到一個服務，會在該服務的current_weight上加上其對應的effective_weight。這個是累加。如果對統一的服務列表進行另一次輪詢，那么會在前面計算的current_weight的基礎之上再加上effective_weight。

輪詢策略是取current_weight最大的服務器。每次取到后端服務（用best表示）后，都會把該對象peer的current_weight減去total的值。因為該服務剛被選中過，因此要降低權值。

關於effective_weight的變化，有兩處，一個是在函數ngx_http_upstream_get_peer中：

        //服務正常，effective_weight 逐漸恢復正常    
        if (peer->effective_weight < peer->weight) {
            peer->effective_weight++;
        }

另一處是在釋放后端服務的函數ngx_http_upstream_free_round_robin_peer中：

        if (peer->max_fails) {
             //服務發生異常時，調低effective_weight
            peer->effective_weight -= peer->weight / peer->max_fails;
        }

權重高的會優先被選中，而且被選中的頻率也更高。權重低的也會由於權重逐漸增長獲得被選中的機會。

下面給出一個加權輪詢的選擇實例（來自http://blog.sina.com.cn/s/blog_7303a1dc01014i0j.html）：

selected server	current_weight beforeselected	current_weight afterselected
a	{ 5, 1, 2 }	{ -3, 1, 2 }
c	{ 2, 2, 4 }	{ 2, 2, -4 }
a	{ 7, 3, -2 }	{ -1, 3, -2 }
a	{ 4, 4, 0 }	{ -4, 4, 0 }
b	{ 1, 5, 2 }	{ 1, -3, 2 }
a	{ 6, -2, 4 }	{ -2, -2, 4 }
c	{ 3, -1, 6 }	{ 3, -1, -2 }
a	{ 8, 0, 0 }	{ 0, 0, 0 }

釋放后端服務器

連接后端服務器並且正常處理當前客戶端請求后需釋放后端服務器。如果在某一輪選擇里，某次選擇的服務器因連接失敗或請求處理失敗而需要重新進行選擇，那么這時候就需要做一些額外的處理。

//函數：
//功能：釋放后端服務器
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;

    ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
                   "free rr peer %ui %ui", pc->tries, state);

    /* TODO: NGX_PEER_KEEPALIVE */

    //后端服務只有一個
    if (rrp->peers->single) {
        pc->tries = 0;
        return;
    }

    peer = &rrp->peers->peer[rrp->current];

    //在某一輪選擇里，某次選擇的服務器因連接失敗或請求處理失敗而需要重新進行選擇
    if (state & NGX_PEER_FAILED) {
        now = ngx_time();

        /* ngx_lock_mutex(rrp->peers->mutex); */

	//已嘗試失敗次數加一
        peer->fails++;
        peer->accessed = now;
        peer->checked = now;

	//如果有最大失敗次數限制
        if (peer->max_fails) {
	    //服務發生異常時，調低effective_weight
            peer->effective_weight -= peer->weight / peer->max_fails;
        }

        ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
                       "free rr peer failed: %ui %i",
                       rrp->current, peer->effective_weight);

	//effective_weight總大於0
        if (peer->effective_weight < 0) {
            peer->effective_weight = 0;
        }

        /* ngx_unlock_mutex(rrp->peers->mutex); */

    } else {

        /* mark peer live if check passed */

        if (peer->accessed < peer->checked) {
            peer->fails = 0;
        }
    }

    //ngx_peer_connection_t結構體中tries字段：
    //表示在連接一個遠端服務器時，當前連接出現異常失敗后可以重試的次數，也就是允許失敗的次數
    if (pc->tries) {
        pc->tries--;
    }

    /* ngx_unlock_mutex(rrp->peers->mutex); */
}

整個加權輪詢的流程

整個加權輪詢的流程圖如下：

說明：

首先是全局初始化，由函數ngx_http_upstream_init_round_robin完成，它在函數ngx_http_upstream_init_main_conf中被調用，代碼：

static char *
ngx_http_upstream_init_main_conf(ngx_conf_t *cf, void *conf)
{    
...
    for (i = 0; i < umcf->upstreams.nelts; i++) {
        //全局初始化
        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_peer，它在函數ngx_http_upstream_init_request中被調用：

static void
ngx_http_upstream_init_request(ngx_http_request_t *r)
{
...
if (uscf->peer.init(r, uscf) != NGX_OK) {
        ngx_http_upstream_finalize_request(r, u,
                                           NGX_HTTP_INTERNAL_SERVER_ERROR);
        return;
    }

    ngx_http_upstream_connect(r, u);
}

然后是針對每個請求選擇后端服務器，實現此功能的函數是ngx_http_upstream_get_round_robin_peer。它在函數ngx_event_connect_peer中被調用：

//函數：連接后端upstream
ngx_int_t
ngx_event_connect_peer(ngx_peer_connection_t *pc)
{
...
    //此處調用選擇后端服務器功能函數ngx_http_upstream_get_round_robin_peer
    rc = pc->get(pc, pc->data);
    if (rc != NGX_OK) {
        return rc;
    }

    s = ngx_socket(pc->sockaddr->sa_family, SOCK_STREAM, 0);
...
}

之后是測試連接ngx_http_upstream_test_connect。它在函數ngx_http_upstream_send_request被調用：

//函數：發送數據到后端upstream
static void
ngx_http_upstream_send_request(ngx_http_request_t *r, ngx_http_upstream_t *u)
{
...
    if (!u->request_sent && ngx_http_upstream_test_connect(c) != NGX_OK) {
        //測試連接失敗
        ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
        return;
    }
...
}

如果測試成功，繼續后續處理，並釋放后端服務器。

如果測試失敗，調用ngx_http_upstream_next函數，這個函數可能再次調用peer.get調用別的連接。

static void
ngx_http_upstream_next(ngx_http_request_t *r, ngx_http_upstream_t *u,
    ngx_uint_t ft_type)
{
...
    if (u->peer.sockaddr) {

        if (ft_type == NGX_HTTP_UPSTREAM_FT_HTTP_404) {
            state = NGX_PEER_NEXT;
        } else {
            state = NGX_PEER_FAILED;
        }
        //釋放后端服務器
        u->peer.free(&u->peer, u->peer.data, state);
        u->peer.sockaddr = NULL;
    }
...
if (status) {
        u->state->status = status;

        if (u->peer.tries == 0 || !(u->conf->next_upstream & ft_type)) {

#if (NGX_HTTP_CACHE)

            if (u->cache_status == NGX_HTTP_CACHE_EXPIRED
                && (u->conf->cache_use_stale & ft_type))
            {
                ngx_int_t  rc;

                rc = u->reinit_request(r);

                if (rc == NGX_OK) {
                    u->cache_status = NGX_HTTP_CACHE_STALE;
                    rc = ngx_http_upstream_cache_send(r, u);
                }

                ngx_http_upstream_finalize_request(r, u, rc);
                return;
            }
#endif
            //結束請求
            ngx_http_upstream_finalize_request(r, u, status);
            return;
        }
    }
...
//再次發起連接
ngx_http_upstream_connect(r, u);
}

函數ngx_http_upstream_connect中會調用ngx_event_connect_peer，進而調用ngx_http_upstream_get_round_robin_peer再次選擇后端服務器。

轉載請注明 出處：http://blog.csdn.net/xiajun07061225/article/details/9318871

參考資料：

 

http://www.cnblogs.com/xiaogangqq123/archive/2011/03/04/1971002.html

http://tengine.taobao.org/book/chapter_05.html#id5

http://blog.dccmx.com/2011/07/nginx-upsream-src-2/

http://nginx-source-analysis.googlecode.com/svn-history/r151/trunk/src/http/ngx_http_upstream.h

http://www.inginx.org/thread-89-1-1.html

http://blog.sina.com.cn/s/blog_7303a1dc01014i0j.html

https://github.com/phusion/nginx/commit/27e94984486058d73157038f7950a0a36ecc6e35

http://www.pagefault.info/?p=251

http://www.pagefault.info/?p=259