etcd
是一个功能强大、可靠性高、易用性好的分布式键值存储系统,可以帮助用户在分布式环境中存储和同步关键数据,并实现高可用性和数据一致性。强大的观察和通知功能,使其成为一个非常适合用于作为配置管理中心或者服务注册/发现模块的选择。
一下是基于etcd
实现的服务注册/发现
1 服务注册
package main
import (
"context"
"fmt"
"log"
"net"
"os"
"os/signal"
"time"
"go.etcd.io/etcd/client/v3"
)
const (
etcdEndpoints = "localhost:2379" // etcd地址
serviceName = "/services/my-service" // 服务名称前缀
)
//空闲的端口号
func GetFreePort() (int, error) {
addr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:0")
if err != nil {
return 0, err
}
cli, err := net.ListenTCP("tcp", addr)
if err != nil {
return 0, err
}
defer cli.Close()
return cli.Addr().(*net.TCPAddr).Port, nil
}
func registerService(client *clientv3.Client, service string, address string) error {
// 创建一个租约
resp, err := client.Grant(context.Background(), 2)
if err != nil {
return err
}
// 注册服务的键值对,将服务名称和地址写入etcd中
_, err = client.Put(context.Background(), fmt.Sprintf("/services/%s/%s", service, address), address, clientv3.WithLease(resp.ID))
if err != nil {
return err
}
// 定期刷新租约
ch, err := client.KeepAlive(context.Background(), resp.ID)
if err != nil {
return err
}
go func() {
for {
select {
case resp := <-ch:
if resp == nil {
log.Println("KeepAlive channel closed")
return
}
}
}
}()
return nil
}
func main() {
// 创建etcd客户端
client, err := clientv3.New(clientv3.Config{
Endpoints: []string{etcdEndpoints},
DialTimeout: 5 * time.Second,
})
if err != nil {
log.Fatal(err)
}
defer client.Close()
port, err := GetFreePort()
if err != nil {
log.Fatal(err)
}
// 注册服务
err = registerService(client, serviceName, fmt.Sprintf("localhost:%d", port))
if err != nil {
log.Fatal(err)
}
fmt.Println(fmt.Sprintf("服务注册成功:localhost:%d", port))
sig := make(chan os.Signal, 1)
signal.Notify(sig, os.Interrupt)
select {
case <-sig:
fmt.Println("Program terminated.")
}
}
2服务发现
package main
import (
"context"
"fmt"
"log"
"os"
"os/signal"
"sync"
"time"
"go.etcd.io/etcd/client/v3"
)
const (
etcdEndpoints = "localhost:2379" // etcd地址
serviceName = "/services/my-service" // 服务名称前缀
)
type ServiceDiscovery struct {
client *clientv3.Client
lock sync.Mutex
services map[string]string
watchedKey string
}
//创建服务对象
func NewServiceDiscovery(endpoints []string, watchedKey string) (*ServiceDiscovery, error) {
client, err := clientv3.New(clientv3.Config{
Endpoints: endpoints,
})
if err != nil {
return nil, err
}
return &ServiceDiscovery{
client: client,
lock: sync.Mutex{},
services: make(map[string]string),
watchedKey: watchedKey,
}, nil
}
//服务发现
func (sd *ServiceDiscovery) DiscoverServices() error {
resp, err := sd.client.Get(context.Background(), serviceName, clientv3.WithPrefix())
if err != nil {
return err
}
for _, kv := range resp.Kvs {
sd.lock.Lock()
defer sd.lock.Unlock()
sd.services[string(kv.Key)] = string(kv.Value)
}
return nil
}
//监听
func (sd *ServiceDiscovery) WatchServices() error {
watchChan := sd.client.Watch(context.Background(), sd.watchedKey, clientv3.WithPrefix())
for watchResp := range watchChan {
for _, event := range watchResp.Events {
switch event.Type {
case clientv3.EventTypePut:
sd.handlePutEvent(event)
case clientv3.EventTypeDelete:
sd.handleDeleteEvent(event)
}
}
}
return nil
}
//新增或者修改
func (sd *ServiceDiscovery) handlePutEvent(event *clientv3.Event) {
sd.lock.Lock()
defer sd.lock.Unlock()
serviceName := string(event.Kv.Key)
serviceAddress := string(event.Kv.Value)
sd.services[serviceName] = serviceAddress
log.Printf("Added service: %s -> %s\n", serviceName, serviceAddress)
}
//删除服务
func (sd *ServiceDiscovery) handleDeleteEvent(event *clientv3.Event) {
sd.lock.Lock()
defer sd.lock.Unlock()
serviceName := string(event.Kv.Key)
delete(sd.services, serviceName)
log.Printf("Removed service: %s\n", serviceName)
}
func main() {
serviceDiscovery, err := NewServiceDiscovery([]string{etcdEndpoints}, serviceName)
if err != nil {
log.Fatalf("Failed to create ServiceDiscovery: %v", err)
}
serviceDiscovery.DiscoverServices()
go func() {
err := serviceDiscovery.WatchServices()
if err != nil {
log.Fatalf("Failed to watch services: %v", err)
}
}()
ticker := time.NewTicker(2 * time.Second)
defer ticker.Stop()
sig := make(chan os.Signal, 1)
signal.Notify(sig, os.Interrupt)
//打印服务的变化
for {
select {
case <-ticker.C:
fmt.Println("服务最新列表:")
for _, v := range serviceDiscovery.services {
fmt.Println(v)
}
case <-sig:
fmt.Println("Program terminated.")
return
}
}
}
启动服务发现
服务最新列表:
启动服务注册
服务注册成功:localhost:2724
此时服务发现窗口 2744服务已经被发现添加,
2023/09/20 23:21:35 Added service: /services/my-service/localhost:2744 -> localhost:2744
服务最新列表:
localhost:2744
再打开一个窗口启动第二个服务注册
服务注册成功:localhost:2752
此时服务发现窗口 2752服务已经被发现添加,
服务最新列表:
localhost:2744
2023/09/20 23:21:57 Added service: /services/my-service/localhost:2752 -> localhost:2752
服务最新列表:
localhost:2744
localhost:2752
关闭其中一个服务
服务注册成功:localhost:2752
Program terminated.
2023/09/20 23:22:01 KeepAlive channel closed
此时服务发现窗口已经显示2752移除,说明关闭移除正常
服务最新列表:
localhost:2744
localhost:2752
2023/09/20 23:22:03 Removed service: /services/my-service/localhost:2752
服务最新列表:
localhost:2744
到此一个简单的服务注册和发现已经完成,
总之,etcd
是一个功能强大、可靠性高、易用性好的分布式键值存储系统,可以帮助用户在分布式环境中存储和同步关键数据,并实现高可用性和数据一致性。