主要使用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之后则可以正常使用。
image.png
废话不多说，直接上代码
服务注册
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)
}
}
}
}