脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Golang - Go 实现 Nginx 加权轮询算法的方法步骤

Go 实现 Nginx 加权轮询算法的方法步骤

2022-01-20 00:42一只小蜗牛 Golang

本文主要介绍了Go 实现 Nginx 加权轮询算法的方法步骤，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下

最近在看一些 getway 相关的资料，发现有关 Nginx 负载均衡的算法有点多，但是有点乱，所以整理下。。。如有不对地方请指出。

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

在说加权轮询之前我们先来简单的说一下轮询

1. nginx 中的配置

?
1
2
3
4
5
6
7
8
9
10
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模拟实现）

?
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
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. 测试

简单调用下方法看看结果

?
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
/**
 * @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 配置

?
1
2
3
4
5
6
7
8
9
10
11
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
1 [serverA=4, serverB=2, serverC=1] serverA [serverA=1, serverB=4, serverC=2]
2 [serverA=1, serverB=4, serverC=2] serverB [serverA=5, serverB=-1, serverC=3]
3 [serverA=5, serverB=-1, serverC=3] serverA [serverA=2, serverB=1, serverC=4]
4 [serverA=2, serverB=1, serverC=4] serverA [serverA=-1, serverB=3, serverC=5]
5 [serverA=-1, serverB=3, serverC=5] serverC [serverA=3, serverB=5, serverC=-1]
6 [serverA=3, serverB=5, serverC=-1] serverA [serverA=0, serverB=7, serverC=0]
7 [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实现下上面的逻辑：

?
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
67
68
69
70
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. 测试验证

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
 * @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

到此这篇关于Go 实现 Nginx 加权轮询算法的方法步骤的文章就介绍到这了,更多相关Go 实现Nginx加权轮询内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://segmentfault.com/a/1190000039799210

  • Nginx
  • Go
  • 加权轮询

    • 延伸 · 阅读

    精彩推荐
    • Golanggolang 通过ssh代理连接mysql的操作

      golang 通过ssh代理连接mysql的操作

      这篇文章主要介绍了golang 通过ssh代理连接mysql的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      a165861639710342021-03-08
    • Golanggolang如何使用struct的tag属性的详细介绍

      golang如何使用struct的tag属性的详细介绍

      这篇文章主要介绍了golang如何使用struct的tag属性的详细介绍，从例子说起，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看...

      Go语言中文网11352020-05-21
    • Golanggo语言制作端口扫描器

      go语言制作端口扫描器

      本文给大家分享的是使用go语言编写的TCP端口扫描器，可以选择IP范围，扫描的端口，以及多线程，有需要的小伙伴可以参考下。 ...

      脚本之家3642020-04-25
    • GolangGolang通脉之数据类型详情

      Golang通脉之数据类型详情

      这篇文章主要介绍了Golang通脉之数据类型，在编程语言中标识符就是定义的具有某种意义的词，比如变量名、常量名、函数名等等，Go语言中标识符允许由...

      羌4272021-11-24
    • GolangGolang中Bit数组的实现方式

      Golang中Bit数组的实现方式

      这篇文章主要介绍了Golang中Bit数组的实现方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      天易独尊11682021-06-09
    • Golanggolang json.Marshal 特殊html字符被转义的解决方法

      golang json.Marshal 特殊html字符被转义的解决方法

      今天小编就为大家分享一篇golang json.Marshal 特殊html字符被转义的解决方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧 ...

      李浩的life12792020-05-27
    • Golanggo日志系统logrus显示文件和行号的操作

      go日志系统logrus显示文件和行号的操作

      这篇文章主要介绍了go日志系统logrus显示文件和行号的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      SmallQinYan12302021-02-02
    • Golanggolang的httpserver优雅重启方法详解

      golang的httpserver优雅重启方法详解

      这篇文章主要给大家介绍了关于golang的httpserver优雅重启的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，...

      helight2992020-05-14
    最近更新
    编辑推荐
    阅读排行
    热门标签
    gosublime 　 指针类型 　 new() 　 make() 　 并发模型 　 切片 　 静态WEB服务器 　 端口扫描器 　 Go语言入门教程 　 基础语 　 Slices 　 Maps 　 Golang编程 　 panic 　 接受者类型 　 嵌入类型 　 Slice 　 Golang教程 　 Golang项目 　 内存模型 　 开发环境搭建 　 大小端判断 　 代码组织结构 　 复合类型 　 GOPATH 　 工作目录 　 实例 　 struct类型 　 并发技术 　 buffered 　
    © 2019-2023 脚本之家 | 服务器之家(www.zzvips.com)旗下站点 版权所有关于我们联系我们版权申明网站地图