ZooKeeper学习笔记之扫盲

时间 2020-12-07

标签 html java node shell 数据库 apache 编程 vim api 服务器栏目 Zookeeper 繁體版

原文原文链接

题外话：从字面上来看，ZooKeeper表示动物园管理员，而Hadoop生态系统中，许多项目的Logo都采用了动物，好比Hadoop采用了大象的形象，因此能够ZooKeeper就是对这些动物进行一些管理工做的。 html

对于单机环境进程内的协调方法，咱们通常经过线程锁来协调对共享数据的访问以保证状态的一致性。可是分布式环境如何进行协调呢？因而，Google创造了Chubby，而ZooKeeper则是对于Chubby的一个开源实现。
ZooKeeper是一种为分布式应用所设计的高可用、高性能且一致的开源协调服务，它提供了一项基本服务：分布式锁服务。因为ZooKeeper的开源特性，后来咱们的开发者在分布式锁的基础上，摸索了出了其余的使用方法：配置维护、组服务、分布式消息队列、分布式通知/协调等。它被设计为易于编程，使用文件系统目录树做为数据模型。java

ZooKeeper集群模式典型架构

Zookeeper服务自身组成一个集群(2n+1个服务容许n个失效)。Zookeeper服务有两个角色，一个是leader，负责写服务和数据同步，剩下的是follower，提供读服务，leader失效后会在follower中从新选举新的leader。
node

保证shell

顺序一致性：按照客户端发送请求的顺序更新数据。数据库
原子性：更新要么成功，要么失败，不会出现部分更新。apache
单一性：不管客户端链接哪一个server，都会看到同一个视图。编程
可靠性：一旦数据更新成功，将一直保持，直到新的更新。vim
及时性：客户端会在一个肯定的时间内获得最新的数据。api

一、Zookeeper数据模型Znode
Zookeeper表现为一个分层的文件系统目录树结构（不一样于文件系统的是，节点能够有本身的数据，而文件系统中的目录节点只有子节点）。
服务器

Zookeeper Stat 结构 —— Zookeeper中的每一个znode的stat都由下面的字段组成：

czxid - 引发这个znode建立的zxid
mzxid - znode最后更新的zxid
ctime - znode被建立的毫秒数(从1970年开始)
mtime - znode最后修改的毫秒数(从1970年开始)
version - znode数据变化号
cversion - znode子节点变化号
aversion - znode访问控制列表的变化号
ephemeralOwner - 若是是临时节点这个是znode拥有者的session id。若是不是临时节点则是0。
dataLength - znode的数据长度
numChildren - znode子节点数量

关于数据模型的理解，建议参考：http://www.cnblogs.com/wuxl36...

简单API——Zookeeper的设计目标的其中之一就是提供一个简单的程序接口。所以，它只支持这些操做：

create - 在树形结构的位置中建立节点
delete - 删除一个节点
exists - 测试节点在指定位置上是否存在
get data - 从节点上读取数据
set data - 往节点写入数据
get chilren - 检索节点的子节点列表
sync - 等待传输数据

ZooKeeper的应用场景

（1）统一命名服务
分布式应用中，一般须要有一套完整的命名规则，既可以产生惟一的名称又便于人识别和记住，一般状况下用树形的名称结构是一个理想的选择，树形的名称结构是一个有层次的目录结构，既对人友好又不会重复。说到这里你可能想到了 JNDI，没错 Zookeeper 的 Name Service 与 JNDI 可以完成的功能是差很少的，它们都是将有层次的目录结构关联到必定资源上，可是 Zookeeper 的 Name Service 更加是普遍意义上的关联，也许你并不须要将名称关联到特定资源上，你可能只须要一个不会重复名称，就像数据库中产生一个惟一的数字主键同样。
Name Service 已是 Zookeeper 内置的功能，你只要调用 Zookeeper 的 API 就能实现。如调用 create 接口就能够很容易建立一个目录节点。
案例：有一组服务器向客户端提供某种服务（例如：使用LVS技术构建的Web网站集群，就是由N台服务器组成的集群，为用户提供Web服务）。对于这种场景，咱们的程序中必定有一份这组服务器的列表，每次客户端请求时候，都是从这份列表里读取这份服务器列表。那么这分列表显然不能存储在一台单节点的服务器上，不然这个节点挂掉了，整个集群都会发生故障，咱们但愿这份列表时高可用的。高可用的解决方案是：这份列表是分布式存储的，它是由存储这份列表的服务器共同管理的，若是存储列表里的某台服务器坏掉了，其余服务器立刻能够替代坏掉的服务器，而且能够把坏掉的服务器从列表里删除掉，让故障服务器退出整个集群的运行，而这一切的操做又不会由故障的服务器来操做，而是集群里正常的服务器来完成。这是一种主动的分布式数据结构，可以在外部状况发生变化时候主动修改数据项状态的数据机构。

（2）分布式锁服务

共享锁在同一个进程中很容易实现，可是在跨进程或者在不一样 Server 之间就很差实现了。Zookeeper 却很容易实现这个功能，实现方式也是须要得到锁的 Server 建立一个 EPHEMERAL_SEQUENTIAL 目录节点，而后调用 getChildren方法获取当前的目录节点列表中最小的目录节点是否是就是本身建立的目录节点，若是正是本身建立的，那么它就得到了这个锁，若是不是那么它就调用exists(String path, boolean watch) 方法并监控 Zookeeper 上目录节点列表的变化，一直到本身建立的节点是列表中最小编号的目录节点，从而得到锁，释放锁很简单，只要删除前面它本身所建立的目录节点就好了。
具体步骤以下：
加锁： ZooKeeper 将按照以下方式实现加锁的操做：
1 ） ZooKeeper 调用 create （）方法来建立一个路径格式为“ _locknode_/lock- ”的节点，此节点类型为sequence （连续）和 ephemeral （临时）。也就是说，建立的节点为临时节点，而且全部的节点连续编号，即“ lock-i ”的格式。
2 ）在建立的锁节点上调用 getChildren （）方法，来获取锁目录下的最小编号节点，而且不设置 watch 。
3 ）步骤 2 中获取的节点刚好是步骤 1 中客户端建立的节点，那么此客户端得到此种类型的锁，而后退出操做。
4 ）客户端在锁目录上调用 exists （）方法，而且设置 watch 来监视锁目录下比本身小一个的连续临时节点的状态。
5 ）若是监视节点状态发生变化，则跳转到第 2 步，继续进行后续的操做，直到退出锁竞争。

解锁：
ZooKeeper 解锁操做很是简单，客户端只须要将加锁操做步骤 1 中建立的临时节点删除便可。

void getLock() throws KeeperException, InterruptedException{ 
        List<String> list = zk.getChildren(root, false); 
        String[] nodes = list.toArray(new String[list.size()]); 
        Arrays.sort(nodes); 
        if(myZnode.equals(root+"/"+nodes[0])){ 
            doAction(); 
        } 
        else{ 
            waitForLock(nodes[0]); 
        } 
    } 
    void waitForLock(String lower) throws InterruptedException, KeeperException {
        Stat stat = zk.exists(root + "/" + lower,true); 
        if(stat != null){ 
            mutex.wait(); 
        } 
        else{ 
            getLock(); 
        } 
    }

（3）配置管理(数据发布与订阅)

在分布式系统里，咱们会把一个服务应用分别部署到n台服务器上，这些服务器的配置文件是相同的，若是配置文件的配置选项发生变化，那么咱们就得一个个去改这些配置文件，若是咱们须要改的服务器比较少，这些操做还不是太麻烦，若是咱们分布式的服务器特别多，那么更改配置选项就是一件麻烦并且危险的事情。这时咱们能够将配置信息保存在 Zookeeper 的某个目录节点中，而后将全部须要修改的应用机器监控配置信息的状态，一旦配置信息发生变化，每台应用机器就会收到 Zookeeper 的通知，而后从 Zookeeper 获取新的配置信息应用到系统中。

（4）集群管理

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 容易出现单点故障的问题。

PS：关于Master的选举，能够参考：http://www.cnblogs.com/sundde...。
注意：ZooKeeper所提供的服务主要是经过：数据结构+原语(一些关于该数据结构的一些操做)+watcher机制，三个部分来实现的

(5)、队列管理
Zookeeper 能够处理两种类型的队列：

当一个队列的成员都聚齐时，这个队列才可用，不然一直等待全部成员到达，这种是同步队列。
队列按照 FIFO 方式进行入队和出队操做，例如实现生产者和消费者模型。

A、同步队列用 Zookeeper 实现的实现思路以下：
建立一个父目录 /synchronizing，每一个成员都监控标志（Set Watch）位目录 /synchronizing/start 是否存在，而后每一个成员都加入这个队列，加入队列的方式就是建立 /synchronizing/member_i 的临时目录节点，而后每一个成员获取 / synchronizing 目录的全部目录节点，也就是 member_i。判断 i 的值是否已是成员的个数，若是小于成员个数等待 /synchronizing/start 的出现，若是已经相等就建立 /synchronizing/start。

void addQueue() throws KeeperException, InterruptedException{ 
        zk.exists(root + "/start",true); 
        zk.create(root + "/" + name, new byte[0], Ids.OPEN_ACL_UNSAFE, 
        CreateMode.EPHEMERAL_SEQUENTIAL); 
        synchronized (mutex) { 
            List<String> list = zk.getChildren(root, false); 
            if (list.size() < size) { 
                mutex.wait(); 
            } else { 
                zk.create(root + "/start", new byte[0], Ids.OPEN_ACL_UNSAFE,
                 CreateMode.PERSISTENT); 
            } 
        } 
 }


 public void process(WatchedEvent event) { 
        if(event.getPath().equals(root + "/start") &&
         event.getType() == Event.EventType.NodeCreated){ 
            System.out.println("获得通知"); 
            super.process(event); 
            doAction(); 
        } 
    }

B、FIFO队列：
实现的思路也很是简单，就是在特定的目录下建立 SEQUENTIAL 类型的子目录 /queue_i，这样就能保证全部成员加入队列时都是有编号的，出队列时经过 getChildren( ) 方法能够返回当前全部的队列中的元素，而后消费其中最小的一个，这样就能保证 FIFO。

boolean produce(int i) throws KeeperException, InterruptedException{ 
        ByteBuffer b = ByteBuffer.allocate(4); 
        byte[] value; 
        b.putInt(i); 
        value = b.array(); 
        zk.create(root + "/element", value, ZooDefs.Ids.OPEN_ACL_UNSAFE, 
                    CreateMode.PERSISTENT_SEQUENTIAL); 
        return true; 
    }

int consume() throws KeeperException, InterruptedException{ 
        int retvalue = -1; 
        Stat stat = null; 
        while (true) { 
            synchronized (mutex) { 
                List<String> list = zk.getChildren(root, true); 
                if (list.size() == 0) { 
                    mutex.wait(); 
                } else { 
                    Integer min = new Integer(list.get(0).substring(7)); 
                    for(String s : list){ 
                        Integer tempValue = new Integer(s.substring(7)); 
                        if(tempValue < min) min = tempValue; 
                    } 
                    byte[] b = zk.getData(root + "/element" + min,false, stat); 
                    zk.delete(root + "/element" + min, 0); 
                    ByteBuffer buffer = ByteBuffer.wrap(b); 
                    retvalue = buffer.getInt(); 
                    return retvalue; 
                } 
            } 
        } 
 }

ZooKeeper集群模式搭建

注意：ZooKeeper服务器集群规模不小于3个节点，要求各服务器之间系统时间要保持一致；
一、下载解压安装后，修改环境变量：vim /etc/profile

增长一行：export ZOOKEEPER_HOME=/usr/local/zookeeper
修改PATH：export PATH=.:$HADOOP_HOME/bin:$ZOOKEEPER_HOME/bin:$JAVA_HOME/bin:$PATH
使配置生效：source /etc/profile

二、进入zookeeper的conf目录下，修改文件名：mv zoo_sample.cfg zoo.cfg

编辑zoo.cfg：vim zoo.cfg
修改dataDir=/usr/local/zookeeper/data
新增
server.0=hadoop-master:2888:3888

server.1=hadoop-slave1:2888:3888
server.2=hadoop-slave2:2888:3888

三、建立data文件夹，并建立myid文件：

新建data文件夹：mkdir /usr/local/zookeeper/data
新建myid文件：vim myid，并设置第一台server为0。

四、复制zookeeper目录至其他两台服务器中：

scp /usr/local/zookeeper hadoop-slave1:/usr/local/
scp /usr/local/zookeeper hadoop-slave2:/usr/local/

五、复制环境变量配置文件至其他两台服务器中：

scp /etc/profile hadoop-slave1:/etc
scp /etc/profile hadoop-slave2:/etc
六、在其他两台服务器中修改myid文件：设置为1和2；

七、启动ZooKeeper，分别在三个节点中执行命令：zkServer.sh start
八、检验ZooKeeper集群节点角色状态，分别在三个节点中执行命令：zkServer.sh status (能够看出哪一个节点是leader,follower,observer等)
ZooKeeper中包含如下角色：

领导者（leader），负责进行投票的发起和决议，更新系统状态；
学习者（learner），包括跟随者（follower）和观察者（observer），follower用于接受客户端请求并向客户端返回结果，在选主过程当中参与投票；observer能够接受客户端链接，将写请求转发给leader，但observer不参加投票过程，只同步leader的状态，observer的目的是为了扩展系统，提升读取速度；

九、ZooKeeper简单测试
搭建好集群环境后，就能够进行简单的读写一致性测试了，这里咱们经过进入zookeeper的bin目录下的zkCli.sh来完成下面的操做：
（1）在其中一个节点192.168.80.100上执行一个写操做：create /MyTest test
（2）在其余两个节点上执行读操做：get /MyTest
TIP：能够在一个节点中经过zkCli.sh -server hadoop-slave1:2181来远程登陆
（3）在其中一个节点192.168.80.101上执行一个修改操做：set /MyTest new-test ,在其余两个节点上执行读操做查看数据是否一致

Zookeeper shell命令

[zkshell: 0] help
ZooKeeper host:port cmd args
       get path [watch]
       ls path [watch]
       set path data [version]
       delquota [-n|-b] path
       quit
       printwatches on|off
       createpath data acl
       stat path [watch]
       listquota path
       history
       setAcl path acl
       getAcl path
       sync path
       redo cmdno
       addauth scheme auth
       delete path [version]
       setquota -n|-b val path

编程

APIDOC: https://zookeeper.apache.org/...

<dependency>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
        <version>3.4.6</version>
</dependency>

Zookeeper主要用来解决分布式集群中应用系统的一致性问题，它能提供基于相似于文件系统的目录节点树方式的数据存储，可是 Zookeeper 并非用来专门存储数据的，它的做用主要是用来维护和监控你存储的数据的状态变化。经过监控这些数据状态的变化，从而能够达到基于数据的集群管理
客户端要链接 Zookeeper 服务器能够经过建立 org.apache.zookeeper.ZooKeeper 的一个实例对象，而后调用这个类提供的接口来和服务器交互。
前面说了 ZooKeeper 主要是用来维护和监控一个目录节点树中存储的数据的状态，全部咱们可以操做 ZooKeeper 的也和操做目录节点树大致同样，如建立一个目录节点，给某个目录节点设置数据，获取某个目录节点的全部子目录节点，给某个目录节点设置权限和监控这个目录节点的状态变化。

常见方法：

String create(String path, byte[] data, List<ACL> acl,CreateMode createMode) 建立一个给定的节点 path, 并给它设置数据，
CreateMode 标识有四种形式的目录节点：

PERSISTENT：持久化目录节点，这个目录节点存储的数据不会丢失；
PERSISTENT_SEQUENTIAL：顺序自动编号的目录节点，这种目录节点会根据当前已近存在的节点数自动加 1，而后返回给客户端已经成功建立的目录节点名；
EPHEMERAL：临时目录节点，一旦建立这个节点的客户端与服务器端口也就是 session 超时，这种节点会被自动删除；
EPHEMERAL_SEQUENTIAL：临时自动编号节点

Stat exists(String path, boolean watch) 判断某个 path 是否存在，并设置是否监控这个目录节点，这里的 watcher 是在建立 ZooKeeper 实例时指定的 watcher
Stat exists(String path,Watcher watcher) 重载方法，这里给某个目录节点设置特定的 watcher，Watcher 在 ZooKeeper 是一个核心功能，Watcher 能够监控目录节点的数据变化以及子目录的变化，一旦这些状态发生变化，服务器就会通知全部设置在这个目录节点上的 Watcher，从而每一个客户端都很快知道它所关注的目录节点的状态发生变化，而作出相应的反应
void delete(String path, int version) 删除 path 对应的目录节点，version 为 -1 能够匹配任何版本，也就删除了这个目录节点全部数据
List<String> getChildren(String path, boolean watch) 获取指定 path 下的全部子目录节点，一样 getChildren方法也有一个重载方法能够设置特定的 watcher 监控子节点的状态
Stat setData(String path, byte[] data, int version) 给 path 设置数据，能够指定这个数据的版本号，若是 version 为 -1 怎能够匹配任何版本
byte[] getData(String path, boolean watch, Stat stat) 获取这个 path 对应的目录节点存储的数据，数据的版本等信息能够经过 stat 来指定，同时还能够设置是否监控这个目录节点数据的状态
void addAuthInfo(String scheme, byte[] auth) 客户端将本身的受权信息提交给服务器，服务器将根据这个受权信息验证客户端的访问权限。
Stat setACL(String path,List<ACL> acl, int version) 给某个目录节点从新设置访问权限，须要注意的是 Zookeeper 中的目录节点权限不具备传递性，父目录节点的权限不能传递给子目录节点。目录节点 ACL 由两部分组成：perms 和 id。
Perms 有 ALL、READ、WRITE、CREATE、DELETE、ADMIN 几种,而 id 标识了访问目录节点的身份列表，默认状况下有如下两种：ANYONE_ID_UNSAFE = new Id("world", "anyone") 和 AUTH_IDS = new Id("auth", "") 分别表示任何人均可以访问和建立者拥有访问权限。
List<ACL> getACL(String path,Stat stat) 获取某个目录节点的访问权限列表

// 建立一个与服务器的链接
 ZooKeeper zk = new ZooKeeper("localhost:" + CLIENT_PORT, 
        ClientBase.CONNECTION_TIMEOUT, new Watcher() { 
            // 监控全部被触发的事件
            public void process(WatchedEvent event) { 
                System.out.println("已经触发了" + event.getType() + "事件！"); 
            } 
        }); 
 // 建立一个目录节点
 zk.create("/testRootPath", "testRootData".getBytes(), Ids.OPEN_ACL_UNSAFE,
   CreateMode.PERSISTENT); 
 // 建立一个子目录节点
 zk.create("/testRootPath/testChildPathOne", "testChildDataOne".getBytes(),
   Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT); 
 System.out.println(new String(zk.getData("/testRootPath",false,null))); 
 // 取出子目录节点列表
 System.out.println(zk.getChildren("/testRootPath",true)); 
 // 修改子目录节点数据
 zk.setData("/testRootPath/testChildPathOne","modifyChildDataOne".getBytes(),-1); 
 System.out.println("目录节点状态：["+zk.exists("/testRootPath",true)+"]"); 
 // 建立另一个子目录节点
 zk.create("/testRootPath/testChildPathTwo", "testChildDataTwo".getBytes(), 
   Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT); 
 System.out.println(new String(zk.getData("/testRootPath/testChildPathTwo",true,null))); 
 // 删除子目录节点
 zk.delete("/testRootPath/testChildPathTwo",-1); 
 zk.delete("/testRootPath/testChildPathOne",-1); 
 // 删除父目录节点
 zk.delete("/testRootPath",-1); 
 // 关闭链接
 zk.close();

官网例子请看：http://zookeeper.majunwei.com...
其余例子：
http://www.uml.org.cn/zjjs/20...
http://www.uml.org.cn/zjjs/20...

进阶：

http://zookeeper.majunwei.com...

参考：

官方文档：https://zookeeper.apache.org/...
小马过河翻译社，Zookeeper文档中文版：http://zookeeper.majunwei.com...
周旭龙，ZooKeeper环境搭建：http://www.cnblogs.com/edison...
Zookeeper 的学习与运用：http://www.oschina.net/questi...
邬兴亮，Zookeeper随笔系列:http://www.cnblogs.com/wuxl36...
ggjucheng,Zookeeper Api(java)入门与应用:http://www.cnblogs.com/ggjuch...