使用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

参考材料：

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

关于使用Golang实现加权负载均衡算法的文章就介绍至此，更多相关Golang负载均衡算法内容请搜索编程宝库以前的文章，希望大家多多支持编程宝库！

 概述Golang 是一个跨平台的新生编程语言. 今天小白就带大家一起携手走进 Golang 的世界.  Go 语法基础Go 程序可以由多个标记组成: 关键字 标识符 常量 ...