gRPC服务发现&负载均衡

编程语言 2018-07-03 23:21:29 阅读次数: 0

构建高可用、高性能的通信服务，通常采用服务注册与发现、负载均衡和容错处理等机制实现。根据负载均衡实现所在的位置不同，通常可分为以下三种解决方案：

1、集中式LB（Proxy Model）

在服务消费者和服务提供者之间有一个独立的LB，通常是专门的硬件设备如 F5，或者基于软件如 LVS，HAproxy等实现。LB上有所有服务的地址映射表，通常由运维配置注册，当服务消费方调用某个目标服务时，它向LB发起请求，由LB以某种策略，比如轮询（Round-Robin）做负载均衡后将请求转发到目标服务。LB一般具备健康检查能力，能自动摘除不健康的服务实例。 该方案主要问题：

  1. 单点问题，所有服务调用流量都经过LB，当服务数量和调用量大的时候，LB容易成为瓶颈，且一旦LB发生故障影响整个系统；

  2. 服务消费方、提供方之间增加了一级，有一定性能开销。

2、进程内LB（Balancing-aware Client）

针对第一个方案的不足，此方案将LB的功能集成到服务消费方进程里，也被称为软负载或者客户端负载方案。服务提供方启动时，首先将服务地址注册到服务注册表，同时定期报心跳到服务注册表以表明服务的存活状态，相当于健康检查，服务消费方要访问某个服务时，它通过内置的LB组件向服务注册表查询，同时缓存并定期刷新目标服务地址列表，然后以某种负载均衡策略选择一个目标服务地址，最后向目标服务发起请求。LB和服务发现能力被分散到每一个服务消费者的进程内部，同时服务消费方和服务提供方之间是直接调用，没有额外开销，性能比较好。该方案主要问题：

  1. 开发成本，该方案将服务调用方集成到客户端的进程里头，如果有多种不同的语言栈，就要配合开发多种不同的客户端，有一定的研发和维护成本；

  2. 另外生产环境中，后续如果要对客户库进行升级，势必要求服务调用方修改代码并重新发布，升级较复杂。

3、独立 LB 进程（External Load Balancing Service）

该方案是针对第二种方案的不足而提出的一种折中方案，原理和第二种方案基本类似。
不同之处是将LB和服务发现功能从进程内移出来，变成主机上的一个独立进程。主机上的一个或者多个服务要访问目标服务时，他们都通过同一主机上的独立LB进程做服务发现和负载均衡。该方案也是一种分布式方案没有单点问题，一个LB进程挂了只影响该主机上的服务调用方，服务调用方和LB之间是进程内调用性能好，同时该方案还简化了服务调用方，不需要为不同语言开发客户库，LB的升级不需要服务调用方改代码。 
该方案主要问题：部署较复杂，环节多，出错调试排查问题不方便。

gRPC服务发现及负载均衡实现

gRPC开源组件官方并未直接提供服务注册与发现的功能实现，但其设计文档已提供实现的思路，并在不同语言的gRPC代码API中已提供了命名解析和负载均衡接口供扩展。

其基本实现原理：

  1. 服务启动后gRPC客户端向命名服务器发出名称解析请求，名称将解析为一个或多个IP地址，每个IP地址标示它是服务器地址还是负载均衡器地址，以及标示要使用那个客户端负载均衡策略或服务配置。

  2. 客户端实例化负载均衡策略，如果解析返回的地址是负载均衡器地址，则客户端将使用grpclb策略，否则客户端使用服务配置请求的负载均衡策略。

  3. 负载均衡策略为每个服务器地址创建一个子通道（channel）。

  4. 当有rpc请求时，负载均衡策略决定那个子通道即grpc服务器将接收请求，当可用服务器为空时客户端的请求将被阻塞。

根据gRPC官方提供的设计思路，基于进程内LB方案（即第2个案，阿里开源的服务框架 Dubbo 也是采用类似机制），结合分布式一致的组件（如Zookeeper、Consul、Etcd），可找到gRPC服务发现和负载均衡的可行解决方案。接下来以GO语言为例，简单介绍下基于Etcd3的关键代码实现：

1）命名解析实现：resolver.go

  1. package etcdv3
  3. import (
  4. "errors"
  5. "fmt"
  6. "strings"
  8. etcd3 "github.com/coreos/etcd/clientv3"
  9. "google.golang.org/grpc/naming"
  10. )
  12. // resolver is the implementaion of grpc.naming.Resolver
  13. type resolver struct {
  14. serviceName string // service name to resolve
  15. }
  17. // NewResolver return resolver with service name
  18. func NewResolver(serviceName string) *resolver {
  19. return &resolver{serviceName: serviceName}
  20. }
  22. // Resolve to resolve the service from etcd, target is the dial address of etcd
  23. // target example: "http://127.0.0.1:2379,http://127.0.0.1:12379,http://127.0.0.1:22379"
  24. func (re *resolver) Resolve(target string) (naming.Watcher, error) {
  25. if re.serviceName == "" {
  26. return nil, errors.New( "grpclb: no service name provided")
  27. }
  29. // generate etcd client
  30. client, err := etcd3.New(etcd3.Config{
  31. Endpoints: strings.Split(target, ","),
  32. })
  33. if err != nil {
  34. return nil, fmt.Errorf( "grpclb: creat etcd3 client failed: %s", err.Error())
  35. }
  37. // Return watcher
  38. return &watcher{re: re, client: *client}, nil
  39. }

2）服务发现实现：watcher.go

  1. package etcdv3
  3. import (
  4. "fmt"
  5. etcd3 "github.com/coreos/etcd/clientv3"
  6. "golang.org/x/net/context"
  7. "google.golang.org/grpc/naming"
  8. "github.com/coreos/etcd/mvcc/mvccpb"
  9. )
  11. // watcher is the implementaion of grpc.naming.Watcher
  12. type watcher struct {
  13. re *resolver // re: Etcd Resolver
  14. client etcd3.Client
  15. isInitialized bool
  16. }
  18. // Close do nothing
  19. func (w *watcher) Close() {
  20. }
  22. // Next to return the updates
  23. func (w *watcher) Next() ([]*naming.Update, error) {
  24. // prefix is the etcd prefix/value to watch
  25. prefix := fmt.Sprintf( "/%s/%s/", Prefix, w.re.serviceName)
  27. // check if is initialized
  28. if !w.isInitialized {
  29. // query addresses from etcd
  30. resp, err := w.client.Get(context.Background(), prefix, etcd3.WithPrefix())
  31. w.isInitialized = true
  32. if err == nil {
  33. addrs := extractAddrs(resp)
  34. //if not empty, return the updates or watcher new dir
  35. if l := len(addrs); l != 0 {
  36. updates := make([]*naming.Update, l)
  37. for i := range addrs {
  38. updates[i] = &naming.Update{Op: naming.Add, Addr: addrs[i]}
  39. }
  40. return updates, nil
  41. }
  42. }
  43. }
  45. // generate etcd Watcher
  46. rch := w.client.Watch(context.Background(), prefix, etcd3.WithPrefix())
  47. for wresp := range rch {
  48. for _, ev := range wresp.Events {
  49. switch ev.Type {
  50. case mvccpb.PUT:
  51. return []*naming.Update{{Op: naming.Add, Addr: string(ev.Kv.Value)}}, nil
  52. case mvccpb.DELETE:
  53. return []*naming.Update{{Op: naming.Delete, Addr: string(ev.Kv.Value)}}, nil
  54. }
  55. }
  56. }
  57. return nil, nil
  58. }
  60. func extractAddrs(resp *etcd3.GetResponse) []string {
  61. addrs := [] string{}
  63. if resp == nil || resp.Kvs == nil {
  64. return addrs
  65. }
  67. for i := range resp.Kvs {
  68. if v := resp.Kvs[i].Value; v != nil {
  69. addrs = append(addrs, string(v))
  70. }
  71. }
  73. return addrs
  74. }

3）服务注册实现：register.go

  1. package etcdv3
  3. import (
  4. "fmt"
  5. "log"
  6. "strings"
  7. "time"
  9. etcd3 "github.com/coreos/etcd/clientv3"
  10. "golang.org/x/net/context"
  11. "github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
  12. )
  14. // Prefix should start and end with no slash
  15. var Prefix = "etcd3_naming"
  16. var client etcd3.Client
  17. var serviceKey string
  19. var stopSignal = make( chan bool, 1)
  21. // Register
  22. func Register(name string, host string, port int, target string, interval time.Duration, ttl int) error {
  23. serviceValue := fmt.Sprintf( "%s:%d", host, port)
  24. serviceKey = fmt.Sprintf( "/%s/%s/%s", Prefix, name, serviceValue)
  26. // get endpoints for register dial address
  27. var err error
  28. client, err := etcd3.New(etcd3.Config{
  29. Endpoints: strings.Split(target, ","),
  30. })
  31. if err != nil {
  32. return fmt.Errorf( "grpclb: create etcd3 client failed: %v", err)
  33. }
  35. go func() {
  36. // invoke self-register with ticker
  37. ticker := time.NewTicker(interval)
  38. for {
  39. // minimum lease TTL is ttl-second
  40. resp, _ := client.Grant(context.TODO(), int64(ttl))
  41. // should get first, if not exist, set it
  42. _, err := client.Get(context.Background(), serviceKey)
  43. if err != nil {
  44. if err == rpctypes.ErrKeyNotFound {
  45. if _, err := client.Put(context.TODO(), serviceKey, serviceValue, etcd3.WithLease(resp.ID)); err != nil {
  46. log.Printf( "grpclb: set service '%s' with ttl to etcd3 failed: %s", name, err.Error())
  47. }
  48. } else {
  49. log.Printf( "grpclb: service '%s' connect to etcd3 failed: %s", name, err.Error())
  50. }
  51. } else {
  52. // refresh set to true for not notifying the watcher
  53. if _, err := client.Put(context.Background(), serviceKey, serviceValue, etcd3.WithLease(resp.ID)); err != nil {
  54. log.Printf( "grpclb: refresh service '%s' with ttl to etcd3 failed: %s", name, err.Error())
  55. }
  56. }
  57. select {
  58. case <-stopSignal:
  59. return
  60. case <-ticker.C:
  61. }
  62. }
  63. }()
  65. return nil
  66. }
  68. // UnRegister delete registered service from etcd
  69. func UnRegister() error {
  70. stopSignal <- true
  71. stopSignal = make( chan bool, 1) // just a hack to avoid multi UnRegister deadlock
  72. var err error;
  73. if _, err := client.Delete(context.Background(), serviceKey); err != nil {
  74. log.Printf( "grpclb: deregister '%s' failed: %s", serviceKey, err.Error())
  75. } else {
  76. log.Printf( "grpclb: deregister '%s' ok.", serviceKey)
  77. }
  78. return err
  79. }

4）接口描述文件：helloworld.proto

  1. syntax = "proto3";
  3. option java_multiple_files = true;
  4. option java_package = "com.midea.jr.test.grpc";
  5. option java_outer_classname = "HelloWorldProto";
  6. option objc_class_prefix = "HLW";
  8. package helloworld;
  10. // The greeting service definition.
  11. service Greeter {
  12. // Sends a greeting
  13. rpc SayHello (HelloRequest) returns (HelloReply) {
  14. }
  15. }
  17. // The request message containing the user's name.
  18. message HelloRequest {
  19. string name = 1;
  20. }
  22. // The response message containing the greetings
  23. message HelloReply {
  24. string message = 1;
  25. }

5）实现服务端接口：helloworldserver.go

  1. package main
  3. import (
  4. "flag"
  5. "fmt"
  6. "log"
  7. "net"
  8. "os"
  9. "os/signal"
  10. "syscall"
  11. "time"
  13. "golang.org/x/net/context"
  14. "google.golang.org/grpc"
  16. grpclb "com.midea/jr/grpclb/naming/etcd/v3"
  17. "com.midea/jr/grpclb/example/pb"
  18. )
  20. var (
  21. serv = flag.String( "service", "hello_service", "service name")
  22. port = flag.Int( "port", 50001, "listening port")
  23. reg = flag.String( "reg", "http://127.0.0.1:2379", "register etcd address")
  24. )
  26. func main() {
  27. flag.Parse()
  29. lis, err := net.Listen( "tcp", fmt.Sprintf( "0.0.0.0:%d", *port))
  30. if err != nil {
  31. panic(err)
  32. }
  34. err = grpclb.Register(*serv, "127.0.0.1", *port, *reg, time.Second* 10, 15)
  35. if err != nil {
  36. panic(err)
  37. }
  39. ch := make( chan os.Signal, 1)
  40. signal.Notify(ch, syscall.SIGTERM, syscall.SIGINT, syscall.SIGKILL, syscall.SIGHUP, syscall.SIGQUIT)
  41. go func() {
  42. s := <-ch
  43. log.Printf( "receive signal '%v'", s)
  44. grpclb.UnRegister()
  45. os.Exit( 1)
  46. }()
  48. log.Printf( "starting hello service at %d", *port)
  49. s := grpc.NewServer()
  50. pb.RegisterGreeterServer(s, &server{})
  51. s.Serve(lis)
  52. }
  54. // server is used to implement helloworld.GreeterServer.
  55. type server struct{}
  57. // SayHello implements helloworld.GreeterServer
  58. func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
  59. fmt.Printf( "%v: Receive is %s\n", time.Now(), in.Name)
  60. return &pb.HelloReply{Message: "Hello " + in.Name}, nil
  61. }

6）实现客户端接口：helloworldclient.go

  1. package main
  3. import (
  4. "flag"
  5. "fmt"
  6. "time"
  8. grpclb "com.midea/jr/grpclb/naming/etcd/v3"
  9. "com.midea/jr/grpclb/example/pb"
  10. "golang.org/x/net/context"
  11. "google.golang.org/grpc"
  12. "strconv"
  13. )
  15. var (
  16. serv = flag.String( "service", "hello_service", "service name")
  17. reg = flag.String( "reg", "http://127.0.0.1:2379", "register etcd address")
  18. )
  20. func main() {
  21. flag.Parse()
  22. r := grpclb.NewResolver(*serv)
  23. b := grpc.RoundRobin(r)
  25. ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
  26. conn, err := grpc.DialContext(ctx, *reg, grpc.WithInsecure(), grpc.WithBalancer(b))
  27. if err != nil {
  28. panic(err)
  29. }
  31. ticker := time.NewTicker( 1 * time.Second)
  32. for t := range ticker.C {
  33. client := pb.NewGreeterClient(conn)
  34. resp, err := client.SayHello(context.Background(), &pb.HelloRequest{Name: "world " + strconv.Itoa(t.Second())})
  35. if err == nil {
  36. fmt.Printf( "%v: Reply is %s\n", t, resp.Message)
  37. }
  38. }
  39. }

7）运行测试

  1. 运行3个服务端S1、S2、S3，1个客户端C，观察各服务端接收的请求数是否相等？

  2. 关闭1个服务端S1，观察请求是否会转移到另外2个服务端？

  3. 重新启动S1服务端，观察另外2个服务端请求是否会平均分配到S1？

  4. 关闭Etcd3服务器，观察客户端与服务端通信是否正常？ 关闭通信仍然正常，但新服务端不会注册进来，服务端掉线了也无法摘除掉。

  5. 重新启动Etcd3服务器，服务端上下线可自动恢复正常。

  6. 关闭所有服务端，客户端请求将被阻塞。

猜你喜欢

转载自blog.csdn.net/linglingma9087/article/details/80904216
今日推荐
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
周排行
浏览器对同一域名进行请求的最大并发连接数
React Hook之自定义Hook
【转】MyBatis缓存机制
-Java-泛型
自动化测试常用脚本-发送邮件
LeetCode#859: Buddy Strings
java、Python处理字符串
第二篇の博客
Hadoop伪分布式环境安装
SQL Server进阶（十一）临时表、表变量
每日归档
更多
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022