目录
- 一，nginx 负载均衡的轮询 （round-robin）
- 1. nginx 中的配置
- 2. 简单介绍
- 3. 特点
- 4. 实现 （这里使用golang模拟实现）
- 5. 测试
- 二，nginx 负载均衡的加权轮询 （weighted-round-robin）
- 1. nginx 配置
- 2. 加权算法简介-特点
- 3. 算法说明
- 4. 简单举例
- 5. 代码实现
- 6. 测试验证
最近在看一些 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加权轮询内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！
