【微服务网关——负载均衡】

news2024/11/17 16:25:35

1. 四大负载均衡策略

  • 随机负载
    • 随机挑选目标服务器IP
  • 轮询负载
    • ABC三台服务器，ABCABC依次轮询
  • 加权负载
    • 给目标设置访问权重，按照权重轮询
  • 一致性hash负载
    • 请求固定URL访问指定IP

2.随机负载均衡

可以通过random函数来随机选择一个ip

2.1 代码实现

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
}

2.2 测试代码

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.3 测试结果

在这里插入图片描述

3.轮询负载均衡

按一定顺序进行轮询

3.1 代码实现

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
}

3.2 测试代码

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.3 测试结果

在这里插入图片描述

4.加权负载均衡

  • Weight
    • 初始化时对节点约定的权重
  • currentWeight
    • 节点的临时权重，每轮都会变化
  • effectiveWeight
    • 节点有效权重，默认与Weight相同
    • 当发生故障时，effectiveWeight会减少
  • totalWeight
    • 所有节点有效权重之和：sum(effectiveWeight)

根据不同的权重给于不同的概率，权重往往与地域、服务器的性能相关。
在这里插入图片描述

4.1 代码实现

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
}

4.2 测试代码

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.3 测试结果

在这里插入图片描述

5.一致性负载均衡

  • 一致性Hash指标
    • 单调性
    • 平衡性
    • 分散性

链接: 一致性负载均衡理论介绍

5.1 代码实现

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
}

5.2 测试代码

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

5.3 测试结果

在这里插入图片描述

6.为代理添加负载均衡

package main

import (
	"bytes"
	"github.com/e421083458/gateway_demo/proxy/load_balance"
	"io/ioutil"
	"log"
	"net"
	"net/http"
	"net/http/httputil"
	"net/url"
	"strconv"
	"strings"
	"time"
)

var (
	addr      = "127.0.0.1:2002"
	transport = &http.Transport{
		DialContext: (&net.Dialer{
			Timeout:   30 * time.Second, //连接超时
			KeepAlive: 30 * time.Second, //长连接超时时间
		}).DialContext,
		MaxIdleConns:          100,              //最大空闲连接
		IdleConnTimeout:       90 * time.Second, //空闲超时时间
		TLSHandshakeTimeout:   10 * time.Second, //tls握手超时时间
		ExpectContinueTimeout: 1 * time.Second,  //100-continue状态码超时时间
	}
)

func NewMultipleHostsReverseProxy(lb load_balance.LoadBalance) *httputil.ReverseProxy {
	// 请求协调者
	director := func(req *http.Request) {
		// 获取请求者的req.RemoteAddr，根据这个获得下游ip
		nextAddr, err := lb.Get(req.RemoteAddr)
		if err != nil {
			log.Fatal("get next addr fail")
		}
		target, err := url.Parse(nextAddr)
		if err != nil {
			log.Fatal(err)
		}
		targetQuery := target.RawQuery
		req.URL.Scheme = target.Scheme
		req.URL.Host = target.Host
		req.URL.Path = singleJoiningSlash(target.Path, req.URL.Path)
		if targetQuery == "" || req.URL.RawQuery == "" {
			req.URL.RawQuery = targetQuery + req.URL.RawQuery
		} else {
			req.URL.RawQuery = targetQuery + "&" + req.URL.RawQuery
		}
		if _, ok := req.Header["User-Agent"]; !ok {
			req.Header.Set("User-Agent", "user-agent")
		}
	}

	//更改内容
	modifyFunc := func(resp *http.Response) error {
		//请求以下命令：curl 'http://127.0.0.1:2002/error'
		if resp.StatusCode != 200 {
			//获取内容
			oldPayload, err := ioutil.ReadAll(resp.Body)
			if err != nil {
				return err
			}
			//追加内容
			newPayload := []byte("StatusCode error:" + string(oldPayload))
			resp.Body = ioutil.NopCloser(bytes.NewBuffer(newPayload))
			resp.ContentLength = int64(len(newPayload))
			resp.Header.Set("Content-Length", strconv.FormatInt(int64(len(newPayload)), 10))
		}
		return nil
	}

	//错误回调 ：关闭real_server时测试，错误回调
	//范围：transport.RoundTrip发生的错误、以及ModifyResponse发生的错误
	errFunc := func(w http.ResponseWriter, r *http.Request, err error) {
		//todo 如果是权重的负载则调整临时权重
		http.Error(w, "ErrorHandler error:"+err.Error(), 500)
	}

	return &httputil.ReverseProxy{Director: director, Transport: transport, ModifyResponse: modifyFunc, ErrorHandler: errFunc}
}

func singleJoiningSlash(a, b string) string {
	aslash := strings.HasSuffix(a, "/")
	bslash := strings.HasPrefix(b, "/")
	switch {
	case aslash && bslash:
		return a + b[1:]
	case !aslash && !bslash:
		return a + "/" + b
	}
	return a + b
}

func main() {
	rb := load_balance.LoadBanlanceFactory(load_balance.LbWeightRoundRobin)
	if err := rb.Add("http://127.0.0.1:2003/base", "10"); err != nil {
		log.Println(err)
	}
	if err := rb.Add("http://127.0.0.1:2004/base", "20"); err != nil {
		log.Println(err)
	}
	proxy := NewMultipleHostsReverseProxy(rb)
	log.Println("Starting httpserver at " + addr)
	log.Fatal(http.ListenAndServe(addr, proxy))
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1839030.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

信号与系统概述

信号与系统概述

信号是消息的表现形式或传送载体&#xff0c;数学上用函数来表示。信号可以分为确定信号和随机信号、连续时间信号和离散时间信号、周期信号和非周期信号、能量信号和功率信号等。模拟信号是幅度连续的连续时间信号&#xff0c;而数字信号是幅度离散的离散时间信号。对于连续时…
阅读更多...
一键解压，无限可能——BetterZip，您的Mac必备神器！

一键解压，无限可能——BetterZip，您的Mac必备神器！

BetterZip for Mac 是一款高效、智能且安全的解压缩软件&#xff0c;专为Mac用户设计。它提供了直观易用的界面&#xff0c;使用户能够轻松应对各种压缩和解压缩需求。 这款软件不仅支持多种压缩格式&#xff0c;如ZIP、RAR、7Z等&#xff0c;还具备快速解压和压缩文件的能力。…
阅读更多...
解锁TikTok数据潜力——高效获取TikTok视频评论回复数据接口

解锁TikTok数据潜力——高效获取TikTok视频评论回复数据接口

一、引言 在社交媒体蓬勃发展的今天&#xff0c;TikTok已成为全球范围内备受欢迎的短视频平台。为了帮助企业、个人和开发者更好地利用TikTok数据&#xff0c;我们推出了一款全新的接口服务&#xff0c;专注于高效获取TikTok视频评论回复数据。 二、核心功能介绍 高效获取评论…
阅读更多...
储备教师和正式教师的区别是什么？

储备教师和正式教师的区别是什么？

当谈论教育行业的未来&#xff0c;是否曾想过&#xff0c;那些被称为"储备教师"的群体&#xff0c;与我们熟知的"正式教师"之间&#xff0c;有何本质的区别&#xff1f; 储备教师&#xff0c;顾名思义&#xff0c;是学校为了应对未来可能的教学需求而提前招…
阅读更多...
DuDuTalk：智能电子录音工牌在销售场景的应用价值

DuDuTalk：智能电子录音工牌在销售场景的应用价值

在快速变化的市场环境中&#xff0c;销售团队面临着日益激烈的竞争和不断变化的客户需求。为了提升销售效率、优化客户体验并加强团队协作&#xff0c;越来越多的企业开始采用智能电子录音工牌作为销售场景中的关键工具。本文将从多个方面探讨智能电子录音工牌在销售场景中的应…
阅读更多...
渗透测试之存储型跨站脚本攻击（高危）

渗透测试之存储型跨站脚本攻击（高危）

一、定义 跨站脚本攻击&#xff0c;指的是恶意用户往web页面里插入恶意HTML代码。当普通用户访问该web页面&#xff0c;嵌入其中的HTML代码会被执行&#xff0c;从而达到破坏的效果。 二、风险定级 高危 三、可输入的HTML标签示例 图片标签 <img src"#"> 超…
阅读更多...
RIP与OSPF发布默认路由（华为）

RIP与OSPF发布默认路由（华为）

#交换设备 RIP与OSPF发布默认路由 合理使用默认路由可以很大程度上减少本地路由表的大小&#xff0c;并可以较好的隐藏一个网络中的路由信息&#xff0c;保护自身网络的隐秘性 另外如果在同一个路由器两端使用了不同的路由协议&#xff0c;那么如果不做路由引入或者发布默认…
阅读更多...
Excel 找出最大值及其相邻的 N 个成员

Excel 找出最大值及其相邻的 N 个成员

某列都是数值&#xff1a; A1132213464215496973482396101113712491342144015151631171718114719182030212222423252419251326272738283029163012312332333233419351436463723383739384028 请找出最大值及其相邻的 10 个成员&#xff0c;注意越界检查&#xff0c;实际符合条件…
阅读更多...
华宽通成功中标“在星沙”平台智慧后勤板块项目

华宽通成功中标“在星沙”平台智慧后勤板块项目

湖南华宽通科技有限公司凭借其在智慧园区领域的专业实力&#xff0c;成功中标“在星沙”平台智慧后勤板块项目。此次项目合作华宽通将充分发挥在智慧园区领域的优势&#xff0c;为“在星沙”平台提供全方位、一体化的智慧后勤解决方案&#xff0c;助力实现后勤管理平台的智能化…
阅读更多...
k8s上尝试滚动更新和回滚

k8s上尝试滚动更新和回滚

滚动更新和回滚 实验目标&#xff1a; 学习如何进行应用的滚动更新和回滚操作。 实验步骤&#xff1a; 创建一个 Deployment。更新 Deployment 的镜像版本&#xff0c;观察滚动更新过程。回滚到之前的版本&#xff0c;验证回滚操作。 今天呢&#xff0c;我们继续来进行我们k…
阅读更多...
自学鸿蒙HarmonyOS的ArkTS语言＜一＞基本语法

自学鸿蒙HarmonyOS的ArkTS语言＜一＞基本语法

一、一个ArkTs的目录结构 二、一个页面的结构 A、装饰器 Entry 装饰器 : 标记组件为入口组件&#xff0c;一个页面由多个自定义组件组成&#xff0c;但是只能有一个组件被标记 Component : 自定义组件, 仅能装饰struct关键字声明的数据结构 State&#xff1a;组件中的状态变量…
阅读更多...
Python抓取天气信息

Python抓取天气信息

Python的详细学习还是需要些时间的。如果有其他语言经验的&#xff0c;可以暂时跟着我来写一个简单的例子。 2024年最新python教程全套&#xff0c;学完即可进大厂&#xff01;&#xff08;附全套视频 下载&#xff09; (qq.com) 我们计划抓取的数据&#xff1a;杭州的天气信息…
阅读更多...
行列式和矩阵的区别

行列式和矩阵的区别

目录 一、行列式 1. 行列式的定义 2. (全)排列 3. 逆序数 二、矩阵 1. 矩阵的定义 三、行列式和矩阵的区别 四、参考书目 一、行列式 1. 行列式的定义 2. (全)排列 3. 逆序数 二、矩阵 1. 矩阵的定义 三、行列式和矩阵的区别 四、参考书目 同济大学数学系. 工程数学…
阅读更多...
破除“数据孤岛”新策略：Data Fabric（数据编织）和逻辑数据平台

破除“数据孤岛”新策略：Data Fabric（数据编织）和逻辑数据平台

今天&#xff0c;我们已经进入到一个数据爆发的时代&#xff0c;仅 2022 年&#xff0c;我国数据产量就高达 8.1ZB&#xff0c;同比增长 22.7%&#xff0c;数据产量位居世界第二。数据作为新型生产资料&#xff0c;是企业数智化运营的基础&#xff0c;已快速融入到生产、分配、…
阅读更多...
什么是数仓调度？推荐使用这款数据仓库ETL工具

什么是数仓调度？推荐使用这款数据仓库ETL工具

随着企业数据规模的不断增大&#xff0c;如何高效地管理和利用数据成为了企业数字化转型过程中的重要问题。数据仓库作为一种专门用于存储和处理企业数据的技术&#xff0c;已经成为了企业数字化转型过程中不可或缺的一部分。而数仓调度则是数据仓库建设过程中至关重要的一环。…
阅读更多...
搭建个人官网时如何配置SMTP邮件自动发送

搭建个人官网时如何配置SMTP邮件自动发送

什么是 SMTP&#xff1f; SMTP( Simple Mail Transfer Protocol ) 是一种简单邮件传输协议&#xff0c;可以在互联网上通过SMTP来发送电子邮件&#xff0c;是建模在 FTP 文件传输服务上的一种邮件服务&#xff0c;主要用于传输系统之间的邮件信息并提供来信有关的通知。SMTP 服…
阅读更多...
如何准备大模型面试：迈向成功职业道路的关键一步

如何准备大模型面试：迈向成功职业道路的关键一步

前言 在当今日新月异的科技领域中&#xff0c;大模型技术正以其卓越的智能和无限的可能性&#xff0c;吸引着越来越多的企业和求职者。面对大模型领域的职位面试&#xff0c;如何充分准备&#xff0c;展现自己的专业能力和潜力&#xff0c;成为了每位求职者关注的焦点。本文将…
阅读更多...
【深度学习基础】详解Pytorch搭建CNN卷积神经网络LeNet-5实现手写数字识别

【深度学习基础】详解Pytorch搭建CNN卷积神经网络LeNet-5实现手写数字识别

目录 写在开头 一、CNN的原理 1. 概述 2. 卷积层 内参数&#xff08;卷积核本身&#xff09; 外参数&#xff08;填充和步幅&#xff09; 输入与输出的尺寸关系 3. 多通道问题 多通道输入 多通道输出 4. 池化层 平均汇聚 最大值汇聚 二、手写数字识别 1. 任务…
阅读更多...
原生js制作svg 图标生成动态 tab栏切换效果(结尾附代码)

原生js制作svg 图标生成动态 tab栏切换效果(结尾附代码)

svg 图标生成动态 tab 栏 先看效果&#xff1a; 我想做一个 tab 栏比较美观的效果&#xff0c;当然切换的数据可以自己做一下&#xff0c;这里不演示&#xff0c;说一下特效如何制作。 当我点击时要将空心变为实心的这么一个效果&#xff0c;所以准备两个五角星样式一个是空…
阅读更多...
【索引】数据库索引之顺序索引概述

【索引】数据库索引之顺序索引概述

目录 1、索引的基本概念 2、顺序索引 3、稠密索引和稀疏索引 3.1 什么是稠密索引&#xff1f; 3.2 什么是稀疏索引&#xff1f; 4、索引的更新 4.1 索引的插入操作 4.1 索引的删除操作 5、辅助索引 1、索引的基本概念 数据库中的索引与图书馆中书的索引作用相同&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023