go实现四大负载均衡策略

已于 2022-11-20 14:57:41 修改
阅读量527 收藏 1
点赞数 1
文章标签： 负载均衡 服务器 运维
于 2022-11-20 14:56:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50887645/article/details/127948858
版权

目录

一、四大负载均衡策略

1.随机负载

2.轮询负载

3.加权负载

4.一致性hash负载

二.具体实现

1.随机负载

2.轮询负载

3.加权负载

4.一致性hash负载

一、四大负载均衡策略

1.随机负载

随机挑选目标服务器IP

2.轮询负载

ABC三台服务器，ABCABC依次轮询

3.加权负载

给目标设置访问权重，按照权重轮询

4.一致性hash负载

请求固定URL访问指定IP

二.具体实现

1.随机负载

    random.go

package load_balance

import (
	"errors"
	"fmt"
	"math/rand"
	"strings"
)

type RandomBalance struct {
	curIndex int
	rss      []string
}

func (r *RandomBalance) Add(params ...string) error {
	if len(params) == 0 {
		return errors.New("param len 1 at least")
	}
	addr := params[0]
	r.rss = append(r.rss, addr)
	return nil
}

func (r *RandomBalance) Next() string {
	if len(r.rss) == 0 {
		return ""
	}
	r.curIndex = rand.Intn(len(r.rss))
	return r.rss[r.curIndex]
}

func (r *RandomBalance) Get(key string) (string, error) {
	return r.Next(), nil
}

func (r *RandomBalance) SetConf(conf LoadBalanceConf) {
	r.conf = conf
}

func (r *RandomBalance) Update() {
	if conf, ok := r.conf.(*LoadBalanceZkConf); ok {
		fmt.Println("Update get conf:", conf.GetConf())
		r.rss = []string{}
		for _, ip := range conf.GetConf() {
			r.Add(strings.Split(ip, ",")...)
		}
	}
	if conf, ok := r.conf.(*LoadBalanceCheckConf); ok {
		fmt.Println("Update get conf:", conf.GetConf())
		r.rss = nil
		for _, ip := range conf.GetConf() {
			r.Add(strings.Split(ip, ",")...)
		}
	}
}

    测试类     random_test.go

package load_balance

import (
	"fmt"
	"testing"
)

func TestRandomBalance(t *testing.T) {
	rb := &RandomBalance{}
	rb.Add("127.0.0.1:2003") //0
	rb.Add("127.0.0.1:2004") //1
	rb.Add("127.0.0.1:2005") //2
	rb.Add("127.0.0.1:2006") //3
	rb.Add("127.0.0.1:2007") //4

	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())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
}

2.轮询负载

    round_robin.go

package load_balance

import (
	"errors"
	"fmt"
	"strings"
)

type RoundRobinBalance struct {
	curIndex int
	rss      []string
}

func (r *RoundRobinBalance) Add(params ...string) error {
	if len(params) == 0 {
		return errors.New("param len 1 at least")
	}
	addr := params[0]
	r.rss = append(r.rss, addr)
	return nil
}

func (r *RoundRobinBalance) Next() string {
	if len(r.rss) == 0 {
		return ""
	}
	lens := len(r.rss) //5
	if r.curIndex >= lens {
		r.curIndex = 0
	}
	curAddr := r.rss[r.curIndex]
	r.curIndex = (r.curIndex + 1) % lens
	return curAddr
}

func (r *RoundRobinBalance) Get(key string) (string, error) {
	return r.Next(), nil
}

func (r *RoundRobinBalance) SetConf(conf LoadBalanceConf) {
	r.conf = conf
}

func (r *RoundRobinBalance) Update() {
	if conf, ok := r.conf.(*LoadBalanceZkConf); ok {
		fmt.Println("Update get conf:", conf.GetConf())
		r.rss = []string{}
		for _, ip := range conf.GetConf() {
			r.Add(strings.Split(ip, ",")...)
		}
	}
	if conf, ok := r.conf.(*LoadBalanceCheckConf); ok {
		fmt.Println("Update get conf:", conf.GetConf())
		r.rss = nil
		for _, ip := range conf.GetConf() {
			r.Add(strings.Split(ip, ",")...)
		}
	}
}

    测试类     round_robin_test.go 

package load_balance

import (
	"fmt"
	"testing"
)

func Test_main(t *testing.T) {
	rb := &RoundRobinBalance{}
	rb.Add("127.0.0.1:2003") //0
	rb.Add("127.0.0.1:2004") //1
	rb.Add("127.0.0.1:2005") //2
	rb.Add("127.0.0.1:2006") //3
	rb.Add("127.0.0.1:2007") //4

	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())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
}

3.加权负载

    weight_round_robin.go 

package load_balance

import (
	"errors"
	"fmt"
	"strconv"
	"strings"
)

type WeightRoundRobinBalance struct {
	curIndex int
	rss      []*WeightNode
	rsw      []int
}

type WeightNode struct {
	addr            string
	weight          int //权重值
	currentWeight   int //节点当前权重
	effectiveWeight int //有效权重
}

func (r *WeightRoundRobinBalance) Add(params ...string) error {
	if len(params) != 2 {
		return errors.New("param len need 2")
	}
	parInt, err := strconv.ParseInt(params[1], 10, 64)
	if err != nil {
		return err
	}
	node := &WeightNode{addr: params[0], weight: int(parInt)}
	node.effectiveWeight = node.weight
	r.rss = append(r.rss, node)
	return nil
}

func (r *WeightRoundRobinBalance) Next() string {
	total := 0
	var best *WeightNode
	for i := 0; i < len(r.rss); i++ {
		w := r.rss[i]
		//step 1 统计所有有效权重之和
		total += w.effectiveWeight

		//step 2 变更节点临时权重为的节点临时权重+节点有效权重
		w.currentWeight += w.effectiveWeight

		//step 3 有效权重默认与权重相同，通讯异常时-1, 通讯成功+1，直到恢复到weight大小
		if w.effectiveWeight < w.weight {
			w.effectiveWeight++
		}
		//step 4 选择最大临时权重点节点
		if best == nil || w.currentWeight > best.currentWeight {
			best = w
		}
	}
	if best == nil {
		return ""
	}
	//step 5 变更临时权重为 临时权重-有效权重之和
	best.currentWeight -= total
	return best.addr
}

func (r *WeightRoundRobinBalance) Get(key string) (string, error) {
	return r.Next(), nil
}

func (r *WeightRoundRobinBalance) SetConf(conf LoadBalanceConf) {
	r.conf = conf
}

func (r *WeightRoundRobinBalance) Update() {
	if conf, ok := r.conf.(*LoadBalanceZkConf); ok {
		fmt.Println("WeightRoundRobinBalance get conf:", conf.GetConf())
		r.rss = nil
		for _, ip := range conf.GetConf() {
			r.Add(strings.Split(ip, ",")...)
		}
	}
	if conf, ok := r.conf.(*LoadBalanceCheckConf); ok {
		fmt.Println("WeightRoundRobinBalance get conf:", conf.GetConf())
		r.rss = nil
		for _, ip := range conf.GetConf() {
			r.Add(strings.Split(ip, ",")...)
		}
	}
}

    测试类     weight_round_robin_test.go 

package load_balance

import (
	"fmt"
	"testing"
)

func TestLB(t *testing.T) {
	rb := &WeightRoundRobinBalance{}
	rb.Add("127.0.0.1:2003", "4") //0
	rb.Add("127.0.0.1:2004", "3") //1
	rb.Add("127.0.0.1:2005", "2") //2

	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())
	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())
}

4.一致性hash负载

    consistent_hash.go 

package load_balance

import (
	"errors"
	"fmt"
	"hash/crc32"
	"sort"
	"strconv"
	"strings"
	"sync"
)

type Hash func(data []byte) uint32

type UInt32Slice []uint32

func (s UInt32Slice) Len() int {
	return len(s)
}

func (s UInt32Slice) Less(i, j int) bool {
	return s[i] < s[j]
}

func (s UInt32Slice) Swap(i, j int) {
	s[i], s[j] = s[j], s[i]
}

type ConsistentHashBanlance struct {
	mux      sync.RWMutex
	hash     Hash
	replicas int               //复制因子
	keys     UInt32Slice       //已排序的节点hash切片
	hashMap  map[uint32]string //节点哈希和Key的map,键是hash值，值是节点key
}

func NewConsistentHashBanlance(replicas int, fn Hash) *ConsistentHashBanlance {
	m := &ConsistentHashBanlance{
		replicas: replicas,
		hash:     fn,
		hashMap:  make(map[uint32]string),
	}
	if m.hash == nil {
		//最多32位,保证是一个2^32-1环
		m.hash = crc32.ChecksumIEEE
	}
	return m
}

// 验证是否为空
func (c *ConsistentHashBanlance) IsEmpty() bool {
	return len(c.keys) == 0
}

// Add 方法用来添加缓存节点，参数为节点key，比如使用IP
func (c *ConsistentHashBanlance) Add(params ...string) error {
	if len(params) == 0 {
		return errors.New("param len 1 at least")
	}
	addr := params[0]
	c.mux.Lock()
	defer c.mux.Unlock()
	// 结合复制因子计算所有虚拟节点的hash值，并存入m.keys中，同时在m.hashMap中保存哈希值和key的映射
	for i := 0; i < c.replicas; i++ {
		hash := c.hash([]byte(strconv.Itoa(i) + addr))
		c.keys = append(c.keys, hash)
		c.hashMap[hash] = addr
	}
	// 对所有虚拟节点的哈希值进行排序，方便之后进行二分查找
	sort.Sort(c.keys)
	return nil
}

// Get 方法根据给定的对象获取最靠近它的那个节点
func (c *ConsistentHashBanlance) Get(key string) (string, error) {
	if c.IsEmpty() {
		return "", errors.New("node is empty")
	}
	hash := c.hash([]byte(key))

	// 通过二分查找获取最优节点，第一个"服务器hash"值大于"数据hash"值的就是最优"服务器节点"
	idx := sort.Search(len(c.keys), func(i int) bool { return c.keys[i] >= hash })

	// 如果查找结果 大于 服务器节点哈希数组的最大索引，表示此时该对象哈希值位于最后一个节点之后，那么放入第一个节点中
	if idx == len(c.keys) {
		idx = 0
	}
	c.mux.RLock()
	defer c.mux.RUnlock()
	return c.hashMap[c.keys[idx]], nil
}

func (c *ConsistentHashBanlance) SetConf(conf LoadBalanceConf) {
	c.conf = conf
}

func (c *ConsistentHashBanlance) Update() {
	if conf, ok := c.conf.(*LoadBalanceZkConf); ok {
		fmt.Println("Update get conf:", conf.GetConf())
		c.keys = nil
		c.hashMap = nil
		for _, ip := range conf.GetConf() {
			c.Add(strings.Split(ip, ",")...)
		}
	}
	if conf, ok := c.conf.(*LoadBalanceCheckConf); ok {
		fmt.Println("Update get conf:", conf.GetConf())
		c.keys = nil
		c.hashMap = map[uint32]string{}
		for _, ip := range conf.GetConf() {
			c.Add(strings.Split(ip, ",")...)
		}
	}
}

    测试类     consistent_hash_test.go 

package load_balance

import (
	"fmt"
	"testing"
)

func TestNewConsistentHashBanlance(t *testing.T) {
	rb := NewConsistentHashBanlance(10, nil)
	rb.Add("127.0.0.1:2003") //0
	rb.Add("127.0.0.1:2004") //1
	rb.Add("127.0.0.1:2005") //2
	rb.Add("127.0.0.1:2006") //3
	rb.Add("127.0.0.1:2007") //4

	//url hash
	fmt.Println(rb.Get("http://127.0.0.1:2002/base/getinfo"))
	fmt.Println(rb.Get("http://127.0.0.1:2002/base/error"))
	fmt.Println(rb.Get("http://127.0.0.1:2002/base/getinfo"))
	fmt.Println(rb.Get("http://127.0.0.1:2002/base/changepwd"))

	//ip hash
	fmt.Println(rb.Get("127.0.0.1"))
	fmt.Println(rb.Get("192.168.0.1"))
	fmt.Println(rb.Get("127.0.0.1"))
}

WyWuu
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
golang 微服务的负载均衡
m0_37322399的博客
05-14 1096
上次我们说了一下 微服务的容错处理，是用的 断路器这一次我们来一起看看 微服务的负载均衡是如何做的负载均衡是什么呢？他能够将大量的请求，根据负载均衡算法，将不同的请求分发到多台服务器上进行处理，使得所有的服务器负载都维持在一个高效稳定的状态，进而可以提高系统的吞吐量，和保证系统的可用性例如我们的访问服务器是这样的用户 – 网络 – 服务器 – 数据库那么，如果这一个服务器的请求数很高，超过了服务器能能处理的极限，自身无法及时响应的时候，则会出现异常，甚至无法连接，用户就无法得到及时的期望结果那么我们至少
golang grpc 负载均衡的方法
01-03
微服务架构里面，每个服务都会有很多节点，如果流量分配不均匀，会造成资源的浪费，甚至将一些机器压垮，这个时候就需要负载均衡，最简单的一种策略就是轮询，顺序依次选择不同的节点访问。 grpc 在客户端提供了负载...
Go语言实现常见的负载均衡算法
m0_52530105的博客
06-16 404
​ 负载均衡建立在现有网络结构之上，它提供了一种廉价有效透明的方法扩展网络设备和服务器的带宽、增加吞吐量、加强网络数据处理能力、提高网络的灵活性和可用性。​ 负载均衡*（Load Balance）*其意思就是分摊到多个操作单元上进行执行，例如Web服务器、FTP服务器、企业关键应用服务器和其它关键任务服务器等，从而共同完成工作任务。负载均衡的常见算法有随机负载均衡加权随机负载均衡轮询负载均衡加权负载均衡加权平滑轮询负载均衡一致性hash负载均衡。
15. Go实现负载均衡算法
YouMing_Li的博客
09-26 189
在实际工作中，为了避免单点故障，一个服务一般都是会部署多个实例的，那么请求来的时候，到底使用哪个服务器处理请求呢？这便涉及到了负载均衡算法了。
2024年Go最新Round-Robin负载均衡算法及其实现原理_madt core round robin(2)，一招彻底弄懂
2401_84904408的博客
05-14 842
轮询调度算法以及权重轮询调度算法的特点是实现起来比较简洁，并且实用。目前几乎所有的负载均衡设备均提供这种功能。
go 进阶 go-zero相关: 六. 负载均衡与请求的发出
qq_29799655的博客
05-11 484
在调用p2cPicker的pick()方法中首先会将节点封装为SubConn, 会执行p2cPicker下的choose()选择指定节点,在choose()方法内部会调用subConn的load()方法计算节点的负载情况,选择最低的一个,查看该方法 参考博客
GO+Nginx实现服务器的高并发+负载均衡（超级简单，开箱即用）
qq_41866988的博客
08-04 1086
Go部分的代码，我没怎么详细讲，大概意思大家应该能看懂，里面我还使用了令牌桶来对请求当前api的连接数做了限制，可以在Nginx的ip限制下再做一次限制，可以简单达到下面的两个功能保护服务器资源：通过限制请求数，可以防止服务器过载。当同时接收到大量的请求时，服务器的资源（如 CPU、内存和网络带宽）可能会耗尽，导致性能下降甚至崩溃。通过限制请求数，可以确保服务器能够合理地处理请求，避免资源耗尽。提高系统稳定性：通过限制请求数，可以防止某些恶意用户或恶意程序通过发送大量请求来攻击服务器。
Django高并发负载均衡实现原理详解
12-20
Django高并发负载均衡实现原理详解 在面对高并发访问时，单一服务器的性能往往不足以应对，这时就需要采用服务器集群来提升网站的处理能力。负载均衡是解决这一问题的关键技术，其目标是确保所有后端服务器能充分...
Go接口练习之负载均衡算法
01-07
Web请求中，申请服务，为了避免多个服务都集中运行在一个服务器山，于是有了负载均衡，本文撰写了随机算法和轮渡(顺序)算法 balance包 balance.go package balance // 负载均衡接口 type Balance interface{ ...
Golang_Godhcplb是facebook为DHCP实现的负载均衡器.zip
最新发布
05-26
总的来说，"Golang_Godhcplb"是Facebook为了解决大规模网络环境中DHCP服务的负载问题而设计的解决方案，利用Go语言的优势实现了高效、可靠的负载均衡。通过深入研究和使用这个项目，我们可以学习到如何用Go语言构建...
go 进阶 go-zero相关: 三. go-zero 微服务基础示例
qq_29799655的博客
05-10 1510
编译命令执行完毕后,会生成一下代码:其中 types/XXX/xxx.pb.go文件与types/XXX/xxx_grpc.pb.go是通过proto生成的,参考grpc“xxx.pb.go”: 内部是编写这个rpc服务时自定义的结构体相关处理“xxx_grpc.pb.go”: 内部是启动这个rpc服务端,启动访问这个rpc客户端的相关代码通过go-zero生成的其中user.proto是用来生成rpc服务的IDL文件。
Go-sslb-Golang超级简单的负载均衡只是一个小项目来达到某种性能
08-14
sslb - Golang超级简单的负载均衡,只是一个小项目来达到某种性能
Go-GoLB一个负载均衡器
08-14
roundrobin：平滑加权圆形方法 chash：cosistent散列方法 balancer：多个LB实例，被动健康检查，SSL卸载 controller：动态配置，用于在运行时启动/停止/添加/删除LB的REST API statistics：HTTP方法/路径/代码/字节
go-zero微服务框架
weixin_42094245的博客
06-14 4141
Go-Zero 是一个基于 Golang 的微服务框架，可以帮助开发者快速、高效地构建高性能、高可用的分布式应用系统。RPC 框架和 API 网关，支持多种协议和格式，如 gRPC、HTTP、JSON、Thrift 等；支持微服务通讯和服务治理，包括服务发现、负载均衡、链路追踪、熔断和限流等；支持数据存储和访问，包括 MySQL、Redis、MongoDB 等；支持日志和监控，包括 Prometheus、Grafana 和 Graphite 等；
go-zero源码阅读-负载均衡(下)#第六期
weixin_47218612的博客
04-10 1149
一致性哈希 一致性哈希主要针对的是缓存服务做负载均衡，以保证缓存节点变更后缓存失效过多，导致缓存穿透，从而把数据库打死。 一致性哈希原理可以参考这篇文章图解一致性哈希算法，细节剖析本文不再赘述。 我们来看看其核心算法 // service node 结构体定义 type ServiceNode struct { Ip string Port string Index int } // 返回service node实例 func NewServiceNode(ip, port string)
Go实现简单负载均衡
360技术
12-11 1409
奇技指南今天小编为大家分享一篇关于Go实现简单的负载均衡器的文章，只是对负载均衡进行了基础的功能实现，有助于对负载均衡的理解。如果有兴趣，也可以以此为基础进行功能扩展，希望能对大家有所帮...
负载均衡之随机法
vsallenfans的博客
04-17 1411
​ 负载均衡(LoadBalance)，它的职责是将网络请求，或者其他形式的负载“均摊”到不同的机器上。避免集群中部分服务器压力过大，而另一些服务器比较空闲的情况。通过负载均衡，可以让每台服务器获取到适合自己处理能力的请求。 ​ 常见的负载均衡的实现方法有多种，如随机、轮询、hash一致性等。本文使用随机法实现负载均衡。 ​ 随机数法就是几个数中随机获取一个数字，然后获取这个数据对应的服务器。 /...
Go语言开发的13个微服务框架，你知道几个？
gb4215287的博客
03-05 1742
go语言相关框架
使用go来实现一个简单的负载均衡
哇哦~
11-12 1586
How does our simple load balancer work 负载均衡有不同的负载策略 Round Robin：轮询，就是每个请求依次打到每个服务商去 Weighted Round Robin：加权轮询，额外加了权重 Least Connections：最少连接，优先请求到连接数最少的服务器上去 补充的其它策略参考https://blog.csdn.net/qq_2...
golang select 实现负载均衡
05-18
在 Go 中，可以使用 select 语句实现负载均衡。具体地，可以将请求分发给多个处理器进行处理，以实现负载均衡的效果。以下是一个简单的示例代码： ```go func main() { numWorkers := 3 jobs := make(chan int, 5...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值