使用Golang实现加权负载均衡算法的实现代码

背景描述

如下图所示，负载均衡做为反向代理，将请求方的请求转发至后端的服务节点，实现服务的请求。

在nginx中可以通过upstream配置server时，设置weight表示对应server的权重。

若存在多个服务节点时，负载均衡如何通过服务节点的权重进行转发。

如下详细说明权重转发算法的实现。

用三个后端服务节点为例说明

设置三个后端服务servera，serverb和serverc，它们的权重分布是 5，3，1

按照加权负载均衡算法，在一轮（5+3+1=9次）中servera占5次，serverb占3次，serverc占1次，从而实现均衡。

如下图所示：

为了实现这个功能，可以给每一个后端设置对应的权重5,3,1

变量1：后端服务的权重 weight

变量2：均衡器累计的总的有效权重effectiveweight

变量3：实时统计后端服务的当前权重 currentweight

算法设计

第一步，向均衡器中增加后端服务标识

• 将三个后端服务标识和权重weight增加到负载均衡器列表中。
• 每次增加后端服务时，累计总的有效权重effectiveweight。

第二步，每次获取一个后端服务标识

• 对均衡器中的所有后端服务增加自己的权重weight，即(5，3，1),计算abc三个服务的当前权重。
• 选择当前权重currentweight最大的服务，做为本次期望的后端服务。
• 将期望的后端服务的当前权重currentweight减小总的权重effectiveweight，供下一轮使用。

如下是一个一轮（5+3+1=9次）获取的权重变化表：

从这个表中可以看到后端服务轮询的顺序是 a b a c a b a b a，其中a出现了5次，b出现了3次，c出现了1次，满足三个服务的权重weight设置。

完成9次获取后，abc三个服务的权重都归0，因此下一轮的9次获取也是均衡的，

算法实现

按照如上算法说明，使用golang实现这个算法如下

package weightroundrobin

import (
    "fmt"
    "strings"
)

// 每一个后端服务定义
type backendserver struct {
    // 实例权重
    weight int
    // 当前的权重，初始为weight
    currentweight int
    // 后端服务名称
    servername string
}

// 通过权重实现调用轮询的定义
type weightserverroundrobin struct {
    // 所有有效的权重总和
    effectiveweight int
    // 后端服务列表
    backendserverlist []*backendserver
}

// 创建一个负载轮询器
func newweightserverroundrobin() *weightserverroundrobin {
    return &weightserverroundrobin{
        effectiveweight: 0,
    }
}

// 增加后端服务名称和权重
func (r *weightserverroundrobin) addbackendserver(backendserver *backendserver) {
    r.effectiveweight += backendserver.weight
    r.backendserverlist = append(r.backendserverlist, backendserver)
}

// 更具权重获取一个后端服务名称
func (r *weightserverroundrobin) getbackendserver() *backendserver {
    var expectbackendserver *backendserver
    for _, backendserver := range r.backendserverlist {
        // 给每个后端服务增加自身权重
        backendserver.currentweight += backendserver.weight
        if expectbackendserver == nil {
            expectbackendserver = backendserver
        }
        if backendserver.currentweight > expectbackendserver.currentweight {
            expectbackendserver = backendserver
        }
    }
    r.visitbackendservercurrentweight()
    // 把选择的后端服务权重减掉总权重
    expectbackendserver.currentweight -= r.effectiveweight
    return expectbackendserver
}

// 打印后端服务的当前权重变化
func (r *weightserverroundrobin) visitbackendservercurrentweight() {
    var serverlistforlog []string
    for _, backendserver := range r.backendserverlist {
        serverlistforlog = append(serverlistforlog,
            fmt.sprintf("%v", backendserver.currentweight))
    }
    fmt.printf("(%v)\n", strings.join(serverlistforlog, ", "))
}

写一个单测进行验证

package weightroundrobin

import (
    "fmt"
    "testing"
)

func testnewweightserverroundrobin(t *testing.t) {
    weightserverroundrobin := newweightserverroundrobin()
    weightserverroundrobin.addbackendserver(&backendserver{
        servername: "servera",
        weight: 5,
    })
    weightserverroundrobin.addbackendserver(&backendserver{
        servername: "serverb",
        weight: 3,
    })
    weightserverroundrobin.addbackendserver(&backendserver{
        servername: "serverc",
        weight: 1,
    })

    expectservernamelist := []string{
        "servera", "serverb", "servera", "serverc", "servera", "serverb", "servera", "serverb", "servera",
        //"servera", "serverb", "servera", "serverc", "servera", "serverb", "servera", "serverb", "servera",
    }
    fmt.printf("(a, b, c)\n")
    for ii, expectservername := range expectservernamelist {
        weightserverroundrobin.visitbackendservercurrentweight()
        backendserver := weightserverroundrobin.getbackendserver()
        if backendserver.servername != expectservername {
            t.errorf("%v.%v.expect:%v, actual:%v", t.name(), ii, expectservername, backendserver.servername)
            return
        }
    }
}

运行单元测试，观察运行结果是否符合算法设计的预期

=== run   testnewweightserverroundrobin
(a, b, c)
(0, 0, 0)
(5, 3, 1)
(-4, 3, 1)
(1, 6, 2)
(1, -3, 2)
(6, 0, 3)
(-3, 0, 3)
(2, 3, 4)
(2, 3, -5)
(7, 6, -4)
(-2, 6, -4)
(3, 9, -3)
(3, 0, -3)
(8, 3, -2)
(-1, 3, -2)
(4, 6, -1)
(4, -3, -1)
(9, 0, 0)
--- pass: testnewweightserverroundrobin (0.00s)
pass

参考材料：

到此这篇关于使用golang实现加权负载均衡算法的文章就介绍到这了,更多相关golang负载均衡算法内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！