Zookeeper学习笔记：Zookeeper--分布式框架

Zookeeper学习笔记：Zookeeper–分布式框架

标签（空格分隔）： Zookeeper

---

一、什么是Zookeeper

    Zookeeper 分布式服务框架是 Apache Hadoop 的一个子项目，它主要是用来解决分布式应用中经常遇到的一些数据管理问题，如：同步配置管理、选举、分布式锁、分组和命名、分布式应用配置项的管理等。本文将从使用者角度详细介绍 Zookeeper 的安装和配置文件中各个配置项的意义，以及分析 Zookeeper 的典型的应用场景（配置文件的管理、集群管理、同步锁、Leader 选举、队列管理等）。

二、Zookeeper的安装

1. 下载Zookeeper的安装包

2. 解压安装

   [root@mo ~]# tar -zxf zookeeper-3.4.6.tar.gz -C /usr/

3. 修改配置文件
   单机版修改为：

   [root@mo conf]# cp zoo_sample.cfg  zoo.cfg 
   [root@mo conf]# vi zoo.cfg
   tickTime=2000
   dataDir=/root/data/zookeeper
   clientPort=2181

   参数说明：

       tickTime：基本事件单元，以毫秒为单位。它用来指示心跳，最小的Session过期时间为两倍的tickTime。
       dataDir：存储内存中数据快照的位置，如果不设置参数，更新事务日志将被存储在默认位置。
       clientPort：监听客户端连接的端口
   
       使用单机模式时，这种配置方式下没有Zookeeper副本，所以如果Zookeeper服务器出现故障，Zookeeper服务器会将会停止。
   

   集群配置:
   Zookeeper 不仅可以单机提供服务，同时也支持多机组成集群来提供服务。实际上 Zookeeper 还支持另外一种伪集群的方式，也就是可以在一台物理机上运行多个 Zookeeper 实例，下面将介绍集群模式的安装和配置。

   集群中的每台机器的conf/zoo.cfg配置文件设置为【zoo为自己修改的名称】：

   tickTime=2000
   dataDir=/root/data/zookeeper        //存放数据路径
   clientPort=2181                     //端口号
   initLimit=5
   syncLimit=2
   server.1=zoo1:2887:3887             //server.【id】=【主机名】：【与主机通讯端口】：【选举端口】
   server.2=zoo2:2888:3888
   server.3=zoo3:2889:3889

       参数：
           initLimit：这个配置项是用来配置Zookeeper接受客户端（这里所说的客户端不是用户连接 Zookeeper 服务器的客
   户端，而是 Zookeeper服务器集群中连接到Leader的Follower服务器）初始化连接时最长能忍受多少个心跳时间间隔数。当已经超
   过10 个心跳的时间（也就是tickTime）长度后Zookeeper服务器还没有收到客户端的返回信息，那么表明这个客户端连接失败。
   总的时间长度就是 5*2000=10 秒。
           syncLimit：这个配置项标识LeaderFollower之间发送消息，请求和应答时间长度，最长不能超过多少个 tickTime 
   的时间长度，总的时间长度就是 2*2000=4 秒。
           server.A=B：C：D：其中 A 是一个数字，表示这个是第几号服务器；B 是这个服务器的 ip 地址；C 表示的是这个服务
   器与集群中的 Leader 服务器交换信息的端口；D 表示的是万一集群中的 Leader 服务器挂了，需要一个端口来重新进行选举，选出
   一个新的Leader，而这个端口就是用来执行选举时服务器相互通信的端口。如果是伪集群的配置方式，由于 B 都是一样，所以不同的 
   Zookeeper 实例通信端口号不能一样，所以要给它们分配不同的端口号。
   

   修改主机名称详情见【附录】 修改配置如：

   //zoo1.cnf
   tickTime=2000
   dataDir=/root/data/zookeeper1
   clientPort=2181
   initLimit=5
   syncLimit=2
   server.1=motui:2887:3887
   server.2=motui:2888:3888
   server.3=motui:2889:3889
   
   //zoo2.cnf
   tickTime=2000
   dataDir=/root/data/zookeeper2
   clientPort=2182
   initLimit=5
   syncLimit=2
   server.1=motui:2887:3887
   server.2=motui:2888:3888
   server.3=motui:2889:3889
   

   具体解释：
       “server.id=host:port:port”：指出不同的Zookeeper的服务器的自身标示，作为集群中的一部分机器应该知道集群中的其他机器。用户可以从“server.id=host:port:port”中读取相关信息。
       在DataDir目录下创建一个名为myid的文件，这个文件仅仅含有一行内容，指定自身的id值。比如服务器的id为1，就在这个文件中写1，第一个port是保证和主机通信，第二个port是做选举的。
       启动Zookeeper的集群：./bin/zkServer.sh start zoo1.cfg
       连接集群：./bin/zkCli -server 127.0.0.1:2181
   

   需要在每台机器的DataDir目录下创建一个名为myid的文件，文件中只有对应自己的ID。

   [root@mo ~]# echo "1" >> /root/data/zookeeper1/myid
   [root@mo ~]# echo "2" >> /root/data/zookeeper2/myid 
   [root@mo ~]# echo "3" >> /root/data/zookeeper3/myid

4. 启动

   //单机启动
   [root@mo zookeeper-3.4.6]# ./bin/zkServer.sh start zoo.cfg 
   
   //集群启动
   [root@mo zookeeper-3.4.6]#./bin/zkServer.sh start zoo1.cfg
   [root@mo zookeeper-3.4.6]#./bin/zkServer.sh start zoo2.cfg
   [root@mo zookeeper-3.4.6]#./bin/zkServer.sh start zoo3.cfg
   。。。

5. 连接Zookeeper

   //单机连接
   [root@mo zookeeper-3.4.6]# ./bin/zkCli.sh -server 192.168.200.128:2181
   
   //集群连接
   //连接集群中的任意一台服务器即可。
   [root@mo zookeeper-3.4.6]#./bin/zkCli.sh -server 192.168.200.128:2181
   
   //连接之后 --help可以查看基本命令
   [zk: 192.168.200.128:2181(CONNECTED) 0] --help
   ZooKeeper -server host:port cmd args
       connect host:port
       get path [watch]
       ls path [watch]
       。。。。。

三、Zookeeper的数据结构

Zookeeper 这种数据结构有如下这些特点：

1. 每个子目录项如NameService都被称作为znode，这个znode是被它所在的路径的唯一标识，如Server1这个znode的标识为/NameService/Server1

2. znode可以有子节点目录，并且每个znode可以储存数据，注意EPHEMERAL类型的目录节点不能有子节点目录。

3. znode是有版本的，每个znode中存储的数据可以有多个版本，也可以是一个访问路径可以存储多分数据

4. znode可以是临时节点，一旦创建这个znode的客户端与服务器失去联系，这个znode将会自动删除，
   Zookeeper的客户端和服务器通信长连接方式，每个客户端和服务器通过心跳来保持连接，这个连接状态为
   session，如果znode是临时节点，这个session失效，znode也就删除。

5. znode的目录名可以自动编号，如App1已经存在，再此创建的话，将会自动命名为APP2

6. znode可以被监控，包括节点数据的改变、子节点的变化。一旦变化就可以通知设置监控的客户端，这是Zookeeper的核心特性，Zookeeper的很多功能都是基于这个特性实现的。具有很多应用场景。

四、API基本操作（java示例）

1. 导入相关jar包

   log4j-1.2.15.jar
   slf4j-api-1.6.1.jar
   Wslf4j-log4j12-1.6.1.jar
   zkclient-0.5.jar        //高级功能包
   zookeeper-3.4.6.jar     //连接包

2. zkclient相关API操作
   zkclient基本操作

   package com.motui.test;
   import org.I0Itec.zkclient.ZkClient;
   import org.apache.zookeeper.CreateMode;
   import org.junit.Test;
   import java.util.Date;
   import java.util.List;
   
   /**
    * Created by MOTUI on 2016/10/24.
    *
    * zookeeper的节点操作
    */
   public class TestZookeeper {
       //单节点连接
       private static ZkClient client = new ZkClient("192.168.200.128:2181");
   
       //集群连接
       private static ZkClient client = new 
   ZkClient("192.168.200.128:2181,192.168.200.128:2182,192.168.200.128:2183");
   
       //node以“/”开头
       private static String node = "/motui";
   
       /**
        * 节点创建
        * 节点类型：PERSISTENT(_SEQUENTIAL) EPHEMERAL(_SEQUENTIAL)
        * 等价的写法： zkClient.createPersistent(path)
        *          zkClient.createPersistentSequential(path, data)
        *          zkClient.createEphemeral(path)
        *          zkClient.createEphemeralSequential(path, data)
        */
   
       @Test
       public void testCreateNode(){
           client.create(node,"Hello Zookeeper!!", CreateMode.PERSISTENT);
       }
   
       /**
        * 获取节点数据
        */
       @Test
       public void testGet(){
           Object data = client.readData(node);
           System.out.println("node data,类型："+data.getClass()+" 数据："+data);
       }
   
       /**
        * 判断节点是否存在
        */
       @Test
       public void testNodeExits(){
           boolean exists = client.exists(node);
           System.out.println("node 是否存在："+exists);
       }
   
       /**
        * 修改节点数据
        */
       @Test
       public void testUpdate(){
           client.writeData(node,new Date());
       }
   
       /**
        * 节点的删除,只能删除空目录节点
        */
       @Test
       public void testDeleteNode(){
           boolean delete = client.delete(node);
           System.out.println("删除状态："+delete);
       }
   
       /**
        * 节点的删除,删除非空目录节点
        */
       @Test
       public void testDeleteNode1(){
           boolean recursive = client.deleteRecursive(node);
           System.out.println("删除状态："+recursive);
       }
   
       /**
        * 级联创建父子节点
        */
       @Test
       public void testCreateMany(){
   
           String path1 = node+"/student1";
           String path2 = node+"/student2";
           client.createPersistent(path1,true);
           client.createPersistent(path2,true);
       }
       /**
        * 获取所有孩子节点
        */
       @Test
       public void testGetChildren(){
           List<String> children = client.getChildren(node);
           System.out.println(node+"的子节点："+children);
       }
   }

   对节点的监听

   package com.motui.test;
   import org.I0Itec.zkclient.IZkChildListener;
   import org.I0Itec.zkclient.IZkDataListener;
   import org.I0Itec.zkclient.ZkClient;
   import org.junit.Test;
   import java.io.IOException;
   import java.util.List;
   
   /**
    * Created by MOTUI on 2016/10/24.
    *
    * 监听节点的变化
    */
   public class TestZookeeperWatcher {
   
       private static ZkClient client = new ZkClient("192.168.200.128:2181");
       private static String node = "/motui";
   
       /**
        * 监听节点的数据变化
        * @throws IOException
        */
       @Test
       public void testNodeDataWatcher() throws IOException {
           client.subscribeDataChanges(node, new IZkDataListener() {
               @Override
               public void handleDataChange(String path, Object data) throws Exception {
                   System.out.println(path);
                   System.out.println(data);
               }
   
               @Override
               public void handleDataDeleted(String path) throws Exception {
                   System.out.println(path);
   
               }
           });
           //挂起线程
           System.in.read();
       }
   
       /**
        * 监视集群孩子的变化
        */
       @Test
       public void testNodeChildWatcher() throws IOException{
           client.subscribeChildChanges(node, new IZkChildListener() {
               @Override
               public void handleChildChange(String path, List<String> list) throws Exception {
                   System.out.println(path);
                   System.out.println(list);
               }
           });
           //挂起线程
           System.in.read();
       }
   }

五、ZooKeeper 典型的应用场景

Zookeeper 从设计模式角度来看，是一个基于观察者模式设计的分布式服务管理框架，它负责存储和管理大家
都关心的数据，然后接受观察者的注册，一旦这些数据的状态发生变化，Zookeeper 就将负责通知已经在
Zookeeper 上注册的那些观察者做出相应的反应，从而实现集群中类似 Master/Slave 管理模式。
统一命名服务（Name Service）
分布式应用中，通常需要有一套完整的命名规则，既能够产生唯一的名称又便于人识别和记住，通常情况下用
树形的名称结构是一个理想的选择，树形的名称结构是一个有层次的目录结构，既对人友好又不会重复。说到
这里你可能想到了 JNDI，没错 Zookeeper 的 Name Service 与 JNDI 能够完成的功能是差不多的，它们都是
将有层次的目录结构关联到一定资源上，但是 Zookeeper 的 Name Service 更加是广泛意义上的关联，也许
你并不需要将名称关联到特定资源上，你可能只需要一个不会重复名称，就像数据库中产生一个唯一的数字主键一样。
Name Service 已经是 Zookeeper 内置的功能，你只要调用 Zookeeper 的 API 就能实现。如调用 create 接口就可以很容易创建一个目录节点。
配置管理（Configuration Management）
配置的管理在分布式应用环境中很常见，例如同一个应用系统需要多台 PC Server 运行，但是它们运行
的应用系统的某些配置项是相同的，如果要修改这些相同的配置项，那么就必须同时修改每台运行这个应用系
统的 PC Server，这样非常麻烦而且容易出错。像这样的配置信息完全可以交给 Zookeeper 来管理，将配置信
息保存在 Zookeeper的某个目录节点中，然后将所有需要修改的应用机器监控配置信息的状态，一旦配置信息
发生变化，每台应用机器就会收到 Zookeeper 的通知，然后从 Zookeeper 获取新的配置信息应用到系统中。

集群管理（Group Membership）
Zookeeper 能够很容易的实现集群管理的功能，如有多台 Server 组成一个服务集群，那么必须要一个“总管”知道当前集群中每台机器的服务状态，一旦有机器不能提供服务，集群中其它集群必须知道，从而做出调整重新分配服务策略。同样当增加集群的服务能力时，就会增加一台或多台 Server，同样也必须让“总管”知道。
Zookeeper 不仅能够帮你维护当前的集群中机器的服务状态，而且能够帮你选出一个“总管”，让这个总管来管理集群，这就是 Zookeeper 的另一个功能 Leader Election。
它们的实现方式都是在 Zookeeper 上创建一个 EPHEMERAL 类型的目录节点，然后每个 Server 在它们创建目录节点的父目录节点上调用 getChildren(String path, boolean watch) 方法并设置 watch 为 true，由于是 EPHEMERAL 目录节点，当创建它的 Server 死去，这个目录节点也随之被删除，所以 Children 将会变化，这时 getChildren上的 Watch 将会被调用，所以其它 Server 就知道已经有某台 Server 死去了。新增 Server 也是同样的原理。
Zookeeper 如何实现 Leader Election，也就是选出一个 Master Server。和前面的一样每台 Server 创建一个 EPHEMERAL 目录节点，不同的是它还是一个 SEQUENTIAL 目录节点，所以它是个 EPHEMERAL_SEQUENTIAL 目录节点。之所以它是 EPHEMERAL_SEQUENTIAL 目录节点，是因为我们可以给每台 Server 编号，我们可以选择当前是最小编号的 Server 为 Master，假如这个最小编号的 Server 死去，由于是 EPHEMERAL 节点，死去的 Server 对应的节点也被删除，所以当前的节点列表中又出现一个最小编号的节点，我们就选择这个节点为当前 Master。这样就实现了动态选择 Master，避免了传统意义上单 Master 容易出现单点故障的问题。

说明：Zookeeper的四种节点类型：

    ZooKeeper 节点是有生命周期的，这取决于节点的类型在ZooKeeper中，节点类型可以分为持久节点（ PERSISTENT）、临时节点（EPHEMERAL），以及时序节点（SEQUENTIAL），具体在节点创建过程中，一般是组合使用，可以生成以下 4 种节点类型。
    持久节点（ PERSISTENT）
        持久节点，是指在节点创建后，就一直存在，直到有删除操作来主动清除这个节点    ——不会因为创建该节点的客户端会话失效而消失。持久顺序节点（PERSISTENT_SEQUENTIAL）
这类节点的基本特性和上面的节点类型是一致的。额外的特性是，在ZK中，每个父节点会他    的第一级子节点维护一份时序，会记录每个子节点创建的先后顺序。基于这个特性，在创建    子节点的时候，可以设置这个属性，那么在创建节点过程中，ZK会自动为给定节点名加上一个数字后缀，作为新的节点名。这个数字后缀的范围是整型的最大值。
临时节点（ EPHEMERAL）
    和持久节点不同的是，临时节点的生命周期和客户端会话绑定。也就是说，如果客户端会话失效，那么这个节点就会自动被清除掉。注意，这里提到的是会话失效，而非连接断开。另外，在临时节点下面不能创建子节点。
    临时顺序节点（ EPHEMERAL_SEQUENTIAL）
    分布式锁
    第一步：客户端调用create()方法创建“_locknode_/guid-lock-”节点，需要注意的是，这里节点的创建类型设置 EPHEMERAL_SEQUENTIAL。
    第二步：客户端调用getChildren(“_locknode_”)方法来获取所有已经创建的子节点，注意，这里不注册任何 Watcher。
    第三步：客户端获取到所有子节点 path 之后，如果发现自己在步骤 1中创建的节点序号最小，那么就认为这个客户端获得了锁。
    如果在步骤 3 中发现自己并非所有子节点中最小的，说明自己还没有获取到
    锁。此时客户端需要找到比自己小的那个节点，然后对其调用 exist()方法，同时注册事件监听。之后当这个被关注的节点被移除了，客户端会收到相应的通知。这个时候客户端需要再次调用 getChildren(“ _locknode_” )方法来获取所有已经创建的子节点，确保自己确实是最小的节点了，然后进入步骤 3。

详细示例可以参考【TCP-IP学习笔记十】

共享锁（Locks）

共享锁在同一个进程中很容易实现（可以使用synchronized实现），但是在跨进程或者在不同Server之间就不好实现了。Zookeeper却很容易实现这个功能，实现方式也是需要获得锁的Server创建一个EPHEMERAL_SEQUENTIAL目录节点，然后调用getChildren方法获取当前的目录节点列表中最小的目录节点是不是就是自己创建的目录节点，如果正是自己创建的，那么它就获得了这个锁，如果不是那么它就调用 exists(String path, boolean watch)方法并监控Zookeeper上目录节点列表的变化，一直到自己创建的节点是列表中最小编号的目录节点，从而获得锁，释放锁很简单，只要删除前面它自己所创建的目录节点就行了。

队列管理
Zookeeper 可以处理两种类型的队列：

当一个队列的成员都聚齐时，这个队列才可用，否则一直等待所有成员到达，这种是同步队列。
队列按照 FIFO 方式进行入队和出队操作，例如实现生产者和消费者模型。
同步队列用 Zookeeper 实现的实现思路如下：

创建一个父目录 /synchronizing，每个成员都监控标志（Set Watch）位目录 /synchronizing/start 是否存在，然后每个成员都加入这个队列，加入队列的方式就是创建 /synchronizing/member_i 的临时目录节点，然后每个成员获取 / synchronizing 目录的所有目录节点，也就是 member_i。判断 i 的值是否已经是成员的个数，如果小于成员个数等待 /synchronizing/start 的出现，如果已经相等就创建 /synchronizing/start。

六、总结：

Zookeeper 作为 Hadoop项目中的一个子项目，是Hadoop集群管理的一个必不可少的模块，它主要用来控制集群中的数据，如它管理 Hadoop 集群中的 NameNode，还有 Hbase 中 Master Election、Server 之间状态同步等。
这些都是典型的应用场景，当然还会有更广泛的应用，随着大数据的不断发展，新的技术不断的出现，Zookeeper也会发挥更多的作用。

参考博客：分布式服务框架 Zookeeper – 管理分布式环境中的数据

---

附录：
修改主机名：

    [root@mo ~]# vi /etc/hosts
    //在最后添加：【主机IP】【空格】【主机名称】，如：
    192.168.111.128 motui

    //测试是否修改成功
    ping 【主机名称】，如：
    ping motui
    //出现如下内容则成功：

    [root@mo etc]# ping motui
    PING motui (192.168.200.128) 56(84) bytes of data.
    64 bytes from motui (192.168.200.128): icmp_seq=1 ttl=64 time=0.022 ms
    64 bytes from motui (192.168.200.128): icmp_seq=2 ttl=64 time=0.051 ms