6. 负载均衡
...大约 5 分钟
1. 负载均衡策略
假设有多个服务实例,每个实例提供相同的功能,为了提高整个系统的吞吐量,每个实例部署在不同的机器上。客户端需要使用负载均衡策略来选择目标服务器,常见的策略:
- 随机选择策略 - 从服务列表中随机选择一个。
- 轮询算法(Round Robin) - 依次调度不同的服务器,每次调度执行 i = (i + 1) mode n。
- 加权轮询(Weight Round Robin) - 在轮询算法的基础上,为每个服务实例设置一个权重,高性能的机器赋予更高的权重,也可以根据服务实例的当前的负载情况做动态的调整,例如考虑最近5分钟部署服务器的 CPU、内存消耗情况。
- 哈希/一致性哈希策略 - 依据请求的某些特征,计算一个 hash 值,根据 hash 值将请求发送到对应的机器。一致性 hash 还可以解决服务实例动态添加情况下,调度抖动的问题。一致性哈希的一个典型应用场景是分布式缓存服务。
- ...
2. 服务发现
负载均衡的前提是有多个服务实例,首先实现一个最基础的服务发现模块 Discovery。为了与通信部分解耦,这部分的代码统一放置在 xclient 子目录下。
xclient/dicovery.go
type SelectMode int
const (
RandomSelect SelectMode = iota
RoundRobinSelect
)
type Discovery interface {
Refresh() error
Update(servers []string) error
Get(mode SelectMode) (string, error)
GetAll() ([]string, error)
}
SelectMode
:负载均衡(选择)策略Discovery
:接口Refresh
:从注册中心更新服务列表Update
:手动更新服务列表Get
:根据负载均衡策略,选择服务实例GetAll
:获取所有的服务实例
// MultiServerDiscovery is a discovery for multi servers without a registry center
// user provides the server addresses explicitly instead
type MultiServerDiscovery struct {
r *rand.Rand // generate random number
mu sync.RWMutex // protect following fields
servers []string
index int // record the selected position for robin algorithm
}
// NewMultiServerDiscovery creates a MultiServersDiscovery instance
func NewMultiServerDiscovery(servers []string) *MultiServerDiscovery {
d := &MultiServerDiscovery{
servers: servers,
r: rand.New(rand.NewSource(time.Now().UnixNano())),
}
d.index = d.r.Intn(math.MaxInt32 - 1)
return d
MultiServerDiscovery
:
r
:用于产生随机数,使用时间戳作为种子index
:记录 Round Robin 算法轮询到的位置,起始位置随机,避免每次从 0 开始
var _ Discovery = (*MultiServerDiscovery)(nil)
func (d *MultiServerDiscovery) Refresh() error {
return nil
}
func (d *MultiServerDiscovery) Update(servers []string) error {
d.mu.Lock()
defer d.mu.Unlock()
d.servers = servers
return nil
}
func (d *MultiServerDiscovery) Get(mode SelectMode) (string, error) {
d.mu.Lock()
defer d.mu.Unlock()
n := len(d.servers)
if n == 0 {
return "", errors.New("rpc discovery: no available servers")
}
switch mode {
case RandomSelect:
return d.servers[d.r.Intn(n)], nil
case RoundRobinSelect:
s := d.servers[d.index%n]
d.index = (d.index + 1) % n
return s, nil
default:
return "", errors.New("rpc discovery: not supported select mode")
}
}
func (d *MultiServerDiscovery) GetAll() ([]string, error) {
d.mu.RLock()
defer d.mu.RUnlock()
// return a copy of d.servers
servers := make([]string, len(d.servers), len(d.servers))
copy(servers, d.servers)
return servers, nil
}
实现Discovery
接口。
3. 支持负载均衡的客户端
xclient/xclient.go
type XClient struct {
d Discovery
mode SelectMode
opt *geerpc.Option
mu sync.Mutex // protect following
clients map[string]*geerpc.Client
}
var _ io.Closer = (*XClient)(nil)
func (xc *XClient) Close() error {
xc.mu.Lock()
defer xc.mu.Unlock()
for key, client := range xc.clients {
_ = client.Close()
delete(xc.clients, key)
}
return nil
}
func NewXClient(d Discovery, mode SelectMode, opt *geerpc.Option) *XClient {
return &XClient{
d: d,
mode: mode,
opt: opt,
clients: make(map[string]*geerpc.Client),
}
}
XClient
:
d
:服务发现实例mode
:负载均衡模式opt
:通信选项clients
:客户端实例,用于复用已存在的实例
func (xc *XClient) dial(rpcAddr string) (*geerpc.Client, error) {
xc.mu.Lock()
defer xc.mu.Unlock()
client, ok := xc.clients[rpcAddr]
if ok && !client.IsAvailable() {
_ = client.Close()
delete(xc.clients, rpcAddr)
client = nil
}
if client == nil {
var err error
client, err = XDial(rpcAddr, xc.opt)
if err != nil {
return nil, err
}
xc.clients[rpcAddr] = client
}
return client, nil
}
// XDial calls different functions to connect to a RPC server
// according the first parameter rpcAddr.
// rpcAddr is a general format (protocol@addr) to represent a rpc server
// eg, [email protected]:7001, [email protected]:9999, unix@/tmp/geerpc.sock
func XDial(rpcAddr string, opts ...*geerpc.Option) (*geerpc.Client, error) {
parts := strings.Split(rpcAddr, "@")
if len(parts) != 2 {
return nil, fmt.Errorf("rpc client err: wrong format '%s', expect protocol@addr", rpcAddr)
}
protocol, addr := parts[0], parts[1]
switch protocol {
case "http":
return geerpc.DialHTTP("tcp", addr, opts...)
default:
// tcp, unix or other transport protocol
return geerpc.Dial(protocol, addr, opts...)
}
}
func (xc *XClient) call(rpcAddr string, ctx context.Context, serviceMethod string, args, reply any) error {
client, err := xc.dial(rpcAddr)
if err != nil {
return err
}
return client.Call(ctx, serviceMethod, args, reply)
}
func (xc *XClient) Call(ctx context.Context, serviceMethod string, args, reply any) error {
rpcAddr, err := xc.d.Get(xc.mode)
if err != nil {
return err
}
return xc.call(rpcAddr, ctx, serviceMethod, args, reply)
}
xc.dial
:- 若客户端已存在,则复用
- 创建新客户端
- 加入缓存并返回
xc.Call
:根据负载均衡策略选择服务并调用
// Broadcast invokes the named function for every server registered in discovery
func (xc *XClient) Broadcast(ctx context.Context, serviceMethod string, args, reply any) error {
servers, err := xc.d.GetAll()
if err != nil {
return err
}
var (
wg sync.WaitGroup
mu sync.Mutex
e error
)
replyDone := reply == nil
ctx, cancel := context.WithCancel(ctx)
for _, rpcAddr := range servers {
wg.Add(1)
go func(rpcAddr string) {
defer wg.Done()
var cloneReply any
if reply != nil {
cloneReply = reflect.New(reflect.ValueOf(reply).Elem().Type()).Interface()
}
err := xc.call(rpcAddr, ctx, serviceMethod, args, cloneReply)
mu.Lock()
if err != nil && e == nil {
e = err
cancel()
}
if err == nil && !replyDone {
reflect.ValueOf(reply).Elem().Set(reflect.ValueOf(cloneReply).Elem())
replyDone = true
cancel()
}
mu.Unlock()
}(rpcAddr)
}
wg.Wait()
cancel()
return e
}
Broadcast
将请求广播到所有实例
- 并发调用
- 若有一个实例出现错误或执行完成,则返回并取消其余服务实例的执行
4. Demo
package main
import (
"context"
"geerpc"
"geerpc/xclient"
"log"
"net"
"sync"
"time"
)
type Foo int
type Args struct {
Num1, Num2 int
}
func (f Foo) Sum(args Args, reply *int) error {
*reply = args.Num1 + args.Num2
return nil
}
func (f Foo) Sleep(args Args, reply *int) error {
time.Sleep(time.Duration(args.Num1) * time.Second)
*reply = args.Num1 + args.Num2
return nil
}
func startServer(addrCh chan string) {
var f Foo
lis, err := net.Listen("tcp", ":0")
if err != nil {
log.Fatal("server listen tcp failed:", err)
}
server := geerpc.NewServer()
if err = server.Register(&f); err != nil {
log.Fatal("server listen tcp failed:", err)
}
log.Println("server runs at:", lis.Addr().String())
addrCh <- lis.Addr().String()
server.Accept(lis)
}
func foo(xc *xclient.XClient, ctx context.Context, typ, serviceMethod string, args *Args) {
var (
reply int
err error
)
switch typ {
case "call":
err = xc.Call(ctx, serviceMethod, args, &reply)
case "broadcast":
err = xc.Broadcast(ctx, serviceMethod, args, &reply)
}
if err != nil {
log.Printf("%s %s error: %v", typ, serviceMethod, err)
} else {
log.Printf("%s %s success: %d + %d = %d", typ, serviceMethod, args.Num1, args.Num2, reply)
}
}
func call(addr1, addr2 string) {
d := xclient.NewMultiServerDiscovery([]string{"tcp@" + addr1, "tcp@" + addr2})
xc := xclient.NewXClient(d, xclient.RandomSelect, nil)
defer func() { _ = xc.Close() }()
// send request & receive response
var wg sync.WaitGroup
for i := 0; i < 5; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
foo(xc, context.Background(), "call", "Foo.Sum", &Args{Num1: i, Num2: i * i})
}(i)
}
wg.Wait()
}
func broadcast(addr1, addr2 string) {
d := xclient.NewMultiServerDiscovery([]string{"tcp@" + addr1, "tcp@" + addr2})
xc := xclient.NewXClient(d, xclient.RandomSelect, nil)
defer func() { _ = xc.Close() }()
var wg sync.WaitGroup
for i := 0; i < 5; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
foo(xc, context.Background(), "broadcast", "Foo.Sum", &Args{Num1: i, Num2: i * i})
// expect 2 - 5 timeout
ctx, _ := context.WithTimeout(context.Background(), time.Second*2)
foo(xc, ctx, "broadcast", "Foo.Sleep", &Args{Num1: i, Num2: i * i})
}(i)
}
wg.Wait()
}
func main() {
log.SetFlags(0)
ch1 := make(chan string)
ch2 := make(chan string)
go startServer(ch1)
go startServer(ch2)
addr1 := <-ch1
addr2 := <-ch2
call(addr1, addr2)
broadcast(addr1, addr2)
}
Reference
Powered by Waline v2.15.2