分布式服务框架 Zookeeper -- 管理分布式环境中的数据

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

一、安装和配置详解

    本文介绍的 Zookeeper 是以 3.4.5 这个稳定版本为基础，最新的版本可以通过官网 http://zookeeper.apache.org/来获取，Zookeeper 的安装非常简单，下面将从单机模式、伪集群模式和全集群模式三个方面介绍 Zookeeper 在Linux下的安装和配置。

1、单机模式

    单机安装非常简单，只要获取到 Zookeeper 的压缩包并解压到某个目录如：/home/fenglibin/soft/zookeeper-3.4.5 下，Zookeeper 的启动脚本在 bin 目录下，配置文件在安装目录的conf目录下。

1.1、配置文件介绍

    在我们启动Zookeeper之前，首先我们需要编写Zookeeper的配置文件conf/zoo.cfg，Zookeeper启动的时候会从该文件中读取属性，如果不存在就会报错误，这个文件不用我们重头开始写，只需要将conf目录下面的zoo_sample.cfg拷贝一份并重命名为zoo.cfg，然后修改其中的属性即可。下面详细介绍一下，这个配置文件中各个配置项的意义。

# 这个时间是作为 Zookeeper 服务器之间或客户端与服务器之间维持心跳的时间间隔，也就是每个 tickTime 时间就会发送一个心跳。

tickTime=2000

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

initLimit=10

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

syncLimit=5

# 是 Zookeeper 保存数据快照的目录，默认情况下，Zookeeper 将写数据的日志文件也保存在这个目录里。注：此目录不要是临时目录/tmp，因为大部份的Linux系统会在重启后清除该目录的内容，造成数据丢失。

dataDir=/home/fenglibin/soft/zookeeper-3.4.5/data

# 这个端口就是客户端连接 Zookeeper 服务器的端口，Zookeeper 会监听这个端口，接受客户端的访问请求。

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

# 这是个3.4.0中才引入的新特性，当启用该配置时，ZooKeeper将执行保留最新快照以及自动执行清除dataDir以及dataLogDir下面的旧的事务日志，只保留指定数量的最新事务日志数据，默认值为3，且最小值也必须为3。

#autopurge.snapRetainCount=3

# Purge task interval in hours

# 自动清除的时间间隔，以小时为单，如果设置为0，将不会执行该任务。默认值为0。

#autopurge.purgeInterval=1

    所有的配置，可参看这里：http://zookeeper.apache.org/doc/trunk/zookeeperAdmin.html#sc_advancedConfiguration

1.2、Bin目录介绍及Zookeeper的启动

    现在介绍bin，在该目录下有四个shell文件：

文件名

说明

zkCleanup.sh

用于清除旧的事务日志及快照

zkEnv.sh or zkEnv.bat

调用于运行时的环境变量，如classpath的设置，堆的大小设置等

zkServer.sh or zkServer.bat

用于执行Zookeeper的启动、停止及状态查看等操作

zkCli.sh or zkCli.bat

Zookeeper的shell客户端，如果是连接本机启动为默认端口2181的的Zookeeper，直接打入zkCli.sh命令，不需要任何参数

    常用的肯定是zkServer.sh及zkCli.sh两个了，以下为使用介绍。

1.2.1、zkServer.sh的使用

#启动Zookeeper

./bin/zkServer.sh start

 

停止Zookeeper

./bin/zkServer.sh stop

#查看Zookeeper的状态

./bin/zkServer.sh status

zkServer.sh还有其它几个参数：start-foreground、restart、upgrade、print-cmd，分别用于在前台启动、重启、更新、操作。

1.2.2、zkCli.sh的使用

连接本机的Zookeeper

./bin/zkCli.sh

连接非本机的Zookeeper

./bin/zkCli.sh -server nginx2:2181

查看服务端的启动状态

 

表示服务端启动成功

 

1.2.3、命令行验证

    请查看此文档中的示例：http://www.ibm.com/developerworks/library/bd-zookeeper/#N100BD

 

 2、集群模式

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

    Zookeeper 的集群模式的安装和配置也不是很复杂，所要做的就是增加几个配置项。集群模式除了上面的单机的配置项外，还要增加下面几个配置项：

server.1=nginx1:2888:3888

server.2=nginx2:2888:3888

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

    除了修改 zoo.cfg 配置文件，集群模式下还要配置一个文件 myid，这个文件在 dataDir 目录下，这个文件里面就有一个数据就是 A 的值，用来表示当前主机，如在server.1上面该值为1，在server.2上面，该值就是2。

二、控制集群中同时只有一台服务器“说话”的示例

    场景一：有些时候需要控制集群中的服务器做缓存预热的时候，只需要其中一台服务器去做这个事情就可以了，因为缓存是类似Memcached的中央集群Cache，只需要有一台将数据成功加载了，那么集群中的其它服务器都可以访问，多台同时加台可能会造成数据冲突以及资源的浪费。

    场景二：在共享存储的情况下，就是集群中的所有服务器都访问的相同的挂载存储，而此时应用需要执行JAR包动态加载，即有新的JAR包上传上来后各个应用服务器就立即加载，但是在笔者的场景下，JAR包的上传是单独的第三方应用去完成的，并且上传过去的JAR的名称不是以.jar结尾的，在各应用加载之前需要将其改名为.jar文件，如果不控制应用去改名，那么就会出现冲突，或者存在多个拷贝的情况下，虽然说不会存在问题，但是毕竟让人不舒服。

    上面的两种场景，当然还可以其它的方式解决，如类似于Lucene的文件锁，或者使用Memcached锁，不一定非得使用ZooKeeper，不过在本例中是以ZooKeeper来解决问题的。

    本例使用的是控制集群中的服务器同一时刻只会有一台“说话”，此时集群中的其它服务器是不能够“说话”的，以达到控制集群中的服务器同一时刻只会有一台在做此“说话”的任务，本例适合于集群中伪分布应用的布署的情况，以及全集群的布署的情况，并可在与ZooKeeper连接Session过期后，采用自动重连，下面是运行截图：

   

   源码：   

package org.apache.zookeeper.test.copy;import java.io.File;import java.io.IOException;import java.net.InetAddress;import java.net.UnknownHostException;import java.util.List;import org.apache.commons.io.FileUtils;import org.apache.zookeeper.CreateMode;import org.apache.zookeeper.KeeperException;import org.apache.zookeeper.KeeperException.NodeExistsException;import org.apache.zookeeper.KeeperException.SessionExpiredException;import org.apache.zookeeper.WatchedEvent;import org.apache.zookeeper.Watcher;import org.apache.zookeeper.ZooDefs.Ids;import org.apache.zookeeper.ZooKeeper;import org.apache.zookeeper.data.Stat;import org.slf4j.Logger;import org.slf4j.LoggerFactory;/** * 使用Zookeeper来控制集群中的服务器，同一时刻只会有一台做指定的事情，名称多台同时做会产生冲突的情况。<rb> 这个示例演示的是集群中的服务器，同一时刻只会有一台说话，当这台服务服务器说话时，其它的服务器不可以说话。<br> * 如果在操作的过程中，连接Zookeeper过期了，会自动进行重连；并确保其在同一个服务器上面布署多个示例也可以正常运行。<br> * 运行该示例：导入Zookeeper下面的Jar包，并且其依赖commons-io，其它就不需要了 *  * @author fenglibin 2014-6-14 下午10:21:15 */public class SpeakOneByOneInCluster implements Watcher {    // 连接Zookeeper Server的客户端连接    static ZooKeeper            zk       = null;    // 锁    static Object               LOCK     = new Object();    // 用户操作的根节点，与“/”是不同的，用户可以控制    String                      root;    // 当前节点的名称，由服务器的名称加随机数据组成，之所以使用这种方式，那是考虑到同一台服务器上可能会布署多个应用示例，而不一定是每个应用示例布署到集群的不同服务器上    private static String       nodeName = "";    // 节点锁，只有能够创建该节点的应用示例，才可以做指定的事情，如本例中的说话    private static String       LOCK_NODE;    // 用于表示当前应用是否拿到了节点锁，然后根据是否拿到节点锁，才可以做指定的事情，如本例中的说话    static boolean              getLock;    String                      address;    // 日志文件    File                        logFile  = new File("D:/test/logFile.txt");    private static final Logger LOG;    static {        // Keep these two lines together to keep the initialization order explicit        LOG = LoggerFactory.getLogger(SpeakOneByOneInCluster.class);    }    SpeakOneByOneInCluster(String address){        this.address = address;        if (zk == null) {            try {                connect(address);            } catch (IOException e) {                writeLog(e.toString());                zk = null;            }        }    }    void connect(String address) throws IOException {        writeLog("Starting ZK:");        zk = new ZooKeeper(address, 2181, this);        writeLog("Finished starting ZK: " + zk);    }    synchronized public void process(WatchedEvent event) {        synchronized (LOCK) {            if (!event.getPath().equals(LOCK_NODE)) {                LOCK.notify();            }        }    }    /**     * 用于选举可用于做事情的应用     */    static public class Barrier extends SpeakOneByOneInCluster implements Runnable {        private static final Logger LOG;        static {            // Keep these two lines together to keep the initialization order explicit            LOG = LoggerFactory.getLogger(Barrier.class);        }        String                      nodeName;        /**         * Barrier constructor         *          * @param address         * @param root         * @param size         */        Barrier(String address, String root){            super(address);            this.root = root;            // Create barrier node            if (zk != null) {                try {                    Stat s = zk.exists(root, false);                    if (s == null) {                        zk.create(root, new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);                    }                } catch (KeeperException e) {                    writeLog("Keeper exception when instantiating queue: " + e.toString());                } catch (InterruptedException e) {                    writeLog("Interrupted exception");                }            }            // My node name            try {                this.nodeName = new StringBuilder(InetAddress.getLocalHost().getCanonicalHostName()).append((int) (Math.random() * 100)).toString();            } catch (UnknownHostException e) {                writeLog(e.toString());            }        }        /**         * Join barrier         *          * @return         * @throws KeeperException         * @throws InterruptedException         */        void lock() throws KeeperException, InterruptedException {            Stat stat = zk.exists(LOCK_NODE, false);            if (stat != null) {                return;            }            zk.create(LOCK_NODE, new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);            writeLog(SpeakOneByOneInCluster.nodeName + ":create node " + LOCK_NODE);            getLock = Boolean.TRUE;            List<String> childs = zk.getChildren(root, true);            // 节点存在了就返回不处理            if (!(childs == null || childs.size() == 0)) {                return;            }            zk.create(root + "/" + nodeName, new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);            writeLog(SpeakOneByOneInCluster.nodeName + ":create node " + root + "/" + nodeName);            SpeakOneByOneInCluster.nodeName = this.nodeName;        }        @Override        public void run() {            while (true) {                try {                    lock();                } catch (NodeExistsException e) {                } catch (SessionExpiredException e) {                    try {                        // Session过期了，进行重连                        connect(address);                    } catch (IOException e1) {                        LOG.error(e1.getMessage(), e1);                    }                } catch (Exception e) {                    LOG.error(e.getMessage(), e);                }            }        }    }    /**     * Producer-Consumer queue     */    static public class Speak extends SpeakOneByOneInCluster implements Runnable {        private static final Logger LOG;        static {            // Keep these two lines together to keep the initialization order explicit            LOG = LoggerFactory.getLogger(Speak.class);        }        /**         * Constructor of speaker         *          * @param address         * @param root         */        Speak(String address, String root){            super(address);            this.root = root;            // Create ZK node name            if (zk != null) {                try {                    Stat s = zk.exists(this.root, false);                    if (s == null) {                        zk.create(this.root, new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);                    }                } catch (SessionExpiredException e) {                    try {                        // Session过期了，进行重连                        connect(address);                    } catch (IOException e1) {                        LOG.error(e1.getMessage(), e1);                    }                } catch (KeeperException e) {                    writeLog("Keeper exception when instantiating queue: " + e.toString());                } catch (InterruptedException e) {                    writeLog("Interrupted exception");                }            }        }        /**         * Add element to the queue.         *          * @param i         * @return         */        boolean check() {            try {                if (getLock == Boolean.FALSE) {                    return false;                }                List<String> childs = zk.getChildren(root, true);                if (childs == null || childs.size() == 0) {                    return false;                }                if (childs.size() != 1) {                    throw new RuntimeException("childs's size is " + childs.size() + ", it must be 1.");                }                if (childs.get(0).endsWith(SpeakOneByOneInCluster.nodeName)) {                    return true;                }                return false;            } catch (SessionExpiredException e) {                try {                    // Session过期了，进行重连                    connect(address);                } catch (IOException e1) {                    LOG.error(e1.getMessage(), e1);                }                return false;            } catch (Exception e) {                LOG.error(e.getMessage(), e);                return false;            }        }        void speak() throws InterruptedException {            while (true) {                // writeLog(CopyOneFileInMultiVM.choosedNodeName + ":try speak...");                synchronized (LOCK) {                    if (!check()) {                        // writeLog(CopyOneFileInMultiVM.choosedNodeName + ":copy condition not ready,wait.");                        LOCK.wait();                    } else {                        writeLog(SpeakOneByOneInCluster.nodeName + ":speak now");                        doSpeak();                    }                }            }        }        void doSpeak() {            try {                writeLog(SpeakOneByOneInCluster.nodeName + ": Now only I can speak. Let me sleep 5s.");                Thread.sleep(5000);                writeLog(SpeakOneByOneInCluster.nodeName + ": I week up now.");                unlock();            } catch (SessionExpiredException e) {                try {                    connect(address);                    unlock();                } catch (Exception e1) {                    LOG.error(e1.getMessage(), e1);                }            } catch (Exception e) {                LOG.error(e.getMessage(), e);            }        }        /**         * delete the lock node         *          * @return         * @throws KeeperException         * @throws InterruptedException         */        void unlock() throws KeeperException, InterruptedException {            writeLog(SpeakOneByOneInCluster.nodeName + ":Begin to delete node " + SpeakOneByOneInCluster.nodeName + " and node " + LOCK_NODE);            zk.delete(root + "/" + SpeakOneByOneInCluster.nodeName, 0);            zk.delete(LOCK_NODE, 0);            getLock = Boolean.FALSE;            writeLog(SpeakOneByOneInCluster.nodeName + ":Resource release OK. It's you turn, bye.");        }        @Override        public void run() {            try {                speak();            } catch (InterruptedException e) {                // TODO Auto-generated catch block                LOG.error(e.getMessage(), e);            }        }    }    public void writeLog(String str) {        try {            System.out.println(str);            FileUtils.writeStringToFile(logFile, str + "\n", true);        } catch (IOException e) {            LOG.error(e.getMessage(), e);        }    }    public static void main(String[] args) throws InterruptedException {        LOCK_NODE = "/zk_test/lock";        new Thread(new Barrier("localhost", "/zk_test/chooseCopyMachine")).start();        new Thread(new Speak("localhost", "/zk_test/chooseCopyMachine")).start();        Runtime.getRuntime().addShutdownHook(new Thread() {            public void run() {                try {                    if (zk.exists(LOCK_NODE, false) != null) {                        zk.delete(LOCK_NODE, -1);                    }                    zk.close();                } catch (Exception e) {                    // TODO Auto-generated catch block                    LOG.error(e.getMessage(), e);                }            }        });    }}

   

三、参考

http://www.ibm.com/developerworks/library/bd-zookeeper/#N100BD

http://www.ibm.com/developerworks/cn/opensource/os-cn-zookeeper/

http://zookeeper.apache.org/doc/trunk/zookeeperTutorial.html

http://zookeeper.apache.org/doc/trunk/zookeeperAdmin.html

http://zookeeper.apache.org/doc/trunk/zookeeperAdmin.html#sc_advancedConfiguration