zookeeper從小白到精通

Jeff的技術棧發表於2022-03-27

目錄

1.介紹

1.1概念

zookeeper作用：用於維護配置資訊、命名、提供分散式同步和提供組服務
zookeeper主要是檔案系統和通知機制

檔案系統主要是用來儲存資料
通知機制主要是伺服器或者客戶端進行通知，並且監督
基於觀察者模式設計的分散式服務管理框架，開源的分散式框架

1.2特點

1):一個leader，多個follower的叢集
2):叢集只要有半數以上包括半數就可正常服務，一般安裝奇數臺伺服器
3):全域性資料一致，每個伺服器都儲存同樣的資料，實時更新
4):更新的請求順序保持順序（來自同一個伺服器）
5):資料更新的原子性，資料要麼成功要麼失敗（大事務）
6):資料實時更新性很快（因為資料量很小）

1.3主要的叢集步驟

1):服務端啟動時去註冊資訊（建立都是臨時節點）
2):獲取到當前線上伺服器列表，並且註冊監聽
3):伺服器節點下線
4):伺服器節點上下線事件通知
5):process(){重新再去獲取伺服器列表，並註冊監聽}

1.4資料結構

與 Unix 檔案系統很類似，可看成樹形結構，每個節點稱做一個ZNode。每一個ZNode預設能夠儲存 1MB 的資料。也就是隻能儲存小資料(一般配置資訊，註冊資訊等)

1.5應用場景

1):統一命名服務（域名服務）
    在分散式環境下，經常需要對應用/服務進行統一命名，便於識別，eg:ip不容易記住，而域名容易記住

2):統一配置管理（一個叢集中的所有配置都一致，且也要實時更新同步）

3):將配置資訊寫入ZooKeeper上的一個Znode，各個客戶端伺服器監聽這個Znode。一旦Znode中的資料被修改，ZooKeeper將通知各個客戶端伺服器

4):統一叢集管理（掌握實時狀態）

5):將節點資訊寫入ZooKeeper上的一個ZNode。監聽ZNode獲取實時狀態變化

6):伺服器節點動態上下線

7):軟負載均衡（根據每個節點的訪問數，讓訪問數最少的伺服器處理最新的資料需求）

2.本地安裝

2.1安裝jdk

1.檢視是否已安裝JDK
yum list installed |grep java 

2.解除安裝CentOS系統Java環境
# yum -y remove java-1.8.0-openjdk*   *表示解除安裝所有openjdk相關檔案輸入 
# yum -y remove tzdata-java.noarch       解除安裝tzdata-java  

3.檢視JDK軟體包版本
# yum -y list java*      或者使用# yum searchjava | grep -i --color JDK 

4.安裝
yum install java-1.8.0-openjdk*  //安裝java1.8.0所有程式
java -version //檢視java版本資訊

注意：使用yum安裝環境變數自動就配好了

2.2下載安裝

官網：https://zookeeper.apache.org/
下載3.5.7穩定版本
下載：https://archive.apache.org/dist/zookeeper/zookeeper-3.5.7/
wget https://archive.apache.org/dist/zookeeper/zookeeper-3.5.7/apache-zookeeper-3.5.7-bin.tar.gz
解壓：tar -xf apache-zookeeper-3.5.7-bin.tar.gz -C /opt/module/
改名：mv apache-zookeeper-3.5.7-bin zookeeper-3.5.7
配置檔案改名：mv zoo_sample.cfg zoo.cfg

bin目錄 框架啟動停止，客戶端和服務端的
conf 配置檔案資訊
docs文件
lib 配置文件的依賴

2.3配置檔案修改

配置檔案：/opt/module/zookeeper-3.5.7/conf/zoo.cfg

修改：
dataDir = /opt/module/zookeeper-3.5.7/zkData // 通常修改的路徑

2.4啟動服務端

cd /opt/module/zookeeper-3.5.7/bin
[root@sg-15 bin]# ./zkServer.sh start  // 啟動服務端

//檢視程式
[root@sg-15 bin]# jps -l
21172 sun.tools.jps.Jps
21110 org.apache.zookeeper.server.quorum.QuorumPeerMain

2.5啟動客戶端

[root@sg-15 bin]# ./zkCli.sh  // 啟動客戶端
[zk: localhost:2181(CONNECTED) 4] ls /
[zookeeper]

[zk: localhost:2181(CONNECTED) 5] quit //退出客戶端

[root@sg-15 bin]# ./zkServer.sh status // 檢視zookeeper狀態
/usr/bin/java
ZooKeeper JMX enabled by default
Using config: /opt/module/zookeeper-3.5.7/bin/../conf/zoo.cfg
Client port found: 2181. Client address: localhost.
Mode: standalone

2.6zookeeper常用命令

[root@sg-15 bin]# ./zkServer.sh start  // 啟動服務端
[root@sg-15 bin]# ./zkServer.sh stop   // 停止服務端
[root@sg-15 bin]# jps -l               // 檢視程式
[root@sg-15 bin]# ./zkCli.sh           // 啟動客戶端
[zk: localhost:2181(CONNECTED) 5] quit // 退出客戶端
[root@sg-15 bin]# ./zkServer.sh status // 檢視zookeeper狀態

2.7配置檔案解讀

配置檔案的5大引數：

tickTime = 2000  //通訊心跳時間，Zookeeper伺服器與客戶端心跳時間，單位毫秒
initLimit = 10   //Leader和Follower初始連線時能容忍的最多心跳數（tickTime的數量）
syncLimit = 5    //Leader和Follower之間通訊時間如果超過5個心跳時間，Leader認為Follwer死掉，從伺服器列表中刪除Follwer。
dataDir =/tmp/zookeeper //儲存zookeeper的資料，這是預設值，會定時被系統清除
dataDir儲存zookeeper的資料，預設是temp會被系統定期清除，通常改為自己的路徑

dataDir = /opt/module/zookeeper-3.5.7/zkData // 通常修改的路徑

clientPort = 2181  //客戶端的連線埠，一般不需要修改

3.叢集安裝

3.1叢集規劃

sg15,sg16,sg17三臺機器部署Zookeeper

3.2安裝

解壓：tar -xf apache-zookeeper-3.5.7-bin.tar.gz -C /opt/module/
改名：mv apache-zookeeper-3.5.7-bin zookeeper-3.5.7
配置檔案改名：mv zoo_sample.cfg zoo.cfg

3.3配置

[root@sg-15 zookeeper-3.5.7]# mkdir zkData  // 建立目錄zkData
[root@sg-15 zkData]# vi myid                // 建立一個 myid 的檔案
在檔案中新增與 server 對應的編號（注意：上下不要有空行，左右不要有空格）
5    // 192.168.0.215,這裡設定伺服器尾號，其他的不重複就行

[root@sg-15 conf]# mv zoo_sample.cfg zoo.cfg  // 配置檔案改名
[root@sg-15 conf]# vi zoo.cfg                //修改配置檔案
dataDir = /opt/module/zookeeper-3.5.7/zkData // 通常修改的路徑
// 新增配置
#######################cluster##########################
server.5=192.168.0.215:2888:3888
server.6=192.168.0.216:2888:3888
server.7=192.168.0.217:2888:3888

##配置引數解讀
server.A=B:C:D
A 是一個數字，表示這個是第幾號伺服器，就是myid中的值
B 是這個伺服器的地址
C 是這個伺服器Follower 與叢集中的 Leader 伺服器交換資訊的埠；
D 是萬一叢集中的 Leader 伺服器掛了，需要一個埠來重新進行選舉，選出一個新的
Leader，而這個埠就是用來執行選舉時伺服器相互通訊的埠。

注意：一臺機器弄好之後，打包傳送到其他機器。其他機器修改myid值
tar -cf module.tar ./module  // 打包
scp -r module.tar root@192.168.0.216:/opt/  //傳送
tar -xf module.tar          // 解包

3.4啟動zookeeper叢集

注意：叢集只要有半數以上包括半數就可正常服務。

三臺機器啟動：
[root@sg-15 bin]# ./zkServer.sh start    //啟動
[root@sg-15 bin]# ./zkServer.sh restart  //重啟
[root@sg-17 bin]# ./zkServer.sh status   //檢查狀態
/usr/bin/java
ZooKeeper JMX enabled by default
Using config: /opt/module/zookeeper-3.5.7/bin/../conf/zoo.cfg
Client port found: 2181. Client address: localhost.
Mode: leader                  //本機器為leader

[root@sg-15 bin]# ./zkServer.sh status
/usr/bin/java
ZooKeeper JMX enabled by default
Using config: /opt/module/zookeeper-3.5.7/bin/../conf/zoo.cfg
Client port found: 2181. Client address: localhost.
Mode: follower           //本機器為follower

4.選舉機制

選舉誰當leader
介紹：
SID：伺服器ID。用來唯一標識一臺ZooKeeper叢集中的機器，每臺機器不能重複，和myid一致。
ZXID：事務ID。ZXID是一個事務ID，用來標識一次伺服器狀態的變更。在某一時刻， 叢集中的每臺機器的ZXID值不一定完全一樣
Epoch：每個Leader任期的代號。沒有Leader時同一輪投票過程中的邏輯時鐘值是

4.1觸發選舉時機

1.伺服器剛啟動
2.伺服器執行期間無法和leader保持連線

當一臺機器進入leader選舉流程時，當前叢集出現兩種狀態：
 1.叢集中已經存在一個leader（此機器和leader建立連線，並狀態同步）
 2.叢集中不存在leader（觸發選舉），looking狀態

4.2zookeeper選舉機制---第一次啟動

伺服器1:myid=1
伺服器2:myid=2
伺服器3:myid=3
（1）	伺服器1啟動，發起一次選舉。伺服器1投自己一票。此時伺服器1票數一票，不夠半數以上（3票），選舉無法完成，伺服器1狀態保持為LOOKING；
（2）	伺服器2啟動，再發起一次選舉。伺服器1和2分別投自己一票並交換選票資訊：伺服器1和伺服器2比較誰的myid大，更改選票為推舉伺服器myid大的。此時伺服器1票數0票，伺服器2票數2票，大於半數以上結果，選舉完成。伺服器1為follower，2狀態為leader
（3）	伺服器3啟動，發起一次選舉。此時伺服器1，2已經不是LOOKING狀態，不會更改選票資訊。交換選票資訊結果：伺服器3為1票，此時伺服器3服從多數，更改選票資訊為伺服器2，並更改狀態為FOLLOWING；

4.2zookeeper選舉機制---非第一次啟動

伺服器1:myid=1
伺服器2:myid=2
伺服器3:myid=3
伺服器執行期間無法和leader保持連線觸發重新選舉：
假設zookeeper由5臺伺服器組成，SID分別為1,2,3,4,5,ZXID分別為8,8,8,7,7,並且此時SID為3的伺服器此時時leader。某時刻3和5出現故障，因此開始進行leader選舉：
 SID為1的機器：（1，8，1）
 SID為2的機器：（1，8，2）
 SID為4的機器：（1，7，4）

選舉規則：
優先比較SID,再比較ZXID,其次比較Epoch。大的直接勝出當選leader

4.3選舉機制總結

半數機制，超過半數的投票通過，即通過。
第一次啟動選舉規則：投票過半數時，伺服器 myid 大的勝出當leader
第二次啟動選舉規則：①EPOCH大的直接勝出 ②EPOCH相同，事務id大的勝出 ③事務id相同，任期代號id大的勝出

5.客戶端命令列操作

5.1常用命令整合

登陸客戶端操作：很多命令和linux命令相似，比如ls,history等
jps : 檢視zookeeper執行的程式
help :顯示所有操作命令
ls / :檢視當前znode中包含的內容
ls -s / :檢視當前節點詳細資料
create : 建立普通節點
create -s :建立帶序號節點
create -e :建立臨時普通節點
create -e -s :建立臨時有序節點
delete:刪除節點

create /wangzhe "this is wangzhe"  //新建節點（永久節點，不帶序號）
create /wangzhe/fashi "this is fashi" // //新建節點（永久節點，不帶序號）
get /wangzhe  // this is wangzhe  取值
get -s /wangzhe  //節點詳情
set set /wangzhe "this is wangzherongyao" //修改值

get -w :監聽值
ls -w /wangzhe :監聽數量
監聽註冊一個生效一次

5.2啟動客戶端

[root@sg-15 bin]# ./zkCli.sh -server 192.168.0.215:2181
quit //退出

5.3znode節點資料資訊

命令:ls -s /
[zk: 192.168.0.215:2181(CONNECTED) 3] ls -s /
[zookeeper]cZxid = 0x0
ctime = Thu Jan 01 08:00:00 CST 1970
mZxid = 0x0
mtime = Thu Jan 01 08:00:00 CST 1970
pZxid = 0x0
cversion = -1
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 0
numChildren = 1

##################################
1):czxid：建立節點的事務id zxid
  每次修改ZooKeeper 狀態都會產生一個ZooKeeper 事務 ID。事務 ID 是ZooKeeper 中所有修改總的次序。每次修改都有唯一的 zxid，如果 zxid1 小於 zxid2，那麼zxid1 在 zxid2 之前發生。

2):ctime：znode 被建立的毫秒數（從 1970 年開始）
3):mzxid：znode 最後更新的事務zxid
4):mtime：znode 最後更新的毫秒數（從 1970 年開始）
5):pZxid：znode 最後更新的子節點zxid
6):cversion：znode 子節點變化號，znode 子節點修改次數
7):dataversion：znode 資料變化號
8):aclVersion：znode 訪問控制列表的變化號
9):ephemeralOwner：如果是臨時節點，這個是 znode 擁有者的 session id。如果不是臨時節點則是 0。
10):dataLength：znode 的資料長度
11):numChildren：znode 子節點數量

5.4節點型別(持久/短暫/有序號/無序號)

持久：客戶端和服務端端開連線後，建立的節點不刪除
序號：在分散式系統中，順序號可以被用於所有事件排序，這樣客戶端可以通過順序號推斷事件的順序
{
  持久有序號：客戶端和服務端端開連線後，建立的節點不刪除。且節點名稱順序編號
  持久無序號：客戶端和服務端端開連線後，建立的節點不刪除。無序號
}

短暫：客戶端和服務端端開連線後，建立的節點自己刪除
{
  短暫有序號：客戶端和服務端端開連線後，建立的節點自己刪除。且節點名稱順序編號
  短暫無序號：客戶端和服務端端開連線後，建立的節點自己刪除。無序號
}

5.5節點操作

5.5.1建立/刪除節點

create : 建立普通節點
create -s :建立帶序號節點
create -e :建立臨時普通節點
create -e -s :建立臨時有序節點
delete:刪除一個節點(如果這個節點下有子節點，刪除失敗)
deleteall:遞迴刪除所有節點(如果這個節點下有子節點，全部刪除)
eg:delete /wangzhe/fashi //只刪除fashi節點
deleteall /wangzhe  //遞迴刪除wangzhe所有節點

//1.建立節點：普通永久節點
[zk: 192.168.0.215:2181(CONNECTED) 27] create /wangzhe "this is wangzhe"
Created /wangzhe

[zk: 192.168.0.215:2181(CONNECTED) 40] create /wangzhe/fashi "this is fashi"
Created /wangzhe/fashi

//2.建立節點：有序永久節點
[zk: 192.168.0.215:2181(CONNECTED) 66] create -s /wangzhe/fashi/daji "daji"
Created /wangzhe/fashi/daji0000000000

[zk: 192.168.0.215:2181(CONNECTED) 70] create -s /wangzhe/fashi/daji "daji"
Created /wangzhe/fashi/daji0000000001 //再次建立daji,序號+1

//3.建立節點：普通臨時節點
[zk: 192.168.0.215:2181(CONNECTED) 71] create -e /wangzhe/fashi/ganjiang "ganjiang"
Created /wangzhe/fashi/ganjiang

//4.建立節點：有序臨時節點
[zk: 192.168.0.215:2181(CONNECTED) 73] create -e -s /wangzhe/fashi/anqila "anqila"
Created /wangzhe/fashi/anqila0000000003

//檢視
[zk: 192.168.0.215:2181(CONNECTED) 74] ls /wangzhe/fashi
[anqila0000000003, daji0000000000, daji0000000001, ganjiang]


//delete刪除
[zk: 192.168.0.215:2181(CONNECTED) 19] delete /wangzhe/fashi/xiaoqiao
xiaoqiao             xiaoqiao0000000007

5.5.2獲取/檢視的值

注意：get獲取有序節點的值時：必須獲取最後一個序號的值，比如獲取下面ganjiang0000000004報錯，獲取ganjiang0000000005正常。
ls
get
get -s

//檢視
[zk: 192.168.0.215:2181(CONNECTED) 10] ls /wangzhe/fashi
[daji0000000000, daji0000000001, ganjiang0000000004, ganjiang0000000005, xiaoqiao]

//獲取值
[zk: 192.168.0.215:2181(CONNECTED) 12] get /wangzhe/fashi/xiaoqiao0000000007
xiaoqiao

// 獲取詳細
[zk: 192.168.0.215:2181(CONNECTED) 13] get -s /wangzhe/fashi/xiaoqiao0000000007
xiaoqiao
cZxid = 0x30000002f
ctime = Sat Mar 26 18:37:35 CST 2022
mZxid = 0x30000002f
mtime = Sat Mar 26 18:37:35 CST 2022
pZxid = 0x30000002f
cversion = 0
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 8
numChildren = 0

[zk: 192.168.0.215:2181(CONNECTED) 14] get -s /wangzhe/fashi
this is fashi
cZxid = 0x300000020
ctime = Sat Mar 26 17:31:12 CST 2022
mZxid = 0x300000020
mtime = Sat Mar 26 17:31:12 CST 2022
pZxid = 0x30000002f
cversion = 10
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 13
numChildren = 6

5.6節點監聽

get -w :監聽值
ls -w /wangzhe :監聽數量
監聽註冊一個生效一次

5.6.1監聽節點值改變

[zk: 192.168.0.215:2181(CONNECTED) 25] get -w /wangzhe //開啟一次監聽
this is wangzhe
[zk: 192.168.0.215:2181(CONNECTED) 26] set /wangzhe "jianting:this is wangzhe"  //修改值

WATCHER::  //監聽值發生變化
WatchedEvent state:SyncConnected type:NodeDataChanged path:/wangzhe

5.6.2監聽節點下子節點數量改變

[zk: 192.168.0.215:2181(CONNECTED) 27] ls -w /wangzhe  ////開啟一次監聽
[fashi, fashi0000000001]
[zk: 192.168.0.215:2181(CONNECTED) 28] delete /wangzhe/fashi0000000001  //刪除一個節點

WATCHER::  //監聽數量發生變化

WatchedEvent state:SyncConnected type:NodeChildrenChanged path:/wangzhe

6.goang操作zookeeper

6.1建立節點create（增）

package main

import (
	"fmt"
	"time"

	"github.com/go-zookeeper/zk"
)

func main() {
  // 任意一個ip都可以，但是建議放主節點ip
	conn, _, err := zk.Connect([]string{"192.168.0.215:2181","192.168.0.216:2181","192.168.0.217:2181"}, time.Second) 
	if err != nil {
		panic(err)
	}
	defer conn.Close()

	// 1.建立的普通永久節點
	path, err := conn.Create("/hello", []byte("world"), 0, zk.WorldACL(zk.PermAll))
	if err != nil {
		fmt.Println("err:",err)
	}
	fmt.Println("建立的普通永久節點：", path)
  
  // 2.建立的普通臨時節點，建立此節點的會話結束後立即清除此節點
	ephemeral, err := conn.Create("/ephemeral", []byte("world"), zk.FlagEphemeral, zk.WorldACL(zk.PermAll))
	if err != nil {
		fmt.Println("err:",err)
	}
	fmt.Println("建立的普通臨時節點:", ephemeral)
  
  // 3.建立的有序永久節點
	sequence, err := conn.Create("/sequence", []byte("world"), zk.FlagSequence, zk.WorldACL(zk.PermAll))
	if err != nil {
		panic(err)
	}
	fmt.Println("建立的有序永久節點:", sequence)
  
  // 4.建立的有序臨時節點，建立此節點的會話結束後立即清除此節點
	ephemeralSequence, err := conn.Create("/ephemeralSequence", []byte("world"), zk.FlagEphemeral|zk.FlagSequence, zk.WorldACL(zk.PermAll))
	if err != nil {
		panic(err)
	}
	fmt.Println("建立的有序臨時節點:", ephemeralSequence)
}

6.2檢視節點get（查）

package main

import (
	"fmt"
	"time"

	"github.com/go-zookeeper/zk"
)

func main() {
	conn, _, err := zk.Connect([]string{"192.168.0.215:2181","192.168.0.216:2181","192.168.0.217:2181"}, time.Second)
	if err != nil {
		fmt.Println("err:",err)
		return
	}
	defer conn.Close()

	result, state, err := conn.Get("/wangzhe/fashi")
	if err != nil {
		fmt.Println("err:",err)
		return
	}
	fmt.Println("result: ", string(result)) // this is fashi
	fmt.Printf("%#v",state)
  //狀態結果：&zk.Stat{Czxid:12884901920, Mzxid:12884901920, Ctime:1648287072539, Mtime:1648287072539, Version:0, Cversion:11, Aversion:0, EphemeralOwner:0, DataLength:13, NumChildren:5, Pzxid:12884901936}
}

6.3修改節點set（改）

package main

import (
	"fmt"
	"time"

	"github.com/go-zookeeper/zk"
)

func main() {
	conn, _, err := zk.Connect([]string{"192.168.0.215:2181","192.168.0.216:2181","192.168.0.217:2181"}, time.Second)
	if err != nil {
		fmt.Println("err:",err)
		return
	}
	defer conn.Close()

	path := "/wangzhe/fashi"
	_, state, _ := conn.Get(path) // 先查詢，拿到當前版本

	state, err = conn.Set(path, []byte("hello"), state.Version)
	if err != nil {
		fmt.Println("err:",err)
		return
	}
	fmt.Printf("%#v",state)
  
  //結果：&zk.Stat{Czxid:12884901920, Mzxid:12884902012, Ctime:1648287072539, Mtime:1648305221598, Version:1, Cversion:11, Aversion:0, EphemeralOwner:0, DataLength:5, NumChildren:5, Pzxid:12884901936}2022/03/26 22:33:39 recv loop 

}

6.4刪除節點delete（刪）

注意：此方法不能遞迴刪除節點

package main

import (
	"fmt"
	"time"

	"github.com/go-zookeeper/zk"
)

func main() {
	conn, _, err := zk.Connect([]string{"192.168.0.215:2181","192.168.0.216:2181","192.168.0.217:2181"}, time.Second)
	if err != nil {
		fmt.Println("err:",err)
		return
	}
	defer conn.Close()

	path := "/hello"
	exists, state, err := conn.Exists(path)  //判斷是否存在和查詢版本
	if exists{
		err = conn.Delete(path, state.Version)
		if err != nil {
			fmt.Println("err:",err)
			return
		}
		fmt.Println("節點刪除成功！！！")
	}else {
		fmt.Println("節點不存在！！！")
	}
}

6.5檢視節點的子節點Children

package main

import (
	"fmt"
	"time"

	"github.com/go-zookeeper/zk"
)

func main() {
	conn, _, err := zk.Connect([]string{"192.168.0.215:2181","192.168.0.216:2181","192.168.0.217:2181"}, time.Second)
	if err != nil {
		fmt.Println("err:",err)
		return
	}
	defer conn.Close()

	childrenList, state, err := conn.Children("/wangzhe/fashi")
	if err != nil {
		fmt.Println("err:",err)
		return
	}
	fmt.Println(childrenList)
	fmt.Printf("%#v",state)
}

6.6遍歷節點Children後再get

package main

import (
	"fmt"
	"time"

	"github.com/go-zookeeper/zk"
)

func main() {
	conn, _, err := zk.Connect([]string{"192.168.0.215:2181","192.168.0.216:2181","192.168.0.217:2181"}, time.Second)
	if err != nil {
		fmt.Println("err:",err)
		return
	}
	defer conn.Close()

	childrenList, _, err := conn.Children("/wangzhe/fashi")
	if err != nil {
		fmt.Println("err:",err)
		return
	}

	for _,children:=range childrenList{
		childrenPath:= fmt.Sprintf("/wangzhe/fashi/%s",children)
		result, state, err := conn.Get(childrenPath)
		if err != nil {
			fmt.Println("err:",err)
			return
		}
		fmt.Println(string(result))
		fmt.Println(state)
	}
}

6.7判斷節點是否存在-conn.Exists

package main

import (
	"fmt"
	"time"

	"github.com/go-zookeeper/zk"
)

func main() {
	conn, _, err := zk.Connect([]string{"192.168.0.215:2181","192.168.0.216:2181","192.168.0.217:2181"}, time.Second)
	if err != nil {
		fmt.Println("err:",err)
		return
	}
	defer conn.Close()

	path := "/hello"
	exists, _, err := conn.Exists(path)
  if err != nil {
		fmt.Println("err:",err)
		return
	}
  
  if exists{
    fmt.Println("節點存在")
  }else{
    fmt.Println("節點不存在")
  }
}

7.監聽/watch

7.1監聽節點-全域性監聽

將監聽器放到Connect函式中，如果有監聽事件發生，會一直執行監聽器的回撥函式。監聽執行了一次之後要重新註冊監聽。

package main

import (
	"fmt"
	"time"

	"github.com/go-zookeeper/zk"
)


func callback(e zk.Event) {
	fmt.Println("========================")
	fmt.Println("path:", e.Path)
	fmt.Println("type:", e.Type.String())
	fmt.Println("state:", e.State.String())
}

func main() {
	eventCallbackOption := zk.WithEventCallback(callback)
  // 經過測試，在連線時會執行3次回撥函式
	conn, _, err := zk.Connect([]string{"192.168.0.215","192.168.0.216","192.168.0.217"}, time.Second,eventCallbackOption)
	if err != nil {
		fmt.Println("err:",err)
		return
	}
	defer conn.Close()


	// 註冊一個 watch
	exists, state, _, err := conn.ExistsW("/watch")
	if err != nil {
		fmt.Println("err:",err)
		return
	}


	fmt.Println("exists:",exists)
	if !exists {
		// 建立 /watch 時，觸發監聽事件，watch 失效
		_, err = conn.Create("/watch", []byte("watch"), zk.FlagEphemeral, zk.WorldACL(zk.PermAll))
		if err != nil {
			fmt.Println("err:",err)
			return
		}

		// 再註冊一個 watch
		_, state, _, err = conn.ExistsW("/watch")
		if err != nil {
			fmt.Println("err:",err)
			return
		}
	}

	// 刪除 /watch 時，觸發監聽事件，watch 失效
	err = conn.Delete("/watch", state.Version)
	if err != nil {
		fmt.Println("err:",err)
		return
	}
}

結果：

========================
path: 
type: EventSession
state: StateConnecting
========================
path: 
type: EventSession
state: StateConnected
2022/03/27 11:09:27 connected to 192.168.0.215:2181
========================
path: 
type: EventSession
state: StateHasSession
2022/03/27 11:09:27 authenticated: id=360292329056632906, timeout=4000
2022/03/27 11:09:27 re-submitting `0` credentials after reconnect
exists: false
========================
path: /watch
type: EventNodeCreated
state: Unknown
========================
path: /watch
type: EventNodeDeleted
state: Unknown

7.2監聽部分事件

package main

import (
	"fmt"
	"time"

	"github.com/go-zookeeper/zk"
)

func main() {
	conn, _, err := zk.Connect([]string{"192.168.0.215","192.168.0.216","192.168.0.217"}, time.Second)
	if err != nil {
		fmt.Println("err:",err)
		return
	}
	defer conn.Close()

	// 註冊一個 watch
	exists, _, eventChannel, err := conn.ExistsW("/watch")
	if err != nil {
		fmt.Println("err:",err)
		return
	}

	go func() {
		// 從事件 channel 中取出事件
		e := <-eventChannel
		fmt.Println("========================")
		fmt.Println("path:", e.Path)
		fmt.Println("type:", e.Type.String())
		fmt.Println("state:", e.State.String())
	}()
	if !exists {
		// 建立 臨時節點/watch 時，觸發監聽事件，watch 失效
		_, err = conn.Create("/watch", []byte("watch"), zk.FlagEphemeral, zk.WorldACL(zk.PermAll))
		if err != nil {
			fmt.Println("err:",err)
			return
		}
	}
}

8.微服務動態上下線監聽（服務註冊/發現）

8.1需求實現

微服務分散式系統中，主節點可以有多臺，可以動態上下線，任意一臺客戶端都能實時感知到主節點伺服器的上下線。

需求實現：
服務端:服務端啟動時，在zookeeper中建立臨時有序節點，服務關閉時，臨時節點自動刪除了(zookeeper臨時節點機制)
客戶端:監聽節點的變化

8.2服務端建立程式碼-(註冊服務)

package main

import (
	"fmt"
	"time"

	"github.com/go-zookeeper/zk"
)

func main() {
	conn, _, err := zk.Connect([]string{"192.168.0.215:2181","192.168.0.216:2181","192.168.0.217:2181"}, time.Second)
	if err != nil {
		fmt.Println("err:",err)
		return
	}
	defer conn.Close()
	//建立的有序臨時節點，建立此節點的會話結束後立即清除此節點 create -e -s
	ephemeralSequence, err := conn.Create("/servers/bikesvc", []byte("bikesvc"), zk.FlagEphemeral|zk.FlagSequence, zk.WorldACL(zk.PermAll))
	if err != nil {
		fmt.Println("err:",err)
		return
	}
	fmt.Println("建立的有序臨時節點:", ephemeralSequence)
	time.Sleep(time.Second*10)
}

8.3客戶端監聽程式碼-(服務發現)

package main

import (
	"fmt"
	"time"

	"github.com/go-zookeeper/zk"
)

func mirror(conn *zk.Conn, path string) (chan []string, chan error) {
	snapshots := make(chan []string)
	errors := make(chan error)
	go func() {
		for {
			snapshot, _, events, err := conn.ChildrenW(path)
			if err != nil {
				errors <- err
				return
			}
			snapshots <- snapshot
			evt := <-events
			if evt.Err != nil {
				errors <- evt.Err
				return
			}
		}
	}()
	return snapshots, errors
}

func main() {
	conn, _, err := zk.Connect([]string{"192.168.0.215:2181", "192.168.0.216:2181", "192.168.0.217:2181"}, time.Second)
	if err != nil {
		fmt.Println("err:", err)
		return
	}
	defer conn.Close()

	snapshots, errors := mirror(conn, "/servers") //監控的根節點，根節點不能刪除
	go func() {
		for {
			select {
			case snapshot := <-snapshots:
				fmt.Println("監控變化:", snapshot)
			case err := <-errors:
				fmt.Println("err:", err)
			}
		}
	}()
	for {

	}
}

結果：
服務端：
建立的有序臨時節點: /servers/bikesvc0000000010

客戶端：
監控變化: []
監控變化: [bikesvc0000000009]
監控變化: []

9.分散式鎖

加鎖進行資源保護
go-zookeeper 新增分散式鎖的方法為NewLock(c *Conn, path string, acl []ACL)。
鎖的結構體為：
type Lock struct {
	c        *Conn
	path     string
	acl      []ACL
	lockPath string
	seq      int
}

這個結構體實現了三個方法：Lock()，LockWithData(data []byte)和Unlock()

9.1分散式鎖案例

根節點“/root”判斷是否存在，不存在則建立

package main

import (
	"fmt"
	"sync"
	"time"

	"github.com/go-zookeeper/zk"
)

func main() {
	conn, _, err := zk.Connect([]string{"192.168.0.215:2181","192.168.0.216:2181","192.168.0.217:2181"}, time.Second)
	if err != nil {
		fmt.Println("err:",err)
		return
	}
	defer conn.Close()
	var wg sync.WaitGroup

	for i := 0; i < 2; i++ {
		wg.Add(1)
		go func(n int) {
			defer wg.Done()
			lock := zk.NewLock(conn, "/root/lock", zk.WorldACL(zk.PermAll)) //加鎖
			err = lock.LockWithData([]byte("it is a lock"))
			if err != nil {
				panic(err)
			}
			fmt.Println("第", n, "個 goroutine 獲取到了鎖")
			time.Sleep(time.Second*1) // 1 秒後釋放鎖
			lock.Unlock()  //解鎖
		}(i)
	}
	wg.Wait()
}

這裡給了兩個程式搶鎖，ls檢視一下鎖:
解釋：把所有程式按有序排列，當成節點放入lock節點中，按照最小的序號執行。解鎖一個刪除一個。直到節點為空，程式執行完畢。
[zk: localhost:2181(CONNECTED) 32] ls /root/lock
[_c_1dbbc1ec75b285ef10a6d6154627335c-lock-0000000153, _c_793a837ded040d01608395e5eac65979-lock-0000000152]

先執行152，再執行153

9.2監控鎖案例

監控鎖節點變化

監控程式碼

package main

import (
	"fmt"
	"time"

	"github.com/go-zookeeper/zk"
)

func mirror(conn *zk.Conn, path string) (chan []string, chan error) {
	snapshots := make(chan []string)
	errors := make(chan error)
	go func() {
		for {
			snapshot, _, events, err := conn.ChildrenW(path)
			if err != nil {
				errors <- err
				return
			}
			snapshots <- snapshot
			evt := <-events
			if evt.Err != nil {
				errors <- evt.Err
				return
			}
		}
	}()
	return snapshots, errors
}

func main() {
	conn, _, err := zk.Connect([]string{"192.168.0.215:2181", "192.168.0.216:2181", "192.168.0.217:2181"}, time.Second)
	if err != nil {
		fmt.Println("err:", err)
		return
	}
	defer conn.Close()

	snapshots, errors := mirror(conn, "/root/lock") //監控的根節點，根節點不能刪除
	go func() {
		for {
			select {
			case snapshot := <-snapshots:
				fmt.Println("監控變化:", snapshot)
			case err := <-errors:
				fmt.Println("err:", err)
			}
		}
	}()
	for {

	}
}

分散式鎖程式碼

package main

import (
	"fmt"
	"sync"
	"time"

	"github.com/go-zookeeper/zk"
)

func main() {
	conn, _, err := zk.Connect([]string{"192.168.0.215:2181","192.168.0.216:2181","192.168.0.217:2181"}, time.Second)
	if err != nil {
		fmt.Println("err:",err)
		return
	}
	defer conn.Close()
	var wg sync.WaitGroup

	for i := 0; i < 2; i++ {
		wg.Add(1)
		go func(n int) {
			defer wg.Done()
			lock := zk.NewLock(conn, "/root/lock", zk.WorldACL(zk.PermAll)) //加鎖
			err = lock.LockWithData([]byte("it is a lock"))
			if err != nil {
				panic(err)
			}
			fmt.Println("第", n, "個 goroutine 獲取到了鎖")
			time.Sleep(time.Second*1) // 1 秒後釋放鎖
			lock.Unlock()  //解鎖
		}(i)
	}
	wg.Wait()
}

結果：

相關文章