golang 实现负载均衡器-负载均衡策略代码实现-版本1.0

go 实现负载均衡器代码细节

代码实现

gitee链接

介绍

负载均衡器（Load Balancer）在计算机网络和分布式系统中扮演着至关重要的角色，它能够有效地管理和分配网络请求到多个服务器或服务实例上，以优化资源利用、最大化吞吐量、最小化响应时间。在上一篇博客中介绍了负载均衡策略的原理、实现策略、使用场景等。本篇文章主要是记录具体代码实现细节。

原理介绍

可以看上一篇博客的原理介绍

版本2.0

在1.0的基础上将服务节点从string改为结构体，并且加入请求体，实现平滑加权轮询负载均衡策略的实现。
加权轮询负载均衡策略
版本2.0
版本2.1
版本2.2

实现细节

设计一个可扩展的负载均衡算法，可以选择不同的负载均衡策略，需要以下几个步骤：

• 接口设计：定义一个统一的接口来处理各种负载均衡策略。
• 策略实现：实现不同的负载均衡策略，如轮询（Round Robin）、随机（Random）、最小连接数（Least Connections）、散列（Hash）、加权轮询（Weighted Round Robin）、响应时间算法（Response Time）、
  一致性哈希算法（Consistent Hash）等。
• 工厂模式：使用工厂模式根据配置或用户输入选择具体的负载均衡策略。
• 负载均衡管理器：提供一个负载均衡管理器来协调和执行具体的策略。

项目结构：

load-balance

—loadbalancer

—model

—server

main.go

版本1.0

版本1.0为了简单起见，不设置请求，服务节点也只是用一个名称代替，后续会优化。

1、在loadbalancer包下创建 load_balancer.go：

package loadbalancer

// LoadBalancer 定义了一个接口，用于规范服务器选择的逻辑。
// 任何实现了 SelectServer 方法的类型都将自动满足 LoadBalancer 接口的要求，
// 这意味着它可以被用作一个通用的负载均衡器。
type LoadBalancer interface {
	// SelectServer 是 LoadBalancer 接口的核心方法，它接收一个服务器列表作为参数，
	// 并从中选择一个服务器返回其地址。
	// 如果服务器列表为空，应该返回一个错误。
	SelectServer(servers []string) (string, error)
}

2、增加三种负载均衡器策略：

轮询负载均衡：

实现统一接口 LoadBalancer 的方法 SelectServer。

package loadbalancer

import (
	"errors"
	"sync"
)

// RoundRobin 定义了一种轮询（Round Robin）负载均衡策略。
// 这种策略按照顺序遍历服务器列表，每次选择列表中的下一个服务器。
type RoundRobin struct {
	index int        // 当前选择的服务器索引
	mu    sync.Mutex // 互斥锁，用于保证并发安全
}

// NewRoundRobin 创建并返回一个新的 RoundRobin 负载均衡策略实例。
func NewRoundRobin() *RoundRobin {
	return &RoundRobin{}
}

// SelectServer 是 RoundRobin 负载均衡策略的核心方法，它从提供的服务器列表中选择下一个服务器。
// 如果服务器列表为空，则返回错误。
// 使用互斥锁确保在并发环境中正确地更新服务器索引。
func (r *RoundRobin) SelectServer(servers []string) (string, error) {
	if len(servers) == 0 { // 检查服务器列表是否为空
		return "", errors.New("no servers available") // 如果为空，返回错误
	}

	r.mu.Lock()         // 加锁，防止并发修改
	defer r.mu.Unlock() // 解锁

	// 根据当前的 index 选择服务器
	server := servers[r.index]
	// 更新 index 到下一个服务器，使用模运算确保 index 在列表范围内
	r.index = (r.index + 1) % len(servers)
	return server, nil // 返回选中的服务器地址
}

随机负载均衡：

package loadbalancer

import (
	"errors"
	"math/rand"
)

// Random 是一种负载均衡策略的实现，它通过随机选择的方式从服务器列表中挑选一个服务器。
type Random struct {
}

// NewRandom 创建并返回一个新的 Random 负载均衡策略实例。
func NewRandom() *Random {
	return &Random{}
}

// SelectServer 是 Random 负载均衡策略的核心方法，它从提供的服务器列表中随机选择一个服务器。
// 如果服务器列表为空，则返回错误。
func (r *Random) SelectServer(servers []string) (string, error) {
	if len(servers) == 0 { // 检查服务器列表是否为空
		return "", errors.New("no servers available") // 如果为空，返回错误
	}

	// 使用标准库中的 rand 包生成一个随机索引
	index := rand.Intn(len(servers))
	// 返回随机选择的服务器地址
	return servers[index], nil
}

最小连接数负载均衡：

package loadbalancer

import (
	"errors"
	"sync"
)

// LeastConnection 实现了最小连接数（Least Connection）的负载均衡策略。
// 这种策略会选择当前连接数最少的服务器，以达到均衡各服务器负载的目的。
// 使用一个全局的连接数管理器来跟踪每个服务器的连接数。
type LeastConnection struct {
	connections map[string]int // 存储每个服务器的当前连接数
	mu          sync.Mutex     // 互斥锁，确保并发安全
}

// NewLeastConnection 创建并返回一个新的 LeastConnection 负载均衡策略实例。
func NewLeastConnection() *LeastConnection {
	return &LeastConnection{
		connections: make(map[string]int), // 初始化连接数管理器
	}
}

// SelectServer 是 LeastConnection 负载均衡策略的核心方法，它从提供的服务器列表中选择连接数最少的服务器。
// 如果服务器列表为空，则返回错误。
// 使用互斥锁确保在并发环境中正确地读取和更新连接数。
func (lc *LeastConnection) SelectServer(servers []string) (string, error) {
	if len(servers) == 0 { // 检查服务器列表是否为空
		return "", errors.New("no servers available") // 如果为空，返回错误
	}

	lc.mu.Lock()         // 加锁，防止并发修改
	defer lc.mu.Unlock() // 解锁

	// 初始化最小连接数为最大整数值
	minConnections := int(^uint(0) >> 1)
	var selectedServer string // 用于存储连接数最少的服务器

	// 遍历服务器列表，找到连接数最少的服务器
	for _, server := range servers {
		if lc.connections[server] < minConnections {
			minConnections = lc.connections[server]
			selectedServer = server
		}
	}

	// 更新选中服务器的连接数
	lc.connections[selectedServer]++
	return selectedServer, nil // 返回选中的服务器地址
}

// ReleaseServer 减少服务器的连接数。
// 当一个连接结束时，调用此方法来减少对应服务器的连接计数。
func (lc *LeastConnection) ReleaseServer(server string) {
	lc.mu.Lock()         // 加锁，确保并发安全
	defer lc.mu.Unlock() // 解锁

	// 减少服务器的连接数，确保不会减至负数
	if lc.connections[server] > 0 {
		lc.connections[server]--
	}
}

3、使用工厂模式选择不同策略

在 loadbalancer 包下创建 Selector.go：

package loadbalancer

import "fmt"

// AlgorithmType 定义了负载均衡算法的类型，使用字符串枚举表示不同的算法。
type AlgorithmType string

// 采用策略模式，策略上下文的一部分，它根据传入的算法类型选择并返回一个具体策略的实例。
// 预定义的负载均衡算法类型常量。策略的种类
const (
	RoundRobinAlgorithm       AlgorithmType = "round_robin"       // 轮询算法
	RandomAlgorithm           AlgorithmType = "random"            // 随机算法
	LeastConnectionsAlgorithm AlgorithmType = "least_connections" // 最小连接数算法
)

// NewLoadBalancer 通过工厂模式来创建具体的负载均衡策略，
// 根据指定的算法类型创建并返回相应的负载均衡器实例。
// 如果算法类型未知，则返回错误。
func NewLoadBalancer(algorithm AlgorithmType) (LoadBalancer, error) {
	switch algorithm {
	case RoundRobinAlgorithm:
		return NewRoundRobin(), nil // 具体策略的工厂方法，创建并返回轮询算法的负载均衡器实例
	case RandomAlgorithm:
		return NewRandom(), nil // 创建并返回随机算法的负载均衡器实例
	case LeastConnectionsAlgorithm:
		return NewLeastConnection(), nil // 创建并返回最小连接数算法的负载均衡器实例
	default:
		return nil, fmt.Errorf("unknown load balancing algorithm: %s", algorithm) // 返回错误，指示未知的算法类型
	}
}

4、创建负载均衡管理器

在 loadbalancer 包下创建 LoadBalancerManager.go：

管理器拥有一个当前使用的负载均衡器实例，以及一个维护所有服务器信息的列表。创建一个 NewLoadBalancerManager 方法用于初始化负载均衡器实例。一个 GetServer 方法用于根据当前负载均衡器的策略选择一个服务器。一个 RemoveServer 方法用于从服务器列表中移除一个服务器。

package loadbalancer

import "errors"

// BalancerManager 管理负载均衡器和服务器列表。
// 它封装了负载均衡器的实例和服务器列表，提供了获取、添加和删除服务器的方法。
type BalancerManager struct {
	loadBalancer LoadBalancer // 当前使用的负载均衡器实例
	servers      []string     // 服务器列表
}

// NewLoadBalancerManager 创建并返回一个新的 BalancerManager 实例。
// 它接受一个算法类型和服务器列表，初始化负载均衡器和服务器列表。
// 如果算法类型无效，将返回错误。
func NewLoadBalancerManager(algorithm AlgorithmType, servers []string) (*BalancerManager, error) {
	// 创建负载均衡器实例
	loadBalancer, err := NewLoadBalancer(algorithm)
	if err != nil {
		return nil, err // 如果创建失败，返回错误
	}
	// 返回初始化的 BalancerManager 实例
	return &BalancerManager{
		loadBalancer: loadBalancer,
		servers:      servers,
	}, nil
}

// GetServer 根据当前负载均衡器的策略选择一个服务器。
// 如果服务器列表为空，将返回错误。
func (lbm *BalancerManager) GetServer() (string, error) {
	if len(lbm.servers) == 0 { // 检查服务器列表是否为空
		return "", errors.New("no servers available") // 如果为空，返回错误
	}
	// 使用负载均衡器选择服务器
	return lbm.loadBalancer.SelectServer(lbm.servers)
}

// AddServer 向服务器列表中添加一个新服务器。
func (lbm *BalancerManager) AddServer(server string) {
	// 直接向服务器列表中追加新服务器
	lbm.servers = append(lbm.servers, server)
}

// RemoveServer 从服务器列表中移除一个服务器。
// 如果服务器不存在于列表中，该方法不会产生任何效果。
func (lbm *BalancerManager) RemoveServer(server string) {
	// 遍历服务器列表，查找并移除指定的服务器
	for i, s := range lbm.servers {
		if s == server {
			// 移除找到的服务器
			lbm.servers = append(lbm.servers[:i], lbm.servers[i+1:]...)
			break
		}
	}
}

5、实现 main 方法进行测试

package main

import (
	"fmt"
	"xun-go/com/xun/load-banlance/loadbalancer"
)

func main() {
	// 定义服务器列表
	servers := []string{"server1", "server2", "server3"}

	// 创建负载均衡器管理器实例
	// 使用RoundRobinAlgorithm算法初始化LoadBalancerManager
	// servers参数是需要负载均衡的服务器列表
	lbm, err := loadbalancer.NewLoadBalancerManager(loadbalancer.RoundRobinAlgorithm, servers)
	if err != nil {
		// 如果创建LoadBalancerManager时出现错误，打印错误信息并退出程序
		fmt.Println("Error creating load balancer manager:", err)
		return
	}

	// 循环10次，每次获取一个服务器
	for i := 0; i < 10; i++ {
		// 从负载均衡器管理器中获取下一个服务器
		// GetServer方法会根据所选的负载均衡算法返回一个服务器
		server, err := lbm.GetServer()
		if err != nil {
			// 如果GetServer方法调用失败，打印错误信息并退出程序
			fmt.Println("Error getting server:", err)
			return
		}
		// 打印被选中的服务器
		fmt.Println("Selected server:", server)
	}
}

其他内容（6.824-2022分布式实验）

Lab1：MapReduce

实验一链接

Lab2：Raft

实验二Raft链接

Lab2A：Leader Election

lab2A链接

Lab2B：日志复制

lab2B链接

Lab2C ：持久化机制 persistence

lab2C链接

Lab2D：日志压缩 log compaction

lab2D链接

Go web 简单开发 demo

直达gitee链接

Go 实现负载均衡器

负载均衡器原理介绍