您的位置: 首页  >  文章  >  ZooKeeper的安装和API

ZooKeeper的安装和API

分类: 文章 • 2024-11-16 19:37:09
Zookeeper的分布式安装和API介绍：

安装教程

在datanode1、datanode2和datanode3三个节点上部署Zookeeper。

步骤

  1. 解压zookeeper安装包到/opt/module/目录下
1
 
tar -zxvf zookeeper-3.4.10.tar.gz -C /opt/module/
  1. /opt/module/zookeeper-3.4.10/这个目录下创建zkData
1
 
mkdir -p zkData
  1. 重命名/opt/module/zookeeper-3.4.10/conf这个目录下的zoo_sample.cfg为zoo.cfg
1
 
mv zoo_sample.cfg zoo.cfg
  1. 配置zoo.cfg文件
1
2
3
4
 
#######################cluster##########################
server.2=datanode1:2888:3888
server.3=datanode2:2888:3888
server.4=datanode3:2888:3888

server.A=B:C:D。

A是一个数字，表示这个是第几号服务器；

B是这个服务器的ip地址或者主机名；

C是这个服务器与集群中的Leader服务器交换信息的端口；

D是万一集群中的Leader服务器挂了，需要一个端口来重新进行选举，选出一个新的Leader，而这个端口就是用来执行选举时服务器相互通信的端口。

集群模式下配置一个文件myid，这个文件在dataDir目录下，这个文件里面有一个数据就是A的值，Zookeeper启动时读取此文件，拿到里面的数据与zoo.cfg里面的配置信息比较从而判断到底是哪个server。

  1. 在/opt/module/zookeeper-3.4.10/zkData目录下创建一个myid的文件
1
 
touch myid

  1. 编辑myid文件,各个节点的值根据配置文件zoo.cfg来

  2. 拷贝配置好的zookeeper到其他机器上并分别修改myid文件中内容为3、4

1
 
touch myid
  1. 启动脚本
1
2
3
4
5
6
7
 
#!/bin/sh
echo "starting zookeeper server..."
hosts="datanode1 datanode2 datanode3" 
for host in $hosts
do
  ssh $host  "source /etc/profile; /opt/module/zookeeper-3.4.10/bin/zkServer.sh start"
done

停止脚本换成stop即可

  1. 查看zhua状态
1
 
zkServer.sh status

客户端命令行操作

命令基本语法 功能描述
help 显示所有操作命令
ls path [watch] 使用 ls 命令来查看当前znode中所包含的内容
ls2 path [watch] 查看当前节点数据并能看到更新次数等数据
create 普通创建 -s 含有序列 -e 临时（重启或者超时消失）
get path [watch] 获得节点的值
set 设置节点的具体值
stat 查看节点状态
delete 删除节点
rmr 递归删除节点

Shell命令

启动客户端

1
 
bin/zkCli.sh

显示所有操作命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
[zk: localhost:2181(CONNECTED) 0] help
ZooKeeper -server host:port cmd args
        connect host:port
        get path [watch]
        ls path [watch]
        set path data [version]
        rmr path
        delquota [-n|-b] path
        quit
        printwatches on|off
        create [-s] [-e] path data acl
        stat path [watch]
        close
        ls2 path [watch]
        history
        listquota path
        setAcl path acl
        getAcl path
        sync path
        redo cmdno
        addauth scheme auth
        delete path [version]
        setquota -n|-b val path

查看当前znode中所包含的内容

1
2
 
[zk: localhost:2181(CONNECTED) 1] ls /
[isr_change_notification, test, hbase, zookeeper, admin, consumers, cluster, config, latest_producer_id_block, kafka-manager, brokers, controller_epoch]

查看当前节点数据并能看到更新次数等数据

1
2
3
4
5
6
7
8
9
10
11
12
13
 
[zk: localhost:2181(CONNECTED) 2]  ls2 /
[isr_change_notification, test, hbase, zookeeper, admin, consumers, cluster, config, latest_producer_id_block, kafka-manager, brokers, controller_epoch]
cZxid = 0x0
ctime = Thu Jan 01 08:00:00 CST 1970
mZxid = 0x0
mtime = Thu Jan 01 08:00:00 CST 1970
pZxid = 0x1200000104
cversion = 100
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 0
numChildren = 12

创建普通节点

1
2
3
4
 
[zk: localhost:2181(CONNECTED) 3]  create /app1 "hello app1"
Created /app1
[zk: localhost:2181(CONNECTED) 4] create /app1/server101 "192.168.1.101"
Created /app1/server101

获得节点的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
[zk: localhost:2181(CONNECTED) 5] get /app1
hello app1
cZxid = 0x120000010a
ctime = Sat Jan 05 13:34:15 CST 2019
mZxid = 0x120000010a
mtime = Sat Jan 05 13:34:15 CST 2019
pZxid = 0x120000010b
cversion = 1
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 10
numChildren = 1
[zk: localhost:2181(CONNECTED) 6] get /app1/server101
192.168.1.101
cZxid = 0x120000010b
ctime = Sat Jan 05 13:34:46 CST 2019
mZxid = 0x120000010b
mtime = Sat Jan 05 13:34:46 CST 2019
pZxid = 0x120000010b
cversion = 0
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 13
numChildren = 0

创建短暂节点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
[zk: localhost:2181(CONNECTED) 7] create -e /app-emphemeral 8888
Created /app-emphemeral
## 在当前客户端是能查看到的
[zk: localhost:2181(CONNECTED) 8]  ls /
[app1, isr_change_notification, test, hbase, zookeeper, admin, consumers, cluster, config, latest_producer_id_block, kafka-manager, app-emphemeral, brokers, controller_epoch]
## 退出当前客户端然后再重启客户端
[zk: localhost:2181(CONNECTED) 9] quit
Quitting...
2019-01-06 17:43:54,558 [myid:] - INFO  [main:[email protected]] - Session: 0x1681924b94d0014 closed
2019-01-06 17:43:54,564 [myid:] - INFO  [main-EventThread:[email protected]] - EventThread shut down for session: 0x1681924b94d0014
## 重启客户端
[[email protected] bin]$ ./zkCli.sh
....
2019-01-06 17:46:04,711 [myid:] - INFO  [main-SendThread(localhost:2181):[email protected]] - Session establishment complete on server localhost/127.0.0.1:2181, sessionid = 0x1681924b94d0015, negotiated timeout = 30000

WATCHER::

WatchedEvent state:SyncConnected type:None path:null
## 再次查看根目录下短暂节点已经删除

[zk: localhost:2181(CONNECTED) 0] ls /
[app1, isr_change_notification, test, hbase, zookeeper, admin, consumers, cluster, config, latest_producer_id_block, kafka-manager, brokers, controller_epoch]

创建带序号的节点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
## 先创建一个普通的根节点app2
[zk: localhost:2181(CONNECTED) 1] create /app2 "app2"
Created /app2
## 创建带序号的节点
[zk: localhost:2181(CONNECTED) 2] create /app2 "app2"
[zk: localhost:2181(CONNECTED) 3] create -s /app2/aa 888
Created /app2/aa0000000000
[zk: localhost:2181(CONNECTED) 4] create -s /app2/bb 888
Created /app2/bb0000000001
[zk: localhost:2181(CONNECTED) 5] create -s /app2/cc 888
Created /app2/cc0000000002
##如果原节点下有1个节点，则再排序时从1开始，以此类推。
[zk: localhost:2181(CONNECTED) 6] create -s /app1/aa 888
Created /app1/aa0000000001

修改节点数据值

1
2
3
4
5
6
7
8
9
10
11
12
 
[zk: localhost:2181(CONNECTED) 8] set /app1 999
cZxid = 0x120000010a
ctime = Sat Jan 05 13:34:15 CST 2019
mZxid = 0x1200000116
mtime = Sat Jan 05 14:12:56 CST 2019
pZxid = 0x1200000114
cversion = 3
dataVersion = 1
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 3
numChildren = 3

节点的值变化监听

在datanode1主机上注册监听/app1节点数据变化

1
2
3
4
5
6
7
8
9
10
11
12
13
 
[zk: localhost:2181(CONNECTED) 9] get /app1 watch
999
cZxid = 0x120000010a
ctime = Sat Jan 05 13:34:15 CST 2019
mZxid = 0x1200000116
mtime = Sat Jan 05 14:12:56 CST 2019
pZxid = 0x1200000114
cversion = 3
dataVersion = 1
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 3
numChildren = 3

在datanode2主机上修改/app1节点的数据

1
2
3
4
5
6
7
8
9
10
11
12
 
[zk: localhost:2181(CONNECTED) 0] set /app1  777
cZxid = 0x120000010a
ctime = Sat Jan 05 13:34:15 CST 2019
mZxid = 0x1200000118
mtime = Sat Jan 05 14:14:43 CST 2019
pZxid = 0x1200000114
cversion = 3
dataVersion = 2
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 3
numChildren = 3

datanode1主机上的变化

1
2
3
4
 
[zk: localhost:2181(CONNECTED) 10]
WATCHER::

WatchedEvent state:SyncConnected type:NodeDataChanged path:/app1

节点的子节点变化监听（路径变化）

在datanode1主机上注册监听/app1节点的子节点变化

1
2
 
[zk: localhost:2181(CONNECTED) 0] ls /app1 watch
[aa0000000001, server101, cc0000000002]

在datanode2主机/app1节点上创建子节点

1
2
 
[zk: localhost:2181(CONNECTED) 1] create /app1/bb 666
Created /app1/bb

观察datanode1主机收到子节点变化的监听

1
2
 
WATCHER::
WatchedEvent state:SyncConnected type:NodeChildrenChanged path:/app1

删除节点

1
 
[zk: localhost:2181(CONNECTED) 2] delete /app1/bb

递归删除节点

1
 
[zk: localhost:2181(CONNECTED) 3] rmr /app2

查看节点状态

1
2
3
4
5
6
7
8
9
10
11
12
 
[zk: localhost:2181(CONNECTED) 1]  stat /app1
cZxid = 0x120000010a
ctime = Sat Jan 05 13:34:15 CST 2019
mZxid = 0x1200000118
mtime = Sat Jan 05 14:14:43 CST 2019
pZxid = 0x120000011d
cversion = 5
dataVersion = 2
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 3
numChildren = 3

API应用

IDEA环境搭建

  1. 创建一个Maven工程

  2. 添加pom文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    		 
    <dependencies>
    	<dependency>
    		<groupId>junit</groupId>
    		<artifactId>junit</artifactId>
    		<version>RELEASE</version>
    	</dependency>
    	<dependency>
    		<groupId>org.apache.logging.log4j</groupId>
    		<artifactId>log4j-core</artifactId>
    		<version>2.8.2</version>
    	</dependency>
    	<!-- https://mvnrepository.com/artifact/org.apache.zookeeper/zookeeper -->
    	<dependency>
    		<groupId>org.apache.zookeeper</groupId>
    		<artifactId>zookeeper</artifactId>
    		<version>3.4.10</version>
    	</dependency>
    </dependencies>

log4j.propertie

1
2
3
4
5
6
7
8
 
log4j.rootLogger=INFO, stdout  
log4j.appender.stdout=org.apache.log4j.ConsoleAppender  
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n  
log4j.appender.logfile=org.apache.log4j.FileAppender  
log4j.appender.logfile.File=target/spring.log  
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout  
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

创建ZooKeeper客户端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
public class ZKDemo {
    private String connect = "datanode1:2181,datanode2:2181,datanode3:2181";
    private int timeout = 2000;
    private ZooKeeper zooKeeper = null;

    //获取Zookeeper的客户端
    @Before
    public void getClient() throws Exception {
        zooKeeper = new ZooKeeper(connect, timeout, new Watcher() {
            //接收到Zookeeper发来的通知以后做出的处理措施(自己处理的业务逻辑)
            @Override
            public void process(WatchedEvent watchedEvent) {
                System.out.println(watchedEvent.getType() + "-----" + watchedEvent.getPath());
            }
        });
    }

创建子节点

1
2
3
4
5
6
7
8
9
10
11
 
//创建节点
@Test
public void testCreate() throws KeeperException, InterruptedException {
 // 参数1：要创建的节点的路径； 参数2：节点数据 ； 参数3：节点权限 ；参数4：节点的类型
    String path = zooKeeper.create(
            "/cainiaoqingfeng",
            "bigtadaLearing".getBytes(),
            ZooDefs.Ids.OPEN_ACL_UNSAFE,
            CreateMode.PERSISTENT);
    System.out.println(path);
}
 
1
2
 
[zk: localhost:2181(CONNECTED) 2] ls /
[test, cainiaoqingfeng, consumers, latest_producer_id_block, controller_epoch, app2, app1, isr_change_notification, hbase, admin, zookeeper, config, cluster, kafka-manager, brokers]

判断节点是否存在

1
2
3
4
 
public void testExist() throws KeeperException, InterruptedException {
     Stat stat = zooKeeper.exists("/cainiaoqingfeng", false);
     System.out.println(stat==null?"not exist":"exist");
 }

循环监听

1
2
3
4
5
6
7
8
9
10
 
      try {
                    List<String> children = zooKeeper.getChildren("/cainiaoqingfeng", true);
                    for (String child : children) {
                        System.out.println(child);
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                }
//在创建Zookeeper客户端的代码中加此以上代码

改变节点的内容

1
2
3
4
 
public void testSet() throws KeeperException, InterruptedException {
    Stat stat = zooKeeper.setData("/cainiaoqingfeng/bigdata", "I love bigdata".getBytes(), -1);

}
 
1
2
3
4
5
6
7
8
9
10
11
12
 
[zk: localhost:2181(CONNECTED) 20] get /cainiaoqingfeng/bigdata
I love bigdata
cZxid = 0x1200000126
ctime = Sat Jan 05 16:11:19 CST 2019
mZxid = 0x1200000136
mtime = Sat Jan 05 16:27:51 CST 2019
pZxid = 0x1200000126
cversion = 0
dataVersion = 1
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 14

监听器原理

ZooKeeper的安装和API

过程

  1. 先要有一个main()线程
  2. 在main线程中创建Zookeeper客户端，这时就会创建两个线程，一个负责网络连接通信（connet），一个负责监听（listener）。
  3. 通过connect线程将注册的监听事件发送给Zookeeper。
  4. 在Zookeeper的注册监听器列表中将注册的监听事件添加到列表中。
  5. Zookeeper监听到有数据或路径变化，就会将这个消息发送给listener线程。
  6. listener线程内部调用了process（）方法。

常见监听

2．常见的监听

（1）监听节点数据的变化：

1
 
get path [watch]

（2）监听子节点增减的变化

1
 
ls path [watch]

写数据

ZooKeeper的安装和API

ZooKeeper 的写数据流程主要分为以下几步，如图所示：

流程

  1. 比如 Client 向 ZooKeeper 的 Server1 上写数据，发送一个写请求。
  2. 如果Server1不是Leader，那么Server1 会把接受到的请求进一步转发给Leader，因为每个ZooKeeper的Server里面有一个是Leader。这个Leader 会将写请求广播给各个Server，比如Server1和Server2， 各个Server写成功后就会通知Leader。
  3. 当Leader收到大多数 Server 数据写成功了，那么就说明数据写成功了。如果这里三个节点的话，只要有两个节点数据写成功了，那么就认为数据写成功了。写成功之后，Leader会告诉Server1数据写成功了。
  4. Server1会进一步通知 Client 数据写成功了，这时就认为整个写操作成功。ZooKeeper 整个写数据流程就是这样的。

服务器节点动态上下线

ZooKeeper的安装和API

ZkServer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
import org.apache.zookeeper.*;

import java.io.IOException;

public class zkServer {
    private static String connect = "datanode1:2181,datanode2:2181,datanode3:2181";  //写自己的集群的ip和端口
    private static int timeout = 2000;
    private static ZooKeeper zooKeeper = null;
    private static String parentPahth = "/servers/";

    public static void main(String[] args) throws IOException, KeeperException, InterruptedException {
        //获取Zookeeper的客户端
        getClient();
        //启动注册
        registsServer(args[0]);
        //业务逻辑
        business(args[0]);
    }

    private static void business(String hostname) throws InterruptedException {
        System.out.println(hostname+"  is working...");
        Thread.sleep(Long.MAX_VALUE);


    }

    private static void registsServer(String hostname) throws KeeperException, InterruptedException {
        //创建临时节点
        String path = zooKeeper.create(parentPahth + "server",
                hostname.getBytes(),
                ZooDefs.Ids.OPEN_ACL_UNSAFE,
                CreateMode.EPHEMERAL_SEQUENTIAL);
        System.out.println(hostname+"  is online  "+path);
        Thread.sleep(Long.MAX_VALUE);
    }


    private static void getClient() throws IOException {
        zooKeeper = new ZooKeeper(connect, timeout, new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {
                System.out.println(watchedEvent.getType() + "**********" + watchedEvent.getPath());
            }
        });
    }
}

ZkClient

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
import org.apache.zookeeper.*;

import java.io.IOException;

public class zkServer {
    private static String connect = "datanode1:2181,datanode2:2181,datanode3:2181";  //写自己的集群的ip和端口
    private static int timeout = 2000;
    private static ZooKeeper zooKeeper = null;
    private static String parentPahth = "/servers/";

    public static void main(String[] args) throws IOException, KeeperException, InterruptedException {
        //获取Zookeeper的客户端
        getClient();
        //启动注册
        registsServer(args[0]);
        //业务逻辑
        business(args[0]);
    }

    private static void business(String hostname) throws InterruptedException {
        System.out.println(hostname+"  is working...");
        Thread.sleep(Long.MAX_VALUE);


    }

    private static void registsServer(String hostname) throws KeeperException, InterruptedException {
        //创建临时节点
        String path = zooKeeper.create(parentPahth + "server",
                hostname.getBytes(),
                ZooDefs.Ids.OPEN_ACL_UNSAFE,
                CreateMode.EPHEMERAL_SEQUENTIAL);
        System.out.println(hostname+"  is online  "+path);
        Thread.sleep(Long.MAX_VALUE);
    }


    private static void getClient() throws IOException {
        zooKeeper = new ZooKeeper(connect, timeout, new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {
                System.out.println(watchedEvent.getType() + "**********" + watchedEvent.getPath());
            }
        });
    }
}

ZooKeeper的安装和API

ZooKeeper的安装和API

​ 参考资料:尚硅谷Zookeeper

相关推荐