golang 使用grpc前的准备,基于ETCD服务发现、服务注册

主要使用ETCD来实现服务注册和服务发现

ETCD集群搭建参考https://www.jianshu.com/p/690d8adcb8c6

为什么使用grpc前要实现服务发现、服务注册?

考虑微服务水平拓展较为容易,grpc包本身没有提供服务发现和服务注册,那么在使用过程中,对应的rpc只能通过nginx等服务去进行负载均衡,而当微服务需要水平拓展时,因为没有服务发现,因此要修改nginx配置才能将该节点加入进行使用,因此需要更加智能的动态添加和删除节点,所以grpc也不必使用nginx进行负载均衡,而是在client端进行负载均衡的实现。

首先下载ETCD官方golang驱动包https://github.com/etcd-io/etcd/

go get -u -v github.com/etcd-io/etcd

但是好像github服务器的问题,不太好下载,速度太慢,去码云找了一个镜像https://gitee.com/mirrors/etcd

下载之后记得在$GOPATH路径下新建文件夹go.etcd.io,将etcd包放入该目录下。否则会出现获取etcd 的response时候,缺少Type,Kv,PrevKv等变量,放入go.etcd.io之后则可以正常使用。

废话不多说,直接上代码

服务注册

package discovery
import (
 "context"
 "go.etcd.io/etcd/clientv3"
 "time"
 "log"
 "encoding/json"
 "errors"
)
//the detail of service 定义服务结构,唯一id加ip地址
type ServiceInfo struct{
 ID uint64
 IP string
}
type Service struct {
 Name string
 Info ServiceInfo
 stop chan error
 leaseid clientv3.LeaseID
 client *clientv3.Client
}
func NewService(name string, info ServiceInfo, endpoints []string) (*Service, error) {
 cli, err := clientv3.New(clientv3.Config{
 Endpoints: endpoints,
 DialTimeout: 2 * time.Second,
 })
 if err != nil {
 log.Fatal(err)
 return nil, err
 }
 return &Service {
 Name: name,
 Info: info,
 stop: make (chan error),
 client: cli,
 },err
}
func (s *Service) Start() error {
 ch, err := s.keepAlive()
 if err != nil {
 log.Fatal(err)
 return err
 }
 for {
 select {
 case err := <- s.stop:
 s.revoke()
 return err
 case <- s.client.Ctx().Done():
 return errors.New("server closed")
 case ka, ok := <-ch:
 if !ok {
 log.Println("keep alive channel closed")
 s.revoke()
 return nil
 } else {
 log.Printf("Recv reply from service: %s, ttl:%d", s.Name, ka.TTL)
 }
 }
 }
}
func (s *Service) Stop() {
 s.stop <- nil
}
func (s *Service) keepAlive() (<-chan *clientv3.LeaseKeepAliveResponse, error){
 info := &s.Info
 key := "services/" + s.Name
 value, _ := json.Marshal(info)
 // minimum lease TTL is 5-second
 resp, err := s.client.Grant(context.TODO(), 5)
 if err != nil {
 log.Fatal(err)
 return nil, err
 }
 _, err = s.client.Put(context.TODO(), key, string(value), clientv3.WithLease(resp.ID))
 if err != nil {
 log.Fatal(err)
 return nil, err
 }
 s.leaseid = resp.ID
 return s.client.KeepAlive(context.TODO(), resp.ID)
}
func (s *Service) revoke() error {
 _, err := s.client.Revoke(context.TODO(), s.leaseid)
 if err != nil {
 log.Fatal(err)
 }
 log.Printf("servide:%s stop\n", s.Name)
 return err
}

服务发现

package discovery
import (
 "context"
 "go.etcd.io/etcd/clientv3"
 "log"
 "time"
 "encoding/json"
 "fmt"
)
type Master struct {
 Path string
 Nodes map[string] *Node
 Client *clientv3.Client
}
//node is a client
type Node struct {
 State bool
 Key string
 Info map[uint64]*ServiceInfo
}
func NewMaster(endpoints []string, watchPath string) (*Master,error) {
 cli, err := clientv3.New(clientv3.Config{
 Endpoints: endpoints,
 DialTimeout: time.Second,
 })
 if err != nil {
 log.Fatal(err)
 return nil,err
 }
 master := &Master {
 Path: watchPath,
 Nodes: make(map[string]*Node),
 Client: cli,
 }
 go master.WatchNodes()
 return master,err
}
func (m *Master) AddNode(key string, info *ServiceInfo) {
 node, ok := m.Nodes[key]
 if !ok {
 node = &Node{
 State: true,
 Key: key,
 Info: map[uint64]*ServiceInfo{info.ID:info},
 }
 m.Nodes[node.Key] = node
 } else {
 node.Info[info.ID] = info
 }
}
func (m *Master) DeleteNode(key string, info *ServiceInfo) {
 node, ok := m.Nodes[key]
 if !ok {
 return
 } else {
 delete(node.Info, info.ID)
 }
}
func GetServiceInfo(ev *clientv3.Event) *ServiceInfo {
 info := &ServiceInfo{}
 err := json.Unmarshal([]byte(ev.Kv.Value), info)
 if err != nil {
 log.Println(err)
 }
 return info
}
func (m *Master) WatchNodes() {
 rch := m.Client.Watch(context.Background(), m.Path, clientv3.WithPrefix())
 for wresp := range rch {
 for _, ev := range wresp.Events {
 switch ev.Type {
 case clientv3.EventTypePut:
 fmt.Printf("[%s] %q : %q\n", ev.Type, ev.Kv.Key, ev.Kv.Value)
 info := GetServiceInfo(ev)
 m.AddNode(string(ev.Kv.Key), info)
 case clientv3.EventTypeDelete:
 fmt.Printf("[%s] %q : %q\n", ev.Type, ev.Kv.Key, ev.Kv.Value)
 info := GetServiceInfo(ev)
 m.DeleteNode(string(ev.Kv.Key), info)
 }
 }
 }
}

服务启动时,将自己的信息通过NewService获得etcd连接对象,将自己的服务器信息上传,同时声明一个NewMaster的etcd连接对象,使用Watch监控,主要负责发现服务,并将服务记录或者删除过期服务。

跑起来没遇到什么问题,实现了基本的服务发现与服务注册机制。但要使用grpc还需要在客户端使用grpc-lb进行rpc调用,还是需要再去看下grpc-lb包的使用,不过离完整使用grpc已经不远了~。

本文来自:简书

感谢作者:青果山圣斗士

查看原文:golang 使用grpc前的准备,基于ETCD服务发现、服务注册

• 编辑
• 预览