轮询算法round-robin是很基础的负载均衡算法,实际应用中wrr更为常见,但一般不需要自己实现,因为一般需要rr的场景,都已经在基础设施层面进行了支持,比如lvs或nginx通过配置即可实现,但业务上偶尔也需要自己实现负载均衡,所以有必要了解一下其技术原理。
谈到wrr的应用场景,一般是服务器配置存在差异时,比如集群里有一个2C4G和一个4C8G,那么我们希望4C8G能承担更多的业务请求。或者是,我们希望通过无条件的流量分发,在集群的一台机器上小范围的导入一些流量进行一些实验。我碰到的场景是,在网关层面对业务方的集群迁移进行支持,也属于第二种场景。
原理
权重可以看做期望目标出现的概率,比如两个节点A、B,权重分别是100和50,那么等于在说,我们期望66.7%的请求由A处理,剩余33.3%的请求由B处理。
一种比较挫的实现方式,是将所有节点按照权重比例分布在一个离散的区间内,比如1-100,然后使用随机数生成100以内的自然数,如果随机数0<x<=66就由A处理请求,如果66<x<=100就由B处理请求。这种方法看似实现容易,但致命缺陷是依赖随机数的有效性,而大部分场景我们使用的都是伪随机数。此外集群数量伸缩时,会出现精度问题。
在wiki中提供了两种wrr的实现方式,分别是classic wrr和interleaved wrr,简称为WRR和IWRR,他们的区别可以通过下图来了解一下。
![](https://i-blog.csdnimg.cn/blog_migrate/075b1639795f30df7c3630862774d0d3.png#pic_center)
-
WRR
初始权重水位c设置为0,外循环遍历所有的节点,内循环遍历当前节点的水位值,如果权重水位c在该值内,则使用当前节点处理请求,同时c值递增。直到c大于当前节点的权重值,重置c为0,再对下一个节点执行内循环。 -
IWRR
外循环递增水位值,内循环遍历所有节点,如果当前水位值低于节点权重值,则由当前节点处理请求。遍历完所有节点后,递增水位值后再对所有节点进行遍历。
通过对比可以发现,如果集群中的节点权重相近,且值都比较高,则使用IWRR会明显的避免节点负载的尖刺情况,节点越多越明显。但这种情况会随着节点权重差异的增加而消退。极端假设集群中有一个节点权重是100,其他节点权重都是1,那么IWRR和WRR的效果是一样的。
此外,在IWRR的实践中,一般会用集群内节点权重值的最大公约数(gcd),来作为外循环水位值的递增步长,这样可以减轻少量权重较低节点的摆动。比如集群内有4个权重为100的节点ABCD,1个权重为20的节点E,当步长为1时,节点E会在开始的20个周期内执行20次,然后在剩下的80个周期内无事可做。如果使用gcd来作为步长,最多隔5个周期就会处理一次请求。
![](https://i-blog.csdnimg.cn/blog_migrate/3f1773b18e6c3589cf9cdc195937720f.png#pic_center)
实践
这里用go实现了一个类IWRR的负载均衡器,区别在于横向扫描的方向是自顶向下的
package balancer
import (
"errors"
)
var (
ErrSuccess = error(nil)
ErrNoTarget = errors.New("no target to run")
)
type ITarget interface {
Call() error // 实际工作负载方法
Weight() int // 当前target权重
}
type Balancer struct {
targets []ITarget // 目标集
maxweight int // 当前集群中的最大权重
current int // 当前权重水位
stride int // 权重步长(最大公约数)
index int // 当前目标索引
}
func (b *Balancer) AddTarget(t ITarget) {
// 更新目标集
b.targets = append(b.targets, t)
// 更新步长
b.stride = t.Weight()
b.maxweight = t.Weight()
for _, v := range b.targets {
b.stride = b.gcd(b.stride, v.Weight())
// 保存目标集中最大权重值
if v.Weight() > b.maxweight {
b.maxweight = v.Weight()
}
}
// 更新当前水位
b.current = b.maxweight
// 更新当前索引位置
b.index = 0
}
func (b *Balancer) Call() error {
if len(b.targets) == 0 {
return ErrNoTarget
}
// 查找满足当前权重水位的target
i := b.index
for {
// 取得target对象
target := b.targets[i]
i++
if target.Weight() >= b.current {
target.Call()
break
}
if i == len(b.targets) {
// 重置索引、降低水位
i, b.current = 0, b.current-b.stride
if b.current <= 0 {
// 重置当前水位
b.current = b.maxweight
}
}
}
if i == len(b.targets) {
// 重置索引、降低水位
i, b.current = 0, b.current-b.stride
if b.current <= 0 {
// 重置当前水位
b.current = b.maxweight
}
}
b.index = i
return ErrSuccess
}
// 辗转相除求最大公约数
func (b *Balancer) gcd(m, n int) int {
if n == 0 {
return m
}
return b.gcd(n, m%n)
}
使用方法如下:这里创建了三个节点,权重分别是100、50、20,期望的分布是10:5:2,所以在后面的循环里打印了17次。
package main
import (
"bournex/weightbalance/balancer"
"fmt"
)
// 虚构的集群目标节点
type Target struct {
name string
weight int
}
// 虚构的执行过程
func (t Target) Call() error {
fmt.Printf("%s", t.name)
return nil
}
// 获取当前目标的权重值
func (t Target) Weight() int {
return t.weight
}
func main() {
var (
x = Target{name: "A", weight: 100}
y = Target{name: "B", weight: 50}
z = Target{name: "C", weight: 20}
b balancer.Balancer
)
if err := b.Call(); err != nil {
fmt.Println(err.Error())
}
b.AddTarget(x)
b.AddTarget(y)
for i := 0; i < 17; i++ {
b.Call()
}
fmt.Println()
b.AddTarget(z)
for i := 0; i < 17; i++ {
b.Call()
}
fmt.Println()
}
执行输出如下
# ./app
no target to run
AABAABAABAABAABAA
AAAAAABABABABCABC
第一行打印由于还没有添加Target,所以当前集群没有可以执行任务的节点,输出error内容"no target to run"。
第二行是节点AB处理负载的情况,以AAB为模式循环处理请求。满足100:50的负载均衡需求。
第三行是添加了节点Z的结果,总共输出17次,A10次,B5次,C2次
作为对比,如果采用1替换gcd作为步长实现IWRR,则它的模式是这样的:
ABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABC
ABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
可以看到,C要隔很久才会再次出现