个人中心
gpt4 book ai didi

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

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 29 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章使用Golang实现加权负载均衡算法的实现代码由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

背景描述

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

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

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

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

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

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

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

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

如下图所示:

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

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

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

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

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

算法设计 。

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

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

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

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

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

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

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

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

算法实现

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
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, ", " ))
}

写一个单测进行验证 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
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 。

参考材料:

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

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

原文链接：https://www.cnblogs.com/voipman/p/15020713.html 。

最后此篇关于使用Golang实现加权负载均衡算法的实现代码的文章就讲到这里了,如果你想了解更多关于使用Golang实现加权负载均衡算法的实现代码的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

29 4 0
文章推荐： Python读写文件基础知识点
文章推荐： 13个 Linux 桌面的最佳深色 GTK 主题
文章推荐： python django框架中使用FastDFS分布式文件系统的安装方法
文章推荐： Linux 修复 Spectre V1 SWAPGS 漏洞，代码来自阿里工程师
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com