golang etcd服務註冊與發現

產生場景

服務端架構最前面是 一臺網關節點 ，網關後面是多臺運行着一樣的 服務的計算節點，客戶端一般就是訪問網關 ，然後 網關 就把流量 轉發到 後面的計算節點上。如果後面的計算節點信息處理不過來的時候，我們需要加機器，最low的方法就是 加上一臺服務器，然後 修改網關服務器的配置表 加上 新加的 服務器的IP 和端口，然後重啓網關。但如果後面的機器一旦down 了，網關是不知道的，還會把流量轉發到 down的機器上，造成服務的不可用，etcd可以避免硬件的單點故障或網絡問題

etcd註冊

etcd 是一個 分佈式鍵值存儲系統，在一個集羣中，如果一個節點配置了某些屬性，集羣中的每個節點都可以使用完整的存檔，我們每次在網關節點後的計算節點集羣加一個服務，只需要向etcd 註冊 該服務（其實就是 存一個值）然後向etcd 發送心跳，當etcd 沒有檢測到心跳就會 把這個鍵值對 刪了(這整個動作是etcd裏的租約模式)，網關那邊 就只需要 watch 這個 key ，就能夠知道 所有服務的所有動態了

啓動服務端：

./etcd --listen-client-urls ‘http://0.0.0.0:2379’ --advertise-client-urls ‘http://0.0.0.0:2379’
–listen-client-urls：監聽的用於客戶端通信的url,可以監聽多個
–advertise-client-urls：建議使用的客戶端通信url

etcdctl

etcdctl是官方提供的客戶端程序。
etcd有兩個版本的接口，v2和v3，且兩個版本不兼容，v2已經停止了支持，v3性能更好。etcdctl默認使用v2版本，如果想使用v3版本，可通過環境變量ETCDCTL_API=3進行設置

# 設置環境變量
> export ETCDCTL_API=3

# 放入一個 鍵值對
> ./etcdctl put "name" "amber"
OK

# 取出 key
> ./etcdctl get name
name
amber

# 刪除 key
> ./etcdctl del name
1

# 再獲取name
> ./etcdctl get name
# 什麼都沒拿到

> ./etcdctl put "/project/jobs/job1" "job1"
OK

> ./etcdctl put "/project/jobs/job2" "job2"
OK

# 獲取某個目錄下的所有key,但是直接獲取某個目錄 etcd是不認識的 因爲它沒有目錄的概念
> ./etcdctl get "/project/jobs/"
# 需要加上 --prefix命令
> ./etcdctl get "/project/jobs/" --prefix
/project/jobs/job1
job1
/project/jobs/job2
job2

# 刪除所有
> ./etcdctl del "/project/jobs/" --prefix
2

# 開始監聽某個key
> ./etcdctl watch "name"
# 。。。什麼都不打印，在等待結果

# 當另一個窗口執行了 ./etcdctl put "name" "amber" 之後
$ ./etcdctl watch "name"
PUT
name
amber

# 當另一個窗口執行了 ./etcdctl del "name" 之後
$ ./etcdctl watch "name"
PUT
name
amber
DELETE
name

續租

# 創建一個20s的租約
> ./etcdctl lease grant 20
lease 694d673115905e37 granted with TTL(20s)

# 使用租約的 id 進行 put 操作
> ./etcdctl put --lease=694d673115905e37 "name" "amber"

# 20s後get發現 key被刪除了
> ./etcdctl get "name"
# 空應答

# 刪除租約
> ./etcdctl lease revoke 694d673115905e49
lease 694d673115905e49 revoked

# 自動續租
> ./etcdctl lease keep-alive 694d673115905e4f
lease 694d673115905e4f keepalived with TTL(20)
lease 694d673115905e4f keepalived with TTL(20)

golang實現etcd續租

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

type Service struct {
    client *clientv3.Client
}

// 指定client端，Endpoints是etcd server的機器列表，DialTimeout是計算節點鏈接服務的超時時間
func NewService() *Service {
    config := clientv3.Config{
        Endpoints:   []string{"106.12.72.181:23791", "106.12.72.181:23792"},
        DialTimeout: 10 * time.Second,
    }
    client, _ := clientv3.New(config)
    return &Service{client: client}
}

//註冊服務
func (this *Service) RegService(id string, name string, address string) error {
    kv := clientv3.NewKV(this.client)
    key_prefix := "/etcd_services/"
    ctx := context.Background()
    lease := clientv3.NewLease(this.client)
    
    //設置租約過期時間爲20秒
    leaseRes, err := clientv3.NewLease(this.client).Grant(ctx, 20) 
    if err != nil {
        return err
    }
    _, err = kv.Put(context.Background(), key_prefix+id+"/"+name, address, clientv3.WithLease(leaseRes.ID)) //把服務的key綁定到租約下面
    if err != nil {
        return err
    }
    //續租時間大概自動爲租約的三分之一時間，context.TODO官方定義爲是你不知道要傳什麼
    keepaliveRes, err := lease.KeepAlive(context.TODO(), leaseRes.ID) context的時候就用這個
    if err != nil {
        return err
    }
    go lisKeepAlive(keepaliveRes)
    return err
}

func lisKeepAlive(keepaliveRes <-chan *clientv3.LeaseKeepAliveResponse) {
    for {
        select {
        case ret := <-keepaliveRes:
            if ret != nil {
                fmt.Println("續租成功", time.Now())
            }
        }
    }
}

golang server實現etcd監聽

package main

import (
	"go.etcd.io/etcd/clientv3"
	"time"
	"context"
	"go.etcd.io/etcd/mvcc/mvccpb"
	"sync"
	"log"
)

type ClientMon struct {
	client        *clientv3.Client
	serverList    map[string]string
	lock          sync.Mutex
}

// 初始化server端
func NewClientMon (addr []string)( *ClientMon, error){
	conf := clientv3.Config{
		Endpoints:   addr,
		DialTimeout: 5 * time.Second,
	}
	if client, err := clientv3.New(conf); err == nil {
		return &ClientMon{
			client:client,
			serverList:make(map[string]string),
		}, nil
	} else {
		return nil ,err
	}
}

// 獲取prefix目錄下所有內容，並返回
func (this * ClientMon) GetService(prefix string) ([]string ,error){
	resp, err := this.client.Get(context.Background(), prefix, clientv3.WithPrefix())
	if err != nil {
		return nil, err
	}
	
	// resp是從指定prefix服務下get回的value，extractAddrs將value內容存到list
	addrs := this.extractAddrs(resp)

    go this.watcher(prefix)
	return addrs ,nil
}

// 將獲取到的prefix目錄下所有內容存入list並返回
func (this *ClientMon) extractAddrs(resp *clientv3.GetResponse) []string {
	addrs := make([]string,0)
	if resp == nil || resp.Kvs == nil {
		return addrs
	}
	for i := range resp.Kvs {
		if v := resp.Kvs[i].Value; v != nil {
			this.SetServiceList(string(resp.Kvs[i].Key),string(resp.Kvs[i].Value))
			addrs = append(addrs, string(v))
		}
	}
	return addrs
}

// watch負責將監聽到的put、delete請求存放到指定list
func (this *ClientMon) watcher(prefix string) {
	rch := this.client.Watch(context.Background(), prefix, clientv3.WithPrefix())
	for wresp := range rch {
		for _, ev := range wresp.Events {
			switch ev.Type {
			case mvccpb.PUT:
				this.SetServiceList(string(ev.Kv.Key),string(ev.Kv.Value))
			case mvccpb.DELETE:
				this.DelServiceList(string(ev.Kv.Key))
			}
		}
	}
}

func (this *ClientMon) SetServiceList(key,val string) {
	this.lock.Lock()
	defer this.lock.Unlock()
	this.serverList[key] = string(val)
	log.Println("set data key :",key,"val:",val)
}

func (this *ClientMon) DelServiceList(key string) {
	this.lock.Lock()
	defer this.lock.Unlock()
	delete(this.serverList,key)
	log.Println("del data key:", key)
}

func main () {
	client,_ := NewClientMon([]string{"127.0.0.1:2379"})
	client.GetService("/node")
}