Ubuntu下ZooKeeper安装过程

「爱情、让人受尽委屈。」 2022-01-12 15:39 783阅读 0赞

[2019独角兽企业重金招聘Python工程师标准>>> ][2019_Python_] ![hot3.png][]

一、安装需求

安装java 1.6及hadoop 1.2.\*

**二、安装zookeeper**

1、下载zookeeper

wget http://apache.osuosl.org/zookeeper/zookeeper-3.4.3/zookeeper-3.4.3.tar.gz（本次安装3.4.3版本）

其他版本下载地址（最好使用stable版本）：[http://zookeeper.apache.org/releases.html][http_zookeeper.apache.org_releases.html]

2、解压

tar -xf zookeeper-3.4.3.tar.gz

将解压后的zookeeper-3.4.3文件放在系统的/home/hadooptest/中。

3、将zookeeper-3.4.3/conf目录下的zoo\_sample.cfg文件拷贝一份，命名为为“zoo.cfg”

4、修改zoo.cfg配置文件

修改zoo.cfg内容为：

\# The number of milliseconds of each tick

tickTime=2000

\# The number of ticks that the initial

\# synchronization phase can take

initLimit=10

\# The number of ticks that can pass between

\# sending a request and getting an acknowledgement

syncLimit=5

\# the directory where the snapshot is stored.

\# do not use /tmp for storage, /tmp here is just

\# example sakes.

dataDir=/home/hadooptest/zookeeper-3.4.3/zookeeperdir/zookeeper-data

dataLogDir=/home/hadooptest/zookeeper-3.4.3/zookeeperdir/logs

\# the port at which the clients will connect

clientPort=2181

\# Be sure to read the maintenance section of the

\# administrator guide before turning on autopurge.

\# http://zookeeper.apache.org/doc/current/zookeeperAdmin.html\#sc\_maintenance

\# The number of snapshots to retain in dataDir

\#autopurge.snapRetainCount=3

\# Purge task interval in hours

\# Set to "0" to disable auto purge feature

\#autopurge.purgeInterval=1

\# 2888,3888 are election port

server.1=zookeeper:2888:3888

其中，2888端口号是zookeeper服务之间通信的端口，而3888是zookeeper与其他应用程序通信的端口。而zookeeper是在hosts中已映射了本机的ip。

initLimit：这个配置项是用来配置 Zookeeper 接受客户端（这里所说的客户端不是用户连接 Zookeeper服务器的客户端，而是 Zookeeper 服务器集群中连接到 Leader 的 Follower 服务器）初始化连接时最长能忍受多少个心跳时间间隔数。当已经超过 10 个心跳的时间（也就是 tickTime）长度后 Zookeeper 服务器还没有收到客户端的返回信息，那么表明这个客户端连接失败。总的时间长度就是 5\*2000=10 秒。

syncLimit：这个配置项标识 Leader 与 Follower 之间发送消息，请求和应答时间长度，最长不能超过多少个 tickTime 的时间长度，总的时间长度就是 2\*2000=4 秒。

server.A=B：C：D：其中 A 是一个数字，表示这个是第几号服务器；B 是这个服务器的 ip 地址；C 表示的是这个服务器与集群中的 Leader 服务器交换信息的端口；D 表示的是万一集群中的 Leader 服务器挂了，需要一个端口来重新进行选举，选出一个新的 Leader，而这个端口就是用来执行选举时服务器相互通信的端口。如果是伪集群的配置方式，由于 B 都是一样，所以不同的 Zookeeper 实例通信端口号不能一样，所以要给它们分配不同的端口号。

5、创建dataDir参数指定的目录(这里指的是“ /home/hadooptest/zookeeper-3.4.3/zookeeperdir/zookeeper-data”)，并在目录下创建文件，命名为“myid”。

6、编辑“myid”文件，并在对应的IP的机器上输入对应的编号。如在zookeeper上，“myid”文件内容就是1。由于本次只在单点上进行安装配置，所以只有一个server.1。若还有其他服务器，比如地址为192.168.1.102，则在zoo.cfg文件中还需加入server.2=192.168.1.102:2888:3888。那么myid文件在192.168.1.102服务器上的内容就是2。

至此，如果是多服务器配置，就需要将zookeeper-3.4.3目录拷贝到其他服务器，然后按照上述的方法修改myid。

7、在/etc/profile文件中设置PATH

修改profile文件：

sudo vi /etc/profile

export ZOOKEEPER\_HOME=/home/hadooptest/zookeeper-3.4.3

PATH=$ZOOKEEPER\_HOME/bin:$PATH

export PATH

8、安装完毕

**三、启动并测试zookeeper**

1、在所有服务器中执行：zookeeper-3.4.3/bin/zkServer.sh start

2、输入jps命令查看进程：

namenode上显示为（本次为单机配置）：

7724 DataNode

19769 HMaster

7485 NameNode

8064 JobTracker

19361 QuorumPeerMain

8323 TaskTracker

7972 SecondaryNameNode

21691 Jps

19988 HRegionServer

其中，QuorumPeerMain是zookeeper进程，启动正常。（HMaster和HRegionServer为已启动的hbase进程，其他为安装hadoop后启动的进程）

3、查看状态：zookeeper-3.4.3/bin/zkServer.sh status

JMX enabled by default

Using config: /home/hadooptest/zookeeper-3.4.3/bin/../conf/zoo.cfg

Mode: standalone

4、启动客户端脚本：zookeeper-3.4.3/bin/zkCli.sh -server zookeeper:2181

WatchedEvent state:SyncConnected type:None path:null

\[zk: zookeeper:2181(CONNECTED) 0\]

\[zk: zookeeper: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\]

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

\[zk: zookeeper:2181(CONNECTED) 1\] ls /

\[hbase, zookeeper\]

\[zk: zookeeper:2181(CONNECTED) 2\]

5、停止zookeeper进程：zookeeper-3.4.3/bin/zkServer.sh stop

创建一个Maven工程
    打开pom.xml文件添加zookeeper依赖
     
            
                org.apache.zookeeper
                zookeeper
                3.4.6
            
    1
    2
    3
    4
    5
    创建Demo.java，代码如下：
     
    package com.shanhy.demo.zookeeper;
     
    import java.io.IOException;
     
    import org.apache.zookeeper.CreateMode;
    import org.apache.zookeeper.KeeperException;
    import org.apache.zookeeper.WatchedEvent;
    import org.apache.zookeeper.Watcher;
    import org.apache.zookeeper.ZooDefs.Ids;
    import org.apache.zookeeper.ZooKeeper;
     
    /**
     * Zookeeper测试
     *
     * @create    2016年3月10日
     */
    public class Test {
     
        // 会话超时时间，设置为与系统默认时间一致
        private static final int SESSION_TIMEOUT = 30 * 1000;
     
        // 创建 ZooKeeper 实例
        private ZooKeeper zk;
     
        // 创建 Watcher 实例
        private Watcher wh = new Watcher() {
            /**
             * Watched事件
             */
            public void process(WatchedEvent event) {
                System.out.println("WatchedEvent >>> " + event.toString());
            }
        };
     
        // 初始化 ZooKeeper 实例
        private void createZKInstance() throws IOException {
            // 连接到ZK服务，多个可以用逗号分割写
            zk = new ZooKeeper("192.168.19.130:2181,192.168.19.130:2182,192.168.19.130:2183", Test.SESSION_TIMEOUT, this.wh);
     
        }
     
        private void ZKOperations() throws IOException, InterruptedException, KeeperException {
            System.out.println("\n1. 创建 ZooKeeper 节点 (znode ： zoo2, 数据： myData2 ，权限： OPEN_ACL_UNSAFE ，节点类型： Persistent");
            zk.create("/zoo2", "myData2".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
     
            System.out.println("\n2. 查看是否创建成功： ");
            System.out.println(new String(zk.getData("/zoo2", this.wh, null)));// 添加Watch
     
            // 前面一行我们添加了对/zoo2节点的监视，所以这里对/zoo2进行修改的时候，会触发Watch事件。
            System.out.println("\n3. 修改节点数据 ");
            zk.setData("/zoo2", "shanhy20160310".getBytes(), -1);
     
            // 这里再次进行修改，则不会触发Watch事件，这就是我们验证ZK的一个特性“一次性触发”，也就是说设置一次监视，只会对下次操作起一次作用。
            System.out.println("\n3-1. 再次修改节点数据 ");
            zk.setData("/zoo2", "shanhy20160310-ABCD".getBytes(), -1);
     
            System.out.println("\n4. 查看是否修改成功： ");
            System.out.println(new String(zk.getData("/zoo2", false, null)));
     
            System.out.println("\n5. 删除节点 ");
            zk.delete("/zoo2", -1);
     
            System.out.println("\n6. 查看节点是否被删除： ");
            System.out.println(" 节点状态： [" + zk.exists("/zoo2", false) + "]");
        }
     
        private void ZKClose() throws InterruptedException {
            zk.close();
        }
     
        public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
            Test dm = new Test();
            dm.createZKInstance();
            dm.ZKOperations();
            dm.ZKClose();
        }
    }
    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
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    我想代码不用解释了，该注释的里面都注释了。
     
    下面有一种特殊的情况的处理思路：
    有server1、server2、server3这三个服务，在client去连接zk的时候，指向server1初始化的过程中是没有问题的，然而刚刚初始化完成，准备去连接server1的时候，server1因为网络等原因挂掉了。
    然而对client来说，它会拿server1的配置去请求连接，这时肯定会报连接被拒绝的异常以致启动退出。
    所以优雅的解决这个问题的方法思路就是“在连接的时候判断连接状态，如果未连接成功，程序自动使用其他连接去请求连接”，这样来避开这种罕见的异常问题。
     
    代码如下：
     
        // 初始化 ZooKeeper 实例
        private void createZKInstance() throws IOException {
            // 连接到ZK服务，多个可以用逗号分割写
            zk = new ZooKeeper("192.168.19.130:2181,192.168.19.130:2182,192.168.19.130:2183", Test.SESSION_TIMEOUT, this.wh);
            if(!zk.getState().equals(States.CONNECTED)){
                while(true){
                    if(zk.getState().equals(States.CONNECTED)){
                        break;
                    }
                    try {
                        TimeUnit.SECONDS.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    上面的代码是基于zk提供的库的API来你使用的，为了更易于使用，有人写了开源的zkclient，我们可以直接使用它来操作zk。
    zkclient 开源地址：https://github.com/sgroschupf/zkclient
    maven 依赖配置：
     
            
            
                com.101tec
                zkclient
                0.7
            
    1
    2
    3
    4
    5
    6
    zkClient 针对 zk 的一次性watcher，做了重新封装，然后定义了 stateChanged、znodeChanged、dataChanged 三种监听器。
     
    监听children变化
    监听节点数据变化
    监听连接状态变化
    代码如下：
     
    package com.shanhy.demo.zookeeper;
     
    import java.util.List;
    import java.util.concurrent.TimeUnit;
     
    import org.I0Itec.zkclient.DataUpdater;
    import org.I0Itec.zkclient.IZkChildListener;
    import org.I0Itec.zkclient.IZkDataListener;
    import org.I0Itec.zkclient.IZkStateListener;
    import org.I0Itec.zkclient.ZkClient;
    import org.apache.zookeeper.Watcher.Event.KeeperState;
     
    /**
     * ZkClient的使用测试
     *
     * @author   单红宇(365384722)
     * @myblog  http://blog.csdn.net/catoop/
     * @create    2016年3月11日
     */
    public class ZkClientTest {
     
        public static void main(String[] args) {
            ZkClient zkClient = new ZkClient("192.168.19.130:2181,192.168.19.130:2182,192.168.19.130:2183");
            String node = "/myapp";
     
            // 订阅监听事件
            childChangesListener(zkClient, node);
            dataChangesListener(zkClient, node);
            stateChangesListener(zkClient);
     
            if (!zkClient.exists(node)) {
                zkClient.createPersistent(node, "hello zookeeper");
            }
            System.out.println(zkClient.readData(node));
     
            zkClient.updateDataSerialized(node, new DataUpdater() {
     
                public String update(String currentData) {
                    return currentData + "-123";
                }
            });
            System.out.println(zkClient.readData(node));
     
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
     
        /**
         * 订阅children变化
         *
         * @param zkClient
         * @param path
         * @author SHANHY
         * @create  2016年3月11日
         */
        public static void childChangesListener(ZkClient zkClient, final String path) {
            zkClient.subscribeChildChanges(path, new IZkChildListener() {
     
                public void handleChildChange(String parentPath, List currentChilds) throws Exception {
                    System.out.println("clildren of path " + parentPath + ":" + currentChilds);
                }
     
            });
        }
     
        /**
         * 订阅节点数据变化
         *
         * @param zkClient
         * @param path
         * @author SHANHY
         * @create  2016年3月11日
         */
        public static void dataChangesListener(ZkClient zkClient, final String path){
            zkClient.subscribeDataChanges(path, new IZkDataListener(){
     
                public void handleDataChange(String dataPath, Object data) throws Exception {
                    System.out.println("Data of " + dataPath + " has changed.");
                }
     
                public void handleDataDeleted(String dataPath) throws Exception {
                    System.out.println("Data of " + dataPath + " has changed.");
                }
     
            });
        }
     
        /**
         * 订阅状态变化
         *
         * @param zkClient
         * @author SHANHY
         * @create  2016年3月11日
         */
        public static void stateChangesListener(ZkClient zkClient){
            zkClient.subscribeStateChanges(new IZkStateListener() {
     
                public void handleStateChanged(KeeperState state) throws Exception {
                    System.out.println("handleStateChanged");
                }
     
                public void handleSessionEstablishmentError(Throwable error) throws Exception {
                    System.out.println("handleSessionEstablishmentError");
                }
     
                public void handleNewSession() throws Exception {
                    System.out.println("handleNewSession");
                }
            });
        }
    }
     
    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
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    ZkClient 做了便捷的包装，对Watch做了增强处理。
    subscribeChildChanges实际上是通过exists和getChildren关注了两个事件。这样当create(“/path”)时，对应path上通过getChildren注册的listener也会被调用。另外subscribeDataChanges实际上只是通过exists注册了事件。因为从上表可以看到，对于一个更新，通过exists和getData注册的watcher要么都会触发，要么都不会触发。
     
    关于session超时的问题，ZkClient 貌似还是有对 Session Expired 处理的，在ZkClient.processStateChanged方法中。虽然能重新连接，但是连接上是一个新的 session，原有创建的ephemeral znode和watch会被删除，程序上你可能需要处理这个问题。
     
    最后说几点关于ZkClient的注意事项：
    1. 创建节点的时候一定要先判断节点是否存在，如果直接使用zkclient创建一个已经存在的节点，则会抛出异常。
    2. 使用zkclient创建节点的时候，path描述的路径，预新增的最终节点之前的所有父节点都必须要存在，否则会抛出异常。所以根据自己需要做好处理。

转载于:https://my.oschina.net/phoebus789/blog/730787

[2019_Python_]: https://my.oschina.net/u/2663968/blog/3061697
[hot3.png]: /images/20220112/990eab387a7e4fb79599c16ea871b916.png
[http_zookeeper.apache.org_releases.html]: http://zookeeper.apache.org/releases.html