• 【算法】使用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)
    ", 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)
    ")
        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

    done.

    祝玩的开心~

  • 相关阅读:
    try抛出异常(ReperenceError/SyntaxError)
    原型,原型链
    katalon下载文件后,点击文件并断言
    ES5的使用eval,()
    继承(原型)
    es数据插入和查询
    【记者团】平台运营与管理 MrFlySand
    油猴脚本 MrFlySand
    手机给笔记本投屏? MrFlySand
    python练习题 MrFlySand
  • 原文地址:https://www.cnblogs.com/voipman/p/15020713.html
Copyright © 2020-2023  润新知