背景

在工作学习中使用gRPC的地方比较多,通常我们都使用的是自带的负载均衡算法,但是在某些场景下我们需要对服务的版本进行控制 比如 [app V2 只能去链接 user V3],在这样的情况下就只能选自定义负载均衡策略

目标

实现基于版本(version)的grpc负载均衡器,了解过程后可自己实现更多的负载均衡功能

  • 注册中心
    • Etcd Lease 是一种检测客户端存活状况的机制。 群集授予具有生存时间的租约。 如果etcd 群集在给定的TTL 时间内未收到keepAlive,则租约到期。 为了将租约绑定到键值存储中,每个key 最多可以附加一个租约
  • 服务注册 (注册服务)
    • 定时把本地服务(APP)地址,版本等信息注册到服务器
  • 服务发现 (客户端发起服务解析请求(APP))
    • 查询注册中心(APP)下有那些服务
    • 并向所有的服务建立HTTP2长链接
    • 通过Etcd watch 监听服务(APP),通过变化更新链接
  • 负载均衡 (客户端发起请求(APP))
    • 负载均衡选择合适的服务(APP HTTP2长链接)
    • 发起调用

服务注册 (注册服务)

源码 register.go

func NewRegister(opt ...RegisterOptions) (*Register, error) {
	s := &Register{
		opts: newOptions(opt...),
	}
	var ctx, cancel = context.WithTimeout(context.Background(), time.Duration(s.opts.RegisterTtl)*time.Second)
	defer cancel()
	data, err := json.Marshal(s.opts)
	if err != nil {
		return nil, err
	}
	etcdCli, err := clientv3.New(s.opts.EtcdConf)
	if err != nil {
		return nil, err
	}
	s.etcdCli = etcdCli
	//申请租约
	resp, err := etcdCli.Grant(ctx, s.opts.RegisterTtl)
	if err != nil {
		return s, err
	}
	s.name = fmt.Sprintf("%s/%s", s.opts.Node.Path, s.opts.Node.Id)
	//注册节点
	_, err = etcdCli.Put(ctx, s.name, string(data), clientv3.WithLease(resp.ID))
	if err != nil {
		return s, err
	}
	//续约租约
	s.keepAliveChan, err = etcdCli.KeepAlive(context.Background(), resp.ID)
	if err != nil {
		return s, err
	}
	return s, nil
}

在etcd里面我们可以看到如下信息
APP v1版本服务在节点的key /hwholiday/srv/app/app-beb3cb56-eb61-11eb-858d-2cf05dc7c711

{
    "node": {
        "name": "app",
        "path": "/hwholiday/srv/app",
        "id": "app-beb3cb56-eb61-11eb-858d-2cf05dc7c711",
        "version": "v1",
        "address": "172.12.12.188:8089"
    }
}

APP v2版本服务在节点的key /hwholiday/srv/app/app-beb3cb56-eb61-11eb-858d-2cf05dc7c711

{
    "node": {
        "name": "app",
        "path": "/hwholiday/srv/app",
        "id": "app-19980562-eb63-11eb-99c0-2cf05dc7c711",
        "version": "v2",
        "address": "172.12.12.188:8088"
    },
}

服务发现 (客户端发起服务解析请求(APP))

源码 discovery.go
实现 grpc内的 resolver.Builder 接口(Builder 创建一个解析器,用于监视名称解析更新)

func NewDiscovery(opt ...ClientOptions) resolver.Builder {
	s := &Discovery{
		opts: newOptions(opt...),
	}
	etcdCli, err := clientv3.New(s.opts.EtcdConf)
	if err != nil {
		panic(err)
	}
	s.etcdCli = etcdCli
	return s
}

// Build 当调用`grpc.Dial()`时执行
func (d *Discovery) Build(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOptions) (resolver.Resolver, error) {
	d.cc = cc
	res, err := d.etcdCli.Get(context.Background(), d.opts.SrvName, clientv3.WithPrefix())
	if err != nil {
		return nil, err
	}
	for _, v := range res.Kvs {
		if err = d.AddNode(v.Key, v.Value); err != nil {
			log.Println(err)
			continue
		}
	}
	go func(dd *Discovery) {
		dd.watcher()
	}(d)
	return d, err
}

//根据官方的建议我们把从注册中心拿到的服务信息储存到Attributes中
// Attributes contains arbitrary data about the resolver intended for
// consumption by the load balancing policy.
// 属性包含有关供负载平衡策略使用的解析器的任意数据。
//Attributes *attributes.Attributes
func (d *Discovery) AddNode(key, val []byte) error {
	var data = new(register.Options)
	err := json.Unmarshal(val, data)
	if err != nil {
		return err
	}
	addr := resolver.Address{Addr: data.Node.Address}
	addr = SetNodeInfo(addr, data)
	d.Node.Store(string(key), addr)
	return d.cc.UpdateState(resolver.State{Addresses: d.GetAddress()})
}

负载均衡 (客户端发起请求(APP))

源码 version_balancer.go
+ gRPC提供了PickerBuilder和Picker接口让我们实现自己的负载均衡策略

//PickerBuilder 创建 balancer.Picker。
type PickerBuilder interface {
    //Build 返回一个选择器,gRPC 将使用它来选择一个 SubConn。
    Build(info PickerBuildInfo) balancer.Picker
}
//gRPC 使用 Picker 来选择一个 SubConn 来发送 RPC。
//每次平衡器的内部状态发生变化时,它都会从它的快照中生成一个新的选择器。 
//gRPC 使用的选择器可以通过 ClientConn.UpdateState() 更新。
type Picker interface {
    //选择合适的子链接发送请求
    Pick(info PickInfo) (PickResult, error)
}
  • 从上面得知我们可以干事的地方在Build方法或者Pick方法(调用gRPC方法时先执行Build再执行Pick)
    • Build(info PickerBuildInfo) balancer.Picker
      info里面有服务的链接,和链接对应的刚刚通过AddNode方法存入的服务信息
      这里我们可以基于grpc-client层面来做负载,比如(加权随机负载)
    • Pick(info PickInfo) (PickResult, error)
      info里面有调用的方法名和 context.Context
      通过context.Context我们可以获得这个来获取发起请求的时候填入的参数,这样我们可以很灵活的针对每个方法进行不同的负载
      这里我们可以基于grpc-client-api层面来做负载
func (*rrPickerBuilder) Build(info base.PickerBuildInfo) balancer.Picker {
	if len(info.ReadySCs) == 0 {
		return base.NewErrPicker(balancer.ErrNoSubConnAvailable)
	}
	var scs = make(map[balancer.SubConn]*register.Options, len(info.ReadySCs))
	for conn, addr := range info.ReadySCs {
		nodeInfo := GetNodeInfo(addr.Address)
		if nodeInfo != nil {
			scs[conn] = nodeInfo
		}
	}
	if len(scs) == 0 {
		return base.NewErrPicker(balancer.ErrNoSubConnAvailable)
	}
	return &rrPicker{
		node: scs,
	}
}
func (p *rrPicker) Pick(info balancer.PickInfo) (balancer.PickResult, error) {
	p.mu.Lock()
	defer p.mu.Unlock()
	version := info.Ctx.Value("version")
	var subConns []balancer.SubConn
	for conn, node := range p.node {
		if version != "" {
			if node.Node.Version == version.(string) {
				subConns = append(subConns, conn)
			}
		}
	}
	if len(subConns) == 0 {
		return balancer.PickResult{}, errors.New("no match found conn")
	}
	index := rand.Intn(len(subConns))
	sc := subConns[index]
	return balancer.PickResult{SubConn: sc}, nil
}

客户的使用我们定义的 version 负载均衡策略

	r := discovery.NewDiscovery(
		discovery.SetName("hwholiday.srv.app"),
		discovery.SetEtcdConf(clientv3.Config{
			Endpoints:   []string{"172.12.12.165:2379"},
			DialTimeout: time.Second * 5,
		}))
	resolver.Register(r)
	// 连接服务器
	conn, err := grpc.Dial(
		"hwholiday.srv.app", //没有使用这个参数
		grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"LoadBalancingPolicy": "%s"}`, "version")),
		grpc.WithInsecure(),
	)
	if err != nil {
		log.Fatalf("net.Connect err: %v", err)
	}
	defer conn.Close()
	// 调用服务
		apiClient := api.NewApiClient(conn)

	ctx := context.WithValue(context.Background(), "version", "v1")
	_, err = apiClient.ApiTest(ctx, &api.Request{Input: "v1v1v1v1v1"})
	if err != nil {
		fmt.Println(err)
	}

运行效果

测试源码

  • 运行APP服务v1,调用grpc-client 使用 v1

    • APP打印
    • 启动成功 === > 0.0.0.0:8089
    • input:“v1v1v1v1v1”
    • grpc-client打印
    • === RUN TestClient
    • v1v1v1v1v1v1v1v1v1v1
  • 运行APP服务v1,调用grpc-client 使用 v2

    • APP打印
    • 启动成功 === > 0.0.0.0:8089
    • grpc-client打印
    • === RUN TestClient
    • rpc error: code = Unavailable desc = no match found conn

总结

详情介绍地址
源码地址: https://github.com/hwholiday/learning_tools/tree/master/etcd
通过学习我们可以实现基于version的负载策略,这里只是提供一种思路怎么去实现可能我的这个例子不太适合这个,但是提供了一种思路,欢迎一起讨论