etcd v3服务注册与发现

参考博客：https://www.cnblogs.com/sevenPP/p/8149890.html

ETCD服务注册分为以下几个步骤：

• 服务向ETCD注册自己的信息，即在ETCD的某个目录下创建Key以及填写Value;
• 服务可能异常退出，所以需要维护一个TTL(V3使用lease实现)，当服务异常退出时，监听程序可以监听到；
• 监听程序，可以根据自己的需求监听服务的事件；（添加、修改、删除）

注册服务

注册的时候，需要提供key,以及注册的信息info
start启动后，执行keeplive(),维护心跳，挂掉时revoke()
同时监听stop chan,相当于unregistered

package discovery

import (
   "context"
   "encoding/json"
   "fmt"
   "go.etcd.io/etcd/clientv3"
   "time"
)

type EtcdServiceInfo struct {
   Info string
}

type EtcdService struct {
   Cluster string  // 集群名称
   Name   string // 服务名称
   Info   EtcdServiceInfo // 节点信息
   stop   chan error
   leaseid clientv3.LeaseID
   client  *clientv3.Client
}

// 注册ETCD服务
func NewService (cluster, name string, info EtcdServiceInfo, hosts[] string) (*EtcdService, error){
   cli, err := clientv3.New(clientv3.Config{
      Endpoints: hosts,
      DialTimeout: 2 * time.Second,
   })

   if nil != err {
      fmt.Println(err.Error())
      return nil, err
   }
   // 返回服务对象
   return &EtcdService{
      Cluster:cluster,
      Name:  name,
      Info:  info,
      stop:  make (chan error),
      client: cli,
   }, err

}

// 启动
func (s *EtcdService) Start() error {
   // 获取心跳的通道
   ch, err := s.keepLive()
   if nil != err {
      fmt.Println(err.Error())
      return  err
   }
   go func() {
      // 死循环
      for {
         select {
         case <- s.stop:
            s.revoke()
            return
         case <- s.client.Ctx().Done():
            fmt.Println("server closed")
            return
         case /*ka*/_, ok := <-ch:
            if !ok {
               fmt.Println("keep live channel closed")
               s.revoke()
               return
            } else {
               //fmt.Printf("recv reply frem service:%s, ttl:%d\n", s.Name, ka.TTL)
            }
         }
      }
   }()
   return nil
}

// 保持心跳
func (s *EtcdService) keepLive() (<-chan *clientv3.LeaseKeepAliveResponse, error) {
   key := s.Cluster + "/" + s.Name
   value, _ := json.Marshal(s.Info)

   // minimum lease TTL is 5-second
   resp, err := s.client.Grant(context.TODO(), 5)
   if nil != err {
      fmt.Println(err.Error())
      return nil, err
   }

   fmt.Printf("Register, Key:%s, Value:%s\n", key, string(value))

   _, err = s.client.Put(context.TODO(), key, string(value), clientv3.WithLease(resp.ID))
   if nil != err {
      fmt.Println(err.Error())
      return nil, err
   }
   s.leaseid = resp.ID

   return s.client.KeepAlive(context.TODO(), resp.ID)
}

// 设置节点信息
func (s *EtcdService) SetValue(info EtcdServiceInfo) {
   s.Info = info
   tmp, _ := json.Marshal(info)
   key := s.Cluster + "/" + s.Name
   if _, err := s.client.Put(context.TODO(), key, string(tmp), clientv3.WithLease(s.leaseid)); nil != err {
      fmt.Printf("etcd set value failed! key:%s;value:%s", key, info)
   }

}

// 停止
func (s *EtcdService) Stop() {
   s.stop <- nil
}

// 撤销
func (s *EtcdService) revoke() error {
   _, err :=  s.client.Revoke(context.TODO(), s.leaseid)
   if nil != err {
      fmt.Println(err.Error())
   }
   fmt.Printf("service:%s stop\n", s.Name)
   return nil
}

监听程序Master

提供监听程序的路径PATH,启动监听程序的时候，当PUT和DELETE事件发发生的时候，监听程序都可以监听到；
但是，有的服务在监听程序启动之前就存在了，所以在在监听之前记得获取已经存在的注册的服务；

package discovery

import (
   "context"
   "encoding/json"
   "fmt"
   "go.etcd.io/etcd/clientv3"
   "math/rand"
   "time"
)

type EtcdMaster struct {
   Cluster string // 集群
   Path   string // 路径
   Nodes  map[string]*EtcdNode
   Client  *clientv3.Client
}

// Etcd注册的节点，一个节点代表一个client
type EtcdNode struct {
   State  bool
   Cluster string              // 集群
   Key       string          // key
   Info   EtcdServiceInfo       // 节点信息
}

func NewMaster(host[] string, cluster string, watchPath string) (*EtcdMaster, error) {
   cli, err := clientv3.New(clientv3.Config{
      Endpoints:host,
      DialTimeout:time.Second,
   })

   if nil != err {
      fmt.Println(err.Error())
      return nil, err
   }

   master := &EtcdMaster{
      Cluster:cluster,
      Path:watchPath,
      Nodes:make(map[string]*EtcdNode),
      Client: cli,
      }

   // 监听观察节点
   go master.WatchNodes()

   return master, err
}

func NewEtcdNode(ev *clientv3.Event) *EtcdServiceInfo {
   info := &EtcdServiceInfo{}
   err := json.Unmarshal([]byte(ev.Kv.Value), info)
   if nil != err {
      fmt.Println(err.Error())
   }
   return info
}

// 监听观察节点
func (m* EtcdMaster) WatchNodes() {
   // 查看之前存在的节点
   resp, err := m.Client.Get(context.Background(), m.Cluster + "/" + m.Path, clientv3.WithPrefix())
   if nil != err {
      fmt.Println(err.Error())
   } else {
      for _, ev := range resp.Kvs {
         fmt.Printf("add dir:%q, value:%q\n", ev.Key, ev.Value)
         info := &EtcdServiceInfo{}
         json.Unmarshal([]byte(ev.Value), info)
         m.addNode(string(ev.Key), info)
      }
   }

   rch := m.Client.Watch(context.Background(), m.Cluster + "/" + m.Path, clientv3.WithPrefix(), clientv3.WithPrevKV())
   for wresp := range rch {
      for _, ev := range wresp.Events {
         switch ev.Type {
         case clientv3.EventTypePut:
            fmt.Printf("[%s] dir:%q, value:%q\n", ev.Type, ev.Kv.Key, ev.Kv.Value)
            info := NewEtcdNode(ev)
            m.addNode(string(ev.Kv.Key), info)
         case clientv3.EventTypeDelete:
            fmt.Printf("[%s] dir:%q, value:%q\n", ev.Type, ev.Kv.Key, ev.Kv.Value)
            k :=  ev.Kv.Key
            if len( ev.Kv.Key) > (len(m.Cluster) + 1) {
               k =  ev.Kv.Key[len(m.Cluster) + 1:]
            }
            delete(m.Nodes, string(k))
         default:
            fmt.Printf("[%s] dir:%q, value:%q\n", ev.Type, ev.Kv.Key, ev.Kv.Value)
         }
      }
   }
}

// 添加节点
func (m *EtcdMaster) addNode(key string, info* EtcdServiceInfo) {
   k := key
   if len(key) > (len(m.Cluster) + 1) {
      k = key[len(m.Cluster) + 1:]
   }

   node := &EtcdNode{
      State:true,
      Cluster:m.Cluster,
      Key:k,
      Info:*info,
   }

   m.Nodes[node.Key] = node
}

// 获取该集群下所有的节点
func (m* EtcdMaster) GetAllNodes() []EtcdNode{
   var temp []EtcdNode
   for _, v := range m.Nodes {
      if nil != v {
         temp = append(temp, *v)
      }
   }
   return temp
}

func (m* EtcdMaster) GetNodeRandom() (EtcdNode, bool){
   count := len(m.Nodes)
   // 该集群不存在节点时，直接返回false
   if 0 == count {
      return EtcdNode{}, false
   }
   idx := rand.Intn(count)
   for _, v := range m.Nodes {
      if idx == 0 {
         return *v, true
      }
      idx = idx - 1
   }
   return EtcdNode{}, false
}

同时注册、监听多个服务

工程里面有时候需要监听和注册的服务不只是一个，可能同时监听多个服务和注册多个服务，这就需要进一步的封装以便能够注册、监听多个服务。

package discovery

import (
   "fmt"
   "strings"
)

type EtcdDis struct {
   Cluster string
   // 注册；key:服务名称
   MapRegister map[string]*EtcdService
   // 监听相关的服务
   MapWatch   map[string]*EtcdMaster
}

//----------------------------------------------------------------------------------
// 注册相关的函数
//----------------------------------------------------------------------------------
// 注册
func (d *EtcdDis) Register(host []string, service, key string, value EtcdServiceInfo) {
   name := service + "/" + key
   var s *EtcdService
   var e error
   if s, e = NewService(d.Cluster,name, value, host); nil != e {
      fmt.Printf("Register service:%s error:", service, e.Error())
      return
   }

   if nil == d.MapRegister {
      d.MapRegister = make(map[string]*EtcdService)
   }

   if _, ok := d.MapRegister[name]; ok {
      fmt.Printf("Service:%s Have Registered!", name)
      return
   }

   d.MapRegister[name] = s
   // w维持心跳
   s.Start()
}

// 更新
func (d *EtcdDis) UpdateInfo(service, key string, info EtcdServiceInfo) {
   name := service + "/" + key
   if sri, ok := d.MapRegister[name]; ok {
      if nil != sri {
         sri.SetValue(info)
      }
   }
}

//----------------------------------------------------------------------------------
// 监听相关的函数
//----------------------------------------------------------------------------------
func (d *EtcdDis) Watch(host []string, service string) {
   var w *EtcdMaster
   var e error
   if w, e = NewMaster(host, d.Cluster, service); nil != e {
      fmt.Printf("Watch Service:%s Failed!Error:%s", service, e.Error())
      return
   }

   if nil == d.MapWatch {
      d.MapWatch = make(map[string]*EtcdMaster)
   }

   if _, ok := d.MapWatch[service]; ok {
      fmt.Printf("Service:%s Have Watch!\n", service)
      return
   }

   d.MapWatch[service] = w
}

// 获取服务的节点信息-随机获取
func (d *EtcdDis) GetServiceInfoRandom(service string) (EtcdNode, bool) {
   if nil == d.MapWatch {
      fmt.Println("MapWatch is nil")
      return EtcdNode{}, false
   }

   if v, ok := d.MapWatch[service]; ok {
      if nil != v {
         if n, ok1 := v.GetNodeRandom(); ok1 {
            return n, true
         }
      }
   } else {
      fmt.Printf("Service:%s Not Be Watched!\n", service)
   }

   return EtcdNode{}, false
}

// 获取服务的节点信息-全部获取
func (d *EtcdDis) GetServiceInfoAllNode(service string)([]EtcdNode, bool) {
   if nil == d.MapWatch {
      fmt.Println("MapWatch is nil")
      return []EtcdNode{}, false
   }

   if v, ok := d.MapWatch[service]; ok {
      if nil != v {
         return v.GetAllNodes(),true
      }
   } else {
      fmt.Printf("Service:%s Not Be Watched!\n", service)
   }

   return []EtcdNode{}, false
}

//----------------------------------------------------------------------------------
// 工具相关函数
//----------------------------------------------------------------------------------
// 拆分service name、key；返回bool true表示成功;false表示失败
func SplitServiceNameKey(dir string) (string, string, bool) {
   if idx := strings.Index(dir,"/"); -1 != idx {
      name := dir[ : idx]
      key := dir[idx+1 :]
      return name, key, true
   }
   return "", "", false
}

使用方法-注册服务

func main() {
   info := dis.EtcdServiceInfo{Info: "123453434324"}
   e := dis.EtcdDis{Cluster:"tc"}
   e.Register([]string{"http://127.0.0.1:2379"}, "s-test", "192.168.21.35",info)
   e.Register([]string{"http://127.0.0.1:2379"}, "s-xxxx", "127.0.0.1",info)
   time.Sleep(time.Second * 10)
   info.Info = "xxxxxxxxxxx"
   e.UpdateInfo("s-test", "192.168.21.35",info)
   time.Sleep(time.Second * 10)
}

使用方法-监听服务

func main() {
   m := dis.EtcdDis{Cluster:"tc"}
   m.Watch([]string{
      "http://127.0.0.1:2379",
   }, "s-test")
   m.Watch([]string{
      "http://127.0.0.1:2379",
   }, "s-xxxx")
   for {
      if e, ok := m.GetServiceInfoAllNode("s-test"); ok {
         tmp, _ := json.Marshal(e)
         fmt.Println(string(tmp))
         if len(e) > 0 {
            name, key, _ := dis.SplitServiceNameKey(e[0].Key)
            fmt.Printf("name:%s, key:%s\n", name, key)
         }
      }

      if e, ok := m.GetServiceInfoAllNode("s-xxxx"); ok {
         tmp, _ := json.Marshal(e)
         fmt.Println(string(tmp))
      }

      //fmt.Printf("nodes num = %d\n", len(m.Nodes))
      fmt.Printf("nodes num = %d\n", 0)
      time.Sleep(time.Second * 2)
   }
}

运行截图