关于golang:Nginx负载均衡算法加权轮询golang-实现

Nginx 负载平衡算法 – 加权轮询

最近在看一些 getway 相干的材料，发现无关 Nginx 负载平衡的算法有点多，然而有点乱，所以整顿下。。。如有不对中央请指出。

一，Nginx 负载平衡的轮询（round-robin）

在说加权轮询之前咱们先来简略的说一下轮询

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:80
127.0.0.1:81
127.0.0.1:82
127.0.0.1:83
127.0.0.1:80
127.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 加权轮询算法 的逻辑实现

1. 轮询所有节点，计算以后状态下所有的节点的 effectiveWeight 之和 作为 totalWeight；
2. 更新每个节点的 currentWeight，currentWeight = currentWeight + effectiveWeight; 选出所有节点 currentWeight 中最大的一个节点作为选中节点；
3. 抉择中的节点再次更新 currentWeight, currentWeight = currentWeight – totalWeight；

4. 简略举例

留神：实现中不思考健康检查，即所有的节点都是 100% 可用的，所以 effectiveWeight 等于 weight

假如：当初有 3 个节点 {A, B, C} 别离权重为：{4, 2, 1}；申请 7 次

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.go

127.0.0.1:80
127.0.0.1:81
127.0.0.1:80
127.0.0.1:80
127.0.0.1:82
127.0.0.1:80
127.0.0.1:81