go 进阶 go-zero相关: 四. 服务注册原理

苹果香蕉西红柿

已于 2023-06-29 15:02:35 修改

阅读量577

点赞数

分类专栏： # 十四. go-zero底层原理与基本使用文章标签： golang java 分布式

于 2023-05-10 09:55:43 首次发布

本文链接：https://blog.csdn.net/qq_29799655/article/details/128724033

版权

十四. go-zero底层原理与基本使用专栏收录该内容

10 篇文章 12 订阅

订阅专栏

一. 基础

go-zero是一个集成了Web和RPC协议的服务框架,RPC也就是指go-zero的zRPC部分, zRPC底层依赖gRPC，内置了服务注册、负载均衡、拦截器等模块，其中还包括自适应降载，自适应熔断，限流等微服务治理方案，是一个简单易用的可直接用于生产的企业级RPC框架,我们在这里先了解一个服务治理这部分,怎么实现服务注册, 服务发现,服务更新的
zRPC支持直连和基于etcd服务发现两种方式,
zRPC中可以分成一下几个模块

client: zRPC客户端，负责发起请求
server: zRPC服务端，负责处理请求
resolver: 服务注册模块，实现了gRPC的resolver.Builder接口并注册到gRPC
discov: 服务发现模块，基于etcd实现服务发现功能
balancer: 负载均衡模块，实现了p2c负载均衡算法，并注册到gRPC
interceptor: 拦截器，对请求和响应进行拦截处理

在我们编写zrpc服务时,通常一个zrpc服务端,对应一个zrpc客户端, 在配置文件中设置etcd地址,将服务注册到etcd上,配置文件如下, 当服务端启动时会连接etcd将当前服务的服务名,服务地址保存到etcd, 当客户端启动时也会注册,同时会获取需要的服务端调用地址列表保存到本地

Name: hello.rpc           // 服务名
ListenOn: 127.0.0.1:9090  // 服务监听地址
Etcd:
  Hosts:
    - 127.0.0.1:2379      // etcd服务地址
  Key: hello.rpc          // 服务注册key

当客户端发起调用时会基于服务发现模块获取目标服务地址列表,负载均衡选择指定地址进行调用,并且基于拦截器统计请求结果,实现熔断限流等功能
接下来我们看一下服务注册,发现的源码,了解一下具体的执行流程

二. resolver 服务注册底层原理

参考博客
首先go-zero中rpc服务发现支持三种模式,当前只讨论服务发现模式

//直连模式
DirectScheme = "direct"
//服务发现模式
DiscovScheme = "discov"
//k8s模式
KubernetesScheme = "k8s"

编写rpc服务端时,需要配置etcd地址,设置当前服务名,服务启动时将当前服务调用地址保存到etcd,在上方已经做了配置文件的示例, 接下来看一下启动zrpc服务端代码

首先会读取配置文件,获取到当前服务的配置信息与etcd连接配置,
创建服务运行需要的Context对象,
通过proto生成的RegisterXXXServer(),将当前rpc服务实例注册到rpc服务器,
执行zrpc.MustNewServer()创建RpcServer,
调用RpcServer下的Start()启动服务

import (
	"flag"
	"fmt"
	"go_cloud_demo/rpc/internal/config"
	"go_cloud_demo/rpc/internal/server"
	"go_cloud_demo/rpc/internal/svc"
	"go_cloud_demo/rpc/types/user"
	"github.com/zeromicro/go-zero/core/conf"
	"github.com/zeromicro/go-zero/core/service"
	"github.com/zeromicro/go-zero/zrpc"
	"google.golang.org/grpc"
	"google.golang.org/grpc/reflection"
)

// 命令行参数读取配置文件所在路径
var configFile = flag.String("f", "rpc/etc/user.yaml", "the config file")

func main() {
	flag.Parse()
	//1.读取配置文件解析到Config结构体上
	var c config.Config
	conf.MustLoad(*configFile, &c)
	//2.创房服务运行上下文
	ctx := svc.NewServiceContext(c)

	//3.将服务注册到rpc服务器,并且监听指定端口启动服务
	//参数一"c.RpcServerConf":保存了当前rpc服务配置信息
	//参数二"func(grpcServer *grpc.Server)"一个函数,当执行该函数时
	//会调用通过proto生成的RegisterXXXServer(),将当前rpc服务实例注册到rpc服务器
	s := zrpc.MustNewServer(c.RpcServerConf,
		func(grpcServer *grpc.Server) {
			user.RegisterUserServer(grpcServer, server.NewUserServer(ctx))

			if c.Mode == service.DevMode || c.Mode == service.TestMode {
				reflection.Register(grpcServer)
			}
		})
	defer s.Stop()

	fmt.Printf("Starting rpc server at %s...\n", c.ListenOn)
	//4.启动
	s.Start()
}

了解服务注册中的可以分为两个步骤,分别是

执行MustNewServer()创建rpcServer时内部创建registerEtcd函数,并将该函数封装到keepAliveServer结构体中
执行Start()启动服务时,内部获取到keepAliveServer中保存的registerEtcd函数并执行,实现服务注册

1. 创建registerEtcd函数,并将该函数封装到keepAliveServer结构体中

我们看一下zrpc.MustNewServer()创建rpcServer源码,在"zrpc/server.go"下, 在MustNewServer()中调用了NewServer()

func MustNewServer(c RpcServerConf, register internal.RegisterFn) *RpcServer {
	//调用NewServer()
	server, err := NewServer(c, register)
	if err != nil {
		log.Fatal(err)
	}
	return server
}

// NewServer returns a RpcServer.
func NewServer(c RpcServerConf, register internal.RegisterFn) (*RpcServer, error) {
	var err error
	if err = c.Validate(); err != nil {
		return nil, err
	}

	var server internal.Server
	metrics := stat.NewMetrics(c.ListenOn)
	serverOptions := []internal.ServerOption{
		internal.WithMetrics(metrics),
		internal.WithRpcHealth(c.Health),
	}
	//判断是否配置了etcd连接地址与当前服务名key,如果有
	if c.HasEtcd() {
		//执行NewRpcPubServer()
		server, err = internal.NewRpcPubServer(c.Etcd, c.ListenOn, serverOptions...)
		if err != nil {
			return nil, err
		}
	} else {
		server = internal.NewRpcServer(c.ListenOn, serverOptions...)
	}

	server.SetName(c.Name)
	//设置拦截器
	if err = setupInterceptors(server, c, metrics); err != nil {
		return nil, err
	}

	rpcServer := &RpcServer{
		server:   server,
		register: register,
	}
	if err = c.SetUp(); err != nil {
		return nil, err
	}

	return rpcServer, nil
}

在NewServer()中,首先执行c.HasEtcd()判断是否配置了etcd地址,是否配置了当前服务key服务名,如果配置了,执行NewRpcPubServer()函数,该函数中,创建了服务注册核心函数registerEtcd,并将registerEtcd封装到了keepAliveServer结构体中,执行NewRpcServer()对keepAliveServer中的Server进行赋值

func NewRpcPubServer(etcd discov.EtcdConf, listenOn string, opts ...ServerOption) (Server, error) {
	//创建一个registerEtcd 函数,
	registerEtcd := func() error {
		pubListenOn := figureOutListenOn(listenOn)
		var pubOpts []discov.PubOption
		if etcd.HasAccount() {
			pubOpts = append(pubOpts, discov.WithPubEtcdAccount(etcd.User, etcd.Pass))
		}
		if etcd.HasTLS() {
			pubOpts = append(pubOpts, discov.WithPubEtcdTLS(etcd.CertFile, etcd.CertKeyFile,
				etcd.CACertFile, etcd.InsecureSkipVerify))
		}
		//创建pubClient 
		pubClient := discov.NewPublisher(etcd.Hosts, etcd.Key, pubListenOn, pubOpts...)
		//执行pubClient.KeepAlive()方法,实现服务注册
		return pubClient.KeepAlive()
	}
	//封装到keepAliveServer结构体中
	server := keepAliveServer{
		registerEtcd: registerEtcd,
		Server:       NewRpcServer(listenOn, opts...),
	}

	return server, nil
}

继续看一下keepAliveServer的结构

keepAliveServer继承了一个Server结构体,通过这个Server属性保存了服务端公共的属性方法等
并且持有一个用来实现服务注册的函数类型属性registerEtcd
查看NewRpcServer()对keepAliveServer中的Server进行赋值的函数,内部会创建一个rpcServer结构体变量
rpcServer中有一个middlewares属性,用来存储服务的中间件,还有一个baseRpcServer属性用于封装一些rpc服务端的公共属性和方法,会调用newBaseRpcServer()函数初始化这个属性
查看baseRpcServer比如存在用来存储流式拦截器的streamInterceptors属性,存储一元拦截器的器的unaryInterceptors属性等等

type keepAliveServer struct {
	registerEtcd func() error
	Server
}

func NewRpcServer(addr string, middlewares ServerMiddlewaresConf, opts ...ServerOption) Server {
	var options rpcServerOptions
	for _, opt := range opts {
		opt(&options)
	}
	if options.metrics == nil {
		options.metrics = stat.NewMetrics(addr)
	}

	return &rpcServer{
		baseRpcServer: newBaseRpcServer(addr, &options),
		middlewares:   middlewares,
		healthManager: health.NewHealthManager(fmt.Sprintf("%s-%s", probeNamePrefix, addr)),
	}
}

func newBaseRpcServer(address string, rpcServerOpts *rpcServerOptions) *baseRpcServer {
	var h *health.Server
	if rpcServerOpts.health {
		h = health.NewServer()
	}
	return &baseRpcServer{
		address: address,
		health:  h,
		metrics: rpcServerOpts.metrics,
		options: []grpc.ServerOption{grpc.KeepaliveParams(keepalive.ServerParameters{
			MaxConnectionIdle: defaultConnectionIdleDuration,
		})},
	}
}

type baseRpcServer struct {
	//服务监听的地址，例如":8080"
	address            string
	//用于提供grpc健康检查服务
	health             *health.Server
	//用于收集和上报服务的统计信息，例如请求数、响应时间、错误数等
	metrics            *stat.Metrics
	//用于存储创建grpc.Server对象时所需的配置数据
	options            []grpc.ServerOption
	//用于存储添加的流拦截器
	streamInterceptors []grpc.StreamServerInterceptor
	//于存储添加的一元拦截器
	unaryInterceptors  []grpc.UnaryServerInterceptor
}

再看一下服务端启动时添加的拦截器,在NewServer()内部的NewRpcPubServer()执行完毕keepAliveServer创建成功,并且内部持有一个用实现服务注册的函数,代码继续向下执行,调用了setupInterceptors()函数,该函数内部会根据配置选择注册拦截器

//setupInterceptors()作用:根据配置信息为rpc服务添加一些拦截器
//入参： svr是一个rpc服务对象
//		c是一个RpcServerConf结构体，包含了rpc服务的配置信息
//		metrics是一个stat.Metrics对象，用于收集和报告统计指标
func setupInterceptors(svr internal.Server, c RpcServerConf, metrics *stat.Metrics) error {
	//1.如果配置中指定了CpuThreshold参数，表示要开启自适应限流功能
	if c.CpuThreshold > 0 {
		// 创建一个自适应限流器对象，设置CPU阈值为配置中的值
		shedder := load.NewAdaptiveShedder(load.WithCpuThreshold(c.CpuThreshold))
		// 为rpc服务添加一个一元拦截器，用于执行限流逻辑，并记录统计指标
		svr.AddUnaryInterceptors(serverinterceptors.UnarySheddingInterceptor(shedder, metrics))
	}

	//2.如果配置中指定了Timeout参数，表示要开启超时控制功能
	if c.Timeout > 0 {
		// 为rpc服务添加一个一元拦截器，用于执行超时控制逻辑，超时时间为配置中的值
		svr.AddUnaryInterceptors(serverinterceptors.UnaryTimeoutInterceptor(
			time.Duration(c.Timeout) * time.Millisecond))
	}

	//3.如果配置中指定了Auth参数，表示要开启鉴权功能
	if c.Auth {
		// 调用setupAuthInterceptors函数，为rpc服务添加鉴权相关的拦截器
		if err := setupAuthInterceptors(svr, c); err != nil {
			return err
		}
	}
	return nil
}

继续查看用来添加拦截器的AddUnaryInterceptors()方法,最终会将拦截器保存到baseRpcServer的streamInterceptors属性,或unaryInterceptors属性中(下方源码在网上搜的,不知道是不是我的版本不对还是操作有问题在go-zero源码包中没找到…不能确认是否正确)

func (rs *RpcServer) AddUnaryInterceptors(interceptors ...grpc.UnaryServerInterceptor) {
	//调用内部的Server对象的AddUnaryInterceptors方法
	rs.server.AddUnaryInterceptors(interceptors...) 
}

// server.go
func (s *Server) AddUnaryInterceptors(interceptors ...grpc.UnaryServerInterceptor) {
	//将拦截器添加到unaryInterceptors切片中
	s.unaryInterceptors = append(s.unaryInterceptors, interceptors...) 
}

2. 执行registerEtcd函数实现服务注册

接下来我们看一下启动rpc服务的源码,RpcServer下的Start()源码

type RpcServer struct {
	server   internal.Server
	register internal.RegisterFn
}

func (rs *RpcServer) Start() {
	//默认会调用keepAliveServer下的Start()
	if err := rs.server.Start(rs.register); err != nil {
		logx.Error(err)
		panic(err)
	}
}

在RpcServer下的Start()中会调用keepAliveServer的Start()方法,该方法内会执行registerEtcd()注册服务地址到etcd

func (s keepAliveServer) Start(fn RegisterFn) error {
	//1.先执行registerEtcd()注册服务地址
	if err := s.registerEtcd(); err != nil {
		return err
	}
	//2.启动服务
	return s.Server.Start(fn)
}

3. registerEtcd 服务注册详细流程

再次查看NewRpcPubServer()中封装的registerEtcd()函数的源码

	//创建一个registerEtcd 函数,
	registerEtcd := func() error {
		pubListenOn := figureOutListenOn(listenOn)
		var pubOpts []discov.PubOption
		if etcd.HasAccount() {
			pubOpts = append(pubOpts, discov.WithPubEtcdAccount(etcd.User, etcd.Pass))
		}
		if etcd.HasTLS() {
			pubOpts = append(pubOpts, discov.WithPubEtcdTLS(etcd.CertFile, etcd.CertKeyFile,
				etcd.CACertFile, etcd.InsecureSkipVerify))
		}
		//创建pubClient 
		pubClient := discov.NewPublisher(etcd.Hosts, etcd.Key, pubListenOn, pubOpts...)
		//执行pubClient.KeepAlive()方法,实现服务发布以及连接
		return pubClient.KeepAlive()
	}

在registerEtcd 函数中会创建一个Publisher 结构体,执行pubClient的KeepAlive()方法

	Publisher struct {
		endpoints  []string //edct的地址
		key        string //该服务的在etcd中的key前缀,从配置文件中取
		//在etcd中的key(如果设置了id 则是key和id的组合,如果没有设置id,则是key和lease的组合)
		fullKey    string 
		id         int64 //如果设置了则用于生成fullKey
		value      string //etcd的值，是RPC服务的地址
		lease      clientv3.LeaseID //etcd的lease id
		quit       *syncx.DoneChan //用于退出操作
		//用于服务注册暂停.如果暂停则会注销etcd的lease,暂停后有两个后续操作 重启或者关闭
		pauseChan  chan lang.PlaceholderType 
		resumeChan chan lang.PlaceholderType //用于服务暂停后重启
	}

	// KeepAlive keeps key:value alive.
	func (p *Publisher) KeepAlive() error {
		//1.获取etcd连接
		cli, err := internal.GetRegistry().GetConn(p.endpoints)
		if err != nil {
			return err
		}
		//2.服务注册
		p.lease, err = p.register(cli)
		if err != nil {
			return err
		}

		proc.AddWrapUpListener(func() {
			p.Stop()
		})
		//4.开启续约监听
		return p.keepAliveAsync(cli)
	}

在go-zero rpc中服务的注册,续约等逻辑都是通过Publisher实现的,在Publisher上绑定了以下方法

NewPublisher()//Publish的构造方法
KeepAlive()//服务发布以及连接
Pause()//服务暂停
Resume()//服务重启
Stop()//服务停止
keepAliveAsync()//开启续约监听

最核心的方法就是KeepAlive()与keepAliveAsync(),其中KeepAlive()内部封装了doRegister()和keepAliveAsync(),而doRegister()内部调用了register()实现了服务注册(不同版本实现不同)

func (p *Publisher) KeepAlive() error {
	cli, err := p.doRegister()
	if err != nil {
		return err
	}

	proc.AddWrapUpListener(func() {
		p.Stop()
	})

	return p.keepAliveAsync(cli)
}

Publisher.register() 服务注册

查看Publisher.register()服务注册源码

func (p *Publisher) register(client internal.EtcdClient) (clientv3.LeaseID, error) {
	//1.创建etcd lease 过期时间 TimeToLive为10秒
	resp, err := client.Grant(client.Ctx(), TimeToLive)
	if err != nil {
		return clientv3.NoLease, err
	}

	lease := resp.ID
	//2.创建fullKey,如果id有设置过则以key和id生成fullKey；如果id没有设置则以key和lease id生成
	if p.id > 0 {
		p.fullKey = makeEtcdKey(p.key, p.id)
	} else {
		p.fullKey = makeEtcdKey(p.key, int64(lease))
	}
	//3.将value存储到etcd中，绑定到刚创建的lease中
	//通过Put方法进行注册
	_, err = client.Put(client.Ctx(), p.fullKey, p.value, clientv3.WithLease(lease))

	return lease, err
}

其中key为在配置文件中配置的Key,id为租约id,value为服务的地址
当服务注册成功后执行以下命令就可以获取到指定服务的地址

etcdctl get 配置文件中定义的服务key --prefix

Publisher.keepAliveAsync()续约监听(不同版本实现不同并且有些没找到源码,慎重参考)

查看Publisher.keepAliveAsync()异步地保持续约监听源码(不同版本实现不同)

// 异步地保持续约
func (p *Publisher) keepAliveAsync(cli internal.EtcdClient) error {
	//1.调用etcd客户端的KeepAlive方法,创建一个用来续约的无缓存channel,
	//该channel中保存了etcd keeplive状态,通过这个channel实现续约
	ch, err := cli.KeepAlive(cli.Ctx(), p.lease)
	if err != nil {
		return err
	}

	//2.通过threading.GoSafe()安全的启动一个goroutine来处理续约响应和事件
	threading.GoSafe(func() {
		for {
			//监听保存了etcd keeplive状态的channel,获取连接状态
			select {
			case _, ok := <-ch:
				if !ok {
					//如果通道返回false说明续约关闭,调用revoke()撤销租约,然后调用doKeepAlive()实现重试
					p.revoke(cli)
					if err := p.doKeepAlive(); err != nil {
						logx.Errorf("etcd publisher KeepAlive: %s", err.Error())
					}
					return
				}
			case <-p.pauseChan:
				//监听Publisher的pauseChan,获取是否有暂停操作	
				//如果收到暂停信号,执行revoke()撤销租约
				logx.Infof("paused etcd renew, key: %s, value: %s", p.key, p.value)
				p.revoke(cli)
				//有暂停操作时注销后,通过resumeChan和quit监听后续是重启还是停止
				select {
				case <-p.resumeChan:
					// 如果resumeChan收到恢复信号,则执行doKeepAlive()重试续约
					if err := p.doKeepAlive(); err != nil {
						logx.Errorf("etcd publisher KeepAlive: %s", err.Error())
					}
					return
				case <-p.quit.Done():
					// 如果收到退出信号，返回
					return
				}
			case <-p.quit.Done():
				//通过p.quit.Done()监听是否有停止操作,如果需要停止就直接注销当前租约	
				p.revoke(cli)
				return
			}
		}
	})
	return nil
}

doKeepAlive()源码(不同版本实现不同)

// 尝试与etcd保持续约
func (p *Publisher) doKeepAlive() error {
	// 创建一个一秒间隔的定时器
	ticker := time.NewTicker(time.Second)
	defer ticker.Stop()

	for range ticker.C {
		select {
		case <-p.quit.Done():
			// 如果收到退出信号，返回nil
			return nil
		default:
			// 尝试注册服务并获取租约ID
			cli, err := p.doRegister()
			if err != nil {
				// 如果注册失败，记录错误并跳出循环
				logx.Errorf("etcd publisher doRegister: %s", err.Error())
				break
			}

			// try to keep alive the lease with etcd
			// 尝试与etcd保持续约
			if err := p.keepAliveAsync(cli); err != nil {
				// 如果续约失败，记录错误并跳出循环
				logx.Errorf("etcd publisher keepAliveAsync: %s", err.Error())
				break
			}

			// 如果续约成功，返回nil
			return nil
		}
	}
	return nil
}

搜了一下网上的博客,说doKeepAlive()内部虽然开启了一个间隔一秒的定时器,但他是用来尝试注册服务和获取租约ID，而不是用来续约的,实际续约是在keepAliveAsync()中第一步执行的EtcdClient上绑定的KeepAlive()方法中,但是我又没找到相关源码,此处慎重参考,有的博客中提到:

在etcd上绑定的KeepAlive()方法中设置了一个定时器,定时时间为lease / 3大概3.3秒,也就是说每隔租约有效时间的三分之一会续约一次

三. 总结

在使用go-zero时,支持direct直连, discov服务发现, k8s三种模式,
在使用服务发现模式时,整个服务架构分注册中心,服务提供方,服务消费方三个角色

go-zero默认使用etcd作为注册中心
创建服务时要在yaml文件中配置Name当前服务名,Host当前服务ip,Port当前服务端口号,配置Etcd.Hosts注册中心地址, Etcd.Key当前服务需要调用的服务提供方名称
服务启动时执行MustLoad()将配置文件读取解析到一个Config结构体变量上
编写生产rpc服务的proto文件,基于该文件生产rpc服务,生成的文件中有一个RegisterXXXServer()函数,执行该函数将当前rpc服务实例注册到rpc服务器
执行zrpc.MustNewServer()创建RpcServer,需要传递这个RegisterXXXServer()函数
调用RpcServer下的Start()启动服务

查看zrpc下的MustNewServer()函数,内部最终会调用到一个NewServer()函数,该函数中:

执行c.HasEtcd()判断是否配置了etcd注册中心地址,如果配置了,执行NewRpcPubServer()函数
在NewRpcPubServer()中会创建一个名为registerEtcd的function函数,并将这个function封装到keepAliveServer结构体中
自此rpcServer创建成功,并封装了keepAliveServer结构体变量,内部持有一个注册服务的registerEtcd()函数

拿到RpcServer后,我们继续查看启动服务执行的Start()方法,内部会获取到这个keepAliveServer,执行keepAliveServer上的Start(),通过这个方法,在该方法内部执行前面封装的registerEtcd()进行服务注册
查看registerEtcd重点关注

执行NewPublisher()创建Publisher结构体变量,也就是服务发现相关的核心
执行Publisher上的KeepAlive()方法实现服务发布以及连接功能

Publisher是服务注册发现的核心,内部重点包含了:

endpoints 属性,内部保存了注册中心地址
key属性:当前服务在注册中心的前缀
用于服务注册暂停的pauseChan和服务暂停后重启的resumeChan
表示当前配置项的租约信息的lease属性

并且Publisher上绑定了

NewPublisher()//Publish的构造方法
doRegister()—>register()服务注册
Pause()//服务暂停
Resume()//服务重启
Stop()//服务停止
keepAliveAsync()//
7.等方法(很多此处只摘要了一些重点关注的), 最核心的方法就是KeepAlive()与keepAliveAsync(),KeepAlive()中包装了doRegister()与keepAliveAsync()

查看Publisher下的register()方法

首先创建etcd lease租约信息,租约中的TimeToLive过期时间默认为10秒
创建fullKey,如果id有设置过则以key和id生成fullKey；如果id没有设置则以key和lease id生成
将value设置到刚创建的lease中,调用EtcdClient上的Put方法进行注册,value就是服务的地址

查Publisher下的keepAliveAsync()续约监听,首先通过threding.GoSafe()安全的开启了一个协程,协程内执行,开启for循环,通过select -case

监听保存了etcd keeplive状态的channel,不是true,则先注销当前租约然后再重新KeepLive()进行服务注册
监听Publisher的pauseChan,获取是否有暂停操作,有暂停操作,执行revoke()注销当前租约,并且在有暂停操作注销后,会监听resumeChan,如果返回true则重启调用KeepAlive()重新注册,会监听quit.Done()取消
监听Publisher的quit.Done()是否有取消信号,如果有调用revoke()注销

当服务注册完毕后最终会以"/服务前缀默认是rpcx/是当前/当前服务ip:端口号"格式将当前服务信息存储到注册中心中
Publisher内部的lease租约信息中包含：

leaseID: 租约ID，这个值在创建租约时由etcd分配。
timeToLive: 租约持续时间，也就是服务注册的有效期，通常为10秒。如果超过了这个有效期，那么etcd就会将该服务注册信息删除。
keepAliveResponseChan: 续租响应状态通道，用于保存etcd返回的续租结果。当续租成功时，keepAliveResponseChan会接收到一个true值，否则接收到false值。
服务注册时会创建当前服务的lease租约数据,只要租约未到期，会一直存在etcd中，服务消费方可以随时通过etcd查询服务注册信息并发起调用请求。在租约到期前，Publisher会通过keepAlive方法不断地向etcd发送续约请求，以延长租约的有效期。这样可以保证服务注册信息一直存在于etcd中，避免因为过期而被删除

在续约监听中为什么要用threding.GoSafe():

在 Go 的默认情况下,如果一个协程中的函数出现 panic，那么这个协程和整个进程都会被直接终止
为了防止因为某个协程中的 panic 导致整个进程崩溃的情况发生,threding.GoSafe() 函数利用了 recover 函数的特性，在协程内部进行了 panic 和 recover 的处理，保证了程序的健壮性