zookeeper适用场景：如何竞选Master及代码实现

转载：http://www.aboutyun.com/forum.php?mod=viewthread&tid=9277&ctid=16

问题导读：
1.如何利用zookeeper保证集群Master可用性和唯一性？
2.zookeeper竞选Master包含哪些过程？
3.zookeeper竞选Master机制利用了zk哪些特性？






在zookeeper应用场景中提出了对于Master节点管理的问题，如何保证集群中Master可用性和唯一性，下面就利用zookeeper来实现。
在确保zookeeper集群节点安装配置的前提下，假设zk已经对外提供了正常的服务，通过下面的步骤来实现Master竞选

• Client连接到zk上，判断znode /Roles/workers是否存在，不存在则建立，znode的类型是PERSISTENT类型，保证不会随着C1的session断开而消失。
• Client在/Roles/workers下面建立一个SEQUENCE|EPHEMERAL类型的znode，前缀可以是worker，由zk保证znode编号是递增而且是暂时的，EPHEMERAL在前文说了，一旦session断开创建的znode也会消失。
• Client通过getChildren获取所有的/Roles/workers下znode列表，并且设置一个Watcher等待通知，返回值有多少个znode数量就对应Client来竞选。
• 对于步骤4返回的节点列表进行排序，找到最小的worker编号，如果是和自己创建的一致（步骤2返回值），那么就代表自己的编号是最小的，自己就是Master。如果发现自己的编号不是最小，那么就等待通知，一旦Watcher触发，就在Watcher回到步骤3。
  

上面的机制主要利用了zk的几个特性

• 对于N个客户端同时请求create一个znode，zk能保证顺序的一致性，并且保证每个客户端创建的znode节点是递增并且唯一。
• 因为创建的znode是临时的，一旦session断开，那么znode就会从zk上消失，从而给每个设置Watcher的客户端发送通知，让每个客户端重新竞选Master，编号小的肯定是Master，保证了唯一性。
  

下图是上面的逻辑图
 



下面是实现的代码，默认是连接本地的zk服务，端口是2181，zkclient模块位于 zookeeper python接口 只需要运行多个下面的脚本就会能实现Master的竞选。

• 先后在三个终端上面运行下面的脚本，模拟为c1,c2,c3三个client，创建的节点依次是/Roles/workers/worker0000000000,/Roles/workers/worker0000000001,依次是/Roles/workers/worker0000000002
• 发现c1成功竞选了Master，然后c2和c3都是slave
• 把c1关了从而导致依次是/Roles/workers/worker0000000000消失，一段时间后c2和c3会重新竞选，c2会成为master，c3是slave
• 重新启动c1，发现c1立马加入集群，消息里面变更表示创建了新的znode依次是/Roles/workers/worker0000000003，重新竞选，c2还是master
  

PS:上面步骤3里面一个客户端关闭后经历了一段时间znode才会删除，原因是这段时间内zk的session还没有被清除，因为关闭是通过ctrl+c关闭的。但是加了一个客户端，znode里面创建，就会通知其余注册了watcher的客户端

1. #!/usr/bin/env python2.7
   
2. # -*- coding: UTF-8 -*-
   
3. 
   
4. import logging
   
5. from os.path import basename, join
   
6. 
   
7. from zkclient import ZKClient, zookeeper, watchmethod
   
8. 
   
9. logging.basicConfig(
   
10.     level = logging.DEBUG,
    
11.     format = "[%(asctime)s] %(levelname)-8s %(message)s"
    
12. )
    
13. 
    
14. log = logging
    
15. 
    
16. class GJZookeeper(object):
    
17. 
    
18.     ZK_HOST = "localhost:2181"
    
19.     ROOT = "/Roles"
    
20.     WORKERS_PATH = join(ROOT, "workers")
    
21.     MASTERS_NUM = 1
    
22.     TIMEOUT = 10000
    
23. 
    
24.     def __init__(self, verbose = True):
    
25.         self.VERBOSE = verbose
    
26.         self.masters = []
    
27.         self.is_master = False
    
28.         self.path = None
    
29. 
    
30.         self.zk = ZKClient(self.ZK_HOST, timeout = self.TIMEOUT)
    
31.         self.say("login ok!")
    
32.         # init
    
33.         self.__init_zk()
    
34.         # register
    
35.         self.register()
    
36. 
    
37.     def __init_zk(self):
    
38.         """
    
39.         create the zookeeper node if not exist
    
40.         |-Roles
    
41.              |-workers
    
42.         """
    
43.         nodes = (self.ROOT, self.WORKERS_PATH)
    
44.         for node in nodes: 
    
45.             if not self.zk.exists(node):
    
46.                 try:
    
47.                     self.zk.create(node, "")
    
48.                 except:
    
49.                     pass
    
50. 
    
51.     @property
    
52.     def is_slave(self):
    
53.         return not self.is_master
    
54. 
    
55.     def register(self):
    
56.         """
    
57.         register a node for this worker,znode type : EPHEMERAL | SEQUENCE
    
58.         |-Roles
    
59.              |-workers
    
60.                      |-worker000000000x         ==>>master
    
61.                      |-worker000000000x+1       ==>>worker
    
62.                      ....
    
63.         """
    
64.         self.path = self.zk.create(self.WORKERS_PATH + "/worker", "1", flags=zookeeper.EPHEMERAL | zookeeper.SEQUENCE)
    
65.         self.path = basename(self.path)
    
66.         self.say("register ok! I'm %s" % self.path)
    
67.         # check who is the master
    
68.         self.get_master()
    
69. 
    
70.     def get_master(self):
    
71.         """
    
72.         get children, and check who is the smallest child
    
73.         """
    
74.         @watchmethod
    
75.         def watcher(event):
    
76.             self.say("child changed, try to get master again.")
    
77.             self.get_master()
    
78.         try :
    
79.             children = self.zk.get_children(self.WORKERS_PATH, watcher)
    
80.         except zookeeper.ConnectionLossException:
    
81.             print "losing connection with zookeeper..."
    
82.             return False
    
83.         except :
    
84.             return False
    
85.         children.sort()
    
86.         self.say("%s's children: %s" % (self.WORKERS_PATH, children)) 
    
87. 
    
88.         # check if I'm master
    
89.         self.masters = children[:self.MASTERS_NUM]
    
90.         if self.path in self.masters:
    
91.             self.is_master = True
    
92.             self.say("I've become master!")
    
93.         else:
    
94.             self.say("%s is masters, I'm slave" % self.masters)
    
95. 
    
96. 
    
97.     def say(self, msg):
    
98.         """
    
99.         print messages to screen
    
100.         """
     
101.         if self.VERBOSE:
     
102.             if self.path:
     
103.                 log.info("[ %s(%s) ] %s" % (self.path, "master" if self.is_master else "slave", msg))
     
104.             else:
     
105.                 log.info(msg)
     
106. 
     
107. def main():
     
108.     gj_zookeeper = GJZookeeper()
     
109. 
     
110. if __name__ == "__main__":
     
111.     main()
     
112.     import time
     
113.     time.sleep(1000)

复制代码

集群管理（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 容易出现单点故障的问题。
图 3. 集群管理结构图

 

这部分的示例代码如下，完整的代码请看附件：
清单 3. Leader Election 关键代码（已下线，替换成FastLeaderElection.java lookForLeader()）

1. void findLeader() throws InterruptedException {
   
2.         byte[] leader = null;
   
3.         try {
   
4.             leader = zk.getData(root + "/leader", true, null);
   
5.         } catch (Exception e) {
   
6.             logger.error(e);
   
7.         }
   
8.         if (leader != null) {
   
9.             following();
   
10.         } else {
    
11.             String newLeader = null;
    
12.             try {
    
13.                 byte[] localhost = InetAddress.getLocalHost().getAddress();
    
14.                 newLeader = zk.create(root + "/leader", localhost,
    
15.                 ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
    
16.             } catch (Exception e) {
    
17.                 logger.error(e);
    
18.             }
    
19.             if (newLeader != null) {
    
20.                 leading();
    
21.             } else {
    
22.                 mutex.wait();
    
23.             }
    
24.         }
    
25.     }

复制代码