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

 更新时间:2021年12月08日 11:33:30   作者:一只小蜗牛  
本文主要介绍了Go 实现 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加权轮询算法 的逻辑实现

  • 轮询所有节点,计算当前状态下所有的节点的 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实现下上面的逻辑:

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

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

您可能感兴趣的文章:

相关文章

  • Go语言基础函数基本用法及示例详解

    Go语言基础函数基本用法及示例详解

    这篇文章主要为大家介绍了Go语言基础函数基本用法及示例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步早日升职加薪
    2021-11-11
  • Golang 实现插入排序的方法示例(2种)

    Golang 实现插入排序的方法示例(2种)

    这篇文章主要介绍了Golang 实现插入排序的方法示例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2020-02-02
  • golang中定时器cpu使用率高的现象详析

    golang中定时器cpu使用率高的现象详析

    这篇文章主要给大家介绍了关于golang中定时器cpu使用率高的现象的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧。
    2018-04-04
  • go语言使用scp的方法实例分析

    go语言使用scp的方法实例分析

    这篇文章主要介绍了go语言使用scp的方法,实例分析了go语言调用scp命令的使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下
    2015-03-03
  • golang中xorm的基本使用说明

    golang中xorm的基本使用说明

    这篇文章主要介绍了golang中xorm的基本使用说明,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
    2020-12-12
  • golang中接口对象的转型两种方式

    golang中接口对象的转型两种方式

    这篇文章主要介绍了golang中接口对象的转型方式,大家都知道接口对象的转型有两种方式,文中通过示例代码给大家介绍的非常详细,需要的朋友可以参考下
    2021-10-10
  • 利用Go Plugin实现插件化编程的简单方法

    利用Go Plugin实现插件化编程的简单方法

    Golang官方提供了plugin模块,该模块可以支持插件开,下面这篇文章主要给大家介绍了关于如何利用Go Plugin实现插件化编程的相关资料,需要的朋友可以参考下
    2021-10-10
  • 详解golang 模板(template)的常用基本语法

    详解golang 模板(template)的常用基本语法

    这篇文章主要介绍了详解golang 模板(template)的常用基本语法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2019-08-08
  • 深入解析golang中的标准库flag

    深入解析golang中的标准库flag

    Go语言内置的flag包实现了命令行参数的解析,flag包使得开发命令行工具更为简单,下面通过本文给大家详细介绍下golang中的标准库flag相关知识,感兴趣的朋友一起看看吧
    2021-11-11
  • Go遍历struct,map,slice的实现

    Go遍历struct,map,slice的实现

    本文主要介绍了Go语言遍历结构体、切片和字典的方法,对大家的学习具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2021-06-06

最新评论