Go 實現 Nginx 加權輪詢演算法

一，Nginx 負載均衡的輪詢（round-robin）

在說加權輪詢之前我們先來簡單的說一下輪詢

轉自：https：//segmentfault。com/a/1190000039799210

整理：地鼠文件：www。topgoer。cn

1。 nginx 中的配置

upstream cluster { server 192。168。0。14； server 192。168。0。15；}location / { proxy_set_header X-Real-IP $remote_addr； //返回真實IP proxy_pass http：//cluster； //代理指向cluster }

2。簡單介紹

輪詢作為負載均衡中較為基礎的演算法，他的實現不需要配置額外的引數。簡單理解：配置檔案中一共配置了 N 臺伺服器，輪詢演算法會遍歷服務的節點列表，並按照節點順序每輪選擇一臺伺服器處理請求，當所有節點遍歷一遍後，重新開始

3。特點

輪詢演算法中我們不難看出，每臺伺服器處理請求的數量基本持平，按照請求時間逐一分配，因此只能適用於叢集伺服器效能相近的情況，平均分配讓每臺伺服器承載量基本持平。但是如果叢集伺服器效能參差不齊，這樣的演算法會導致資源分配不合理，造成部分請求阻塞，部分伺服器資源浪費。為了解決上述問題，我們將輪詢演算法升級了，引入了加權輪詢演算法，讓叢集中效能差異較大的伺服器也能合理分配資源。達到資源儘量最大化合理利用

4。實現（這裡使用golang模擬實現）

type RoundRobinBalance struct { curIndex int rss ［］string}/** * @Author： yang * @Description：新增服務 * @Date： 2021/4/7 15：36 */func （r *RoundRobinBalance） Add （params 。。。string） error{ if len（params） == 0 { return errors。New（“params len 1 at least”） } addr ：= params［0］ r。rss = append（r。rss， addr） return nil}/** * @Author： yang * @Description：輪詢獲取服務 * @Date： 2021/4/7 15：36 */func （r *RoundRobinBalance） Next （） string { if len（r。rss） == 0 { return “” } lens ：= len（r。rss） if r。curIndex >= lens { r。curIndex = 0 } curAdd ：= r。rss［r。curIndex ］ r。curIndex = （r。curIndex + 1） % lens return curAdd}

5。測試

簡單呼叫下方法看看結果

/** * @Author： yang * @Description：測試 * @Date： 2021/4/7 15：36 */func main（）{ rb ：= new（RoundRobinBalance） rb。Add（“127。0。0。1：80”） rb。Add（“127。0。0。1：81”） rb。Add（“127。0。0。1：82”） rb。Add（“127。0。0。1：83”） fmt。Println（rb。Next（）） fmt。Println（rb。Next（）） fmt。Println（rb。Next（）） fmt。Println（rb。Next（）） fmt。Println（rb。Next（）） fmt。Println（rb。Next（））}go run main。go 127。0。0。1：80127。0。0。1：81127。0。0。1：82127。0。0。1：83127。0。0。1：80127。0。0。1：81

二，Nginx 負載均衡的加權輪詢（weighted-round-robin）

進入主題

1。 nginx 配置

http { upstream cluster { server 192。168。1。2 weight=5； server 192。168。1。3 weight=3； server 192。168。1。4 weight=1； } location / { proxy_set_header X-Real-IP $remote_addr； //返回真實IP proxy_pass http：//cluster； //代理指向cluster }

2。加權演算法簡介-特點

不同的伺服器的配置，部署的應用數量，網路狀況等都會導致伺服器處理能力會不一樣，所以簡單的輪詢演算法將不再適用，而引入了加權輪詢演算法：根據伺服器不同的處理能力，給每個伺服器分配不同的權值，根據不同的權值將不同的伺服器分配到對應的伺服器上；

請求數量較大時，每個服務處理請求的數量之比會趨向於權重之比。

3。演算法說明

在 Nginx加權輪詢演算法中，每個節點都有3個權重的變數

Weight ：配置的權重，根據配置檔案初始化每個伺服器節點的權重

currentWeight ：節點的當前權重，初始化時是配置的權重，隨後會一直變更

effectiveWeight ：有效的權重，初始值為 weight ，通訊過程中發現節點異常，則 -1 ，之後再次選擇本節點，呼叫成功一次則 +1 ，直到恢復到 weight。這個引數可以用於做降權。或者說是你的設定的許可權修正。。

Nginx加權輪詢演算法的邏輯實現

輪詢所有節點，計算當前狀態下所有的節點的 effectiveWeight 之和作為 totalWeight；

更新每個節點的 currentWeight ， currentWeight = currentWeight + effectiveWeight；選出所有節點 currentWeight 中最大的一個節點作為選中節點；

選擇中的節點再次更新 currentWeight， currentWeight = currentWeight - totalWeight；

4。簡單舉例

注意：實現中不考慮健康檢查，即所有的節點都是100%可用的，所以 effectiveWeight 等於 weight

假設：現在有3個節點 {A， B， C} 分別權重為：{4， 2， 1}；請求7次

第N次請求

請求前 currentWeight

選中的節點

請求後 currentWeight

［serverA=4， serverB=2， serverC=1］

serverA

［serverA=1， serverB=4， serverC=2］

serverB

［serverA=5， serverB=-1， serverC=3］

serverA

［serverA=2， serverB=1， serverC=4］

serverA

［serverA=-1， serverB=3， serverC=5］

serverC

［serverA=3， serverB=5， serverC=-1］

serverA

［serverA=0， serverB=7， serverC=0］

serverB

［serverA=4， serverB=2， serverC=1］

totaoWeight = 4 + 2 + 1 = 7

第一次請求： serverA = 4 + 4 = 8 ， serverB = 2 + 2 = 4， serverC = 1 + 1 = 2；最大的是 serverA ；所以選擇 serverA ；然後serverA = 8 - 7 = 1；最後得出：serverA=1， serverB=4， serverC=2

第二次請求： serverA = 1 + 4 = 5； serverB = 4 + 2 = 6 ； serverC = 2 + 1 = 3；最大的是 serverB ；所以選擇 serverB ；然後 serverB = 6 - 7 = -1 ；最後得出： serverA=5， serverB=-1， serverC=3

以此類推。。。

5。程式碼實現

以golang實現下上面的邏輯：

type WeightRoundRobinBalance struct { curIndex int rss ［］*WeightNode}type WeightNode struct { weight int // 配置的權重，即在配置檔案或初始化時約定好的每個節點的權重 currentWeight int //節點當前權重，會一直變化 effectiveWeight int //有效權重，初始值為weight，通訊過程中發現節點異常，則-1 ，之後再次選取本節點，呼叫成功一次則+1，直達恢復到weight 。用於健康檢查，處理異常節點，降低其權重。 addr string // 伺服器addr}/** * @Author： yang * @Description：新增服務 * @Date： 2021/4/7 15：36 */func （r *WeightRoundRobinBalance） Add （params 。。。string） error{ if len（params）！= 2{ return errors。New（“params len need 2”） } // @Todo 獲取值 addr ：= params［0］ parInt， err ：= strconv。ParseInt（params［1］， 10， 64） if err ！= nil { return err } node ：= &WeightNode{ weight： int（parInt）， effectiveWeight： int（parInt）， // 初始化時有效權重 = 配置權重值 currentWeight： int（parInt）， // 初始化時當前權重 = 配置權重值 addr： addr， } r。rss = append（r。rss， node） return nil}/** * @Author： yang * @Description：輪詢獲取服務 * @Date： 2021/4/7 15：36 */func （r *WeightRoundRobinBalance） Next （） string { // @Todo 沒有服務 if len（r。rss） == 0 { return “” } totalWeight ：= 0 var maxWeightNode *WeightNode for key ， node ：= range r。rss { // @Todo 計算當前狀態下所有節點的effectiveWeight之和totalWeight totalWeight += node。effectiveWeight // @Todo 計算currentWeight node。currentWeight += node。effectiveWeight // @Todo 尋找權重最大的 if maxWeightNode == nil || maxWeightNode。currentWeight < node。currentWeight { maxWeightNode = node r。curIndex = key } } // @Todo 更新選中節點的currentWeight maxWeightNode。currentWeight -= totalWeight // @Todo 返回addr return maxWeightNode。addr}

6。測試驗證

/** * @Author： yang * @Description：測試 * @Date： 2021/4/7 15：36 */func main（）{ rb ：= new（WeightRoundRobinBalance） rb。Add（“127。0。0。1：80”， “4”） rb。Add（“127。0。0。1：81”， “2”） rb。Add（“127。0。0。1：82”， “1”） fmt。Println（rb。Next（）） fmt。Println（rb。Next（）） fmt。Println（rb。Next（）） fmt。Println（rb。Next（）） fmt。Println（rb。Next（）） fmt。Println（rb。Next（）） fmt。Println（rb。Next（））}

執行下看下結果

run main。go127。0。0。1：80127。0。0。1：81127。0。0。1：80127。0。0。1：80127。0。0。1：82127。0。0。1：80127。0。0。1：81