zookeeper学习（一）

zookeeper的特点：

1、最终一致性： 为客户端展示同一个视图，这是zookeeper里面一个非常重要的功能

2、可靠性 ： 如果消息被一台服务器接收，那么他将被所有的服务器接收

3、zookeeper不能保证两个客户端同时得到刚更新的数据，如果需要最新数据，应该在读数据之前调用sync（）接口

4、独立性： 各个client之间互不干预

5、原子性：更新只能成功或者失败，没有中间状态

6、顺序性：所有server，统一消息的发布顺序一致

统一视图： 会话session

数据模型Znode  --目录结构  --节点类型

事件监听Watcher

原理： 原子消息广播协议ZAB

paxos   -jouenalnode -sentinel -zookeeper ->ZAB

zxid,myid

ZXID:epoch+ID

广播模式原理

恢复模式原理：无主模型：ZAB：ZXID，myid

集群状态： 选举模式  安期内

广播模式：壤其外

server状态：

LOOKING：当前server不知道leader是谁，正在搜寻

LEADING：当前Server即为选举出来的leader

FOLLOWING：leader已经选举出来，当前server与其同步

主从分工：

领导者（leader） ： 负责进行投票的发起和决议，更新系统状态

学习者（learner）：包括跟随者和观察者，follower用于接受客户端请求并向客户端返回结果，在选主过程中参与投票

OBSERVER： 可以接受客户端的连接，将写请求转发给leader,但Observer不参加投票过程，只同步leader的状态，Observer的目的是为了扩展系统，提高读取速度

会话seeion：客户端与集群节点建立TCP连接后获得一个session

如果连接的Server出现问题，在没有超过Timeout时间内，可以连接其他的节点

同一session期内的特性不变

session是由谁创建出来的：

leader： 产生一个唯一的session,放到消息队列，让所有的server 知道

注：leader的选举过程： 先通过版本ID：ZXID进行选举，以最新的为主，如果多个节点之间的版本ID是一致的，就通过serverID进行选举，选举sernerID 最大的那个节点  ，当节点中的数据发生更新的时候，版本的ID就会进行更新 ‘

znode信息： 包含最大1M的数据信息，包含了ZXID等元数据信息

zookeeper集群的搭建：

1、上传安装包，并进行解压

2、配置环境变量 /etc/profile

3 、将配置好的文件分发到其他的节点

4、zookeeper的bin目录中最终要的两个脚本文件： zkCli.sh zkServer.sh (一个是客户端的启动命令，一个是脚本服务器的启动命令)

5、修改配置文件： 进入conf文件  cd /conf  修改zoo_sample.cfg文件  mv zoo_sample.cfg zoo.cfg

6、vi zoo.cfg   修改服务器存储文件的路劲   dataDir=/var/wcg/zk

添加服务器信息：

server.1=mynode03:2888:3888(2888代表不同服务器之间的通讯端口，3888代表的是发生内部选举的时候，通过那个节点那个端口进行的选举 )

server.2=mynode04:2888:3888

server.3=mynode05:2888:3888

7、分发配置文件

8、创建在配置文件中写的路径，存放当前服务器的编号id,就是serverid

echo 1 > /var/wcg/zk/myid

echo 2 > /var/wcg/zk/myid

echo 3 > /var/wcg/zk/myid

zookeeper客户端操作常用命令：

create ：创建一个节点 ，创建节点的时候需要在根目录下面进行创建 create /wcg  hello

mzxid--代表版本编号，每进行数据更新的时候，就会更新版本参数

get --获取创建信息的的命令 get /wcg

set -- 修改当前节点信息

pzxid --代表父目录下子目录的最新版本ID

zookeeper不允许创建重复的节点

Znode有两种类型，短暂的（ephemeral）和持久的（persistent）

Znode支持序列SEQUENTIAL:leader

--短暂的znode的客户端会话结束时，zookeeper会将该短暂znode 删除，短暂znode不可以有子节点

--持久Znode不依赖于客户端会话，只有当客户端明确要删除该持久znode时才会被删除

Znode的类型在创建时确定并且之后不能在进行修改

Znode有四种形式的目录节点

PERSISTENT

EPHEMERAL

一旦客户端和服务器端失去联系之后，临时性节点就会失效被删除

创建节点时有两个参数，如果创建的时候什么参数都不加，默认创建的是永久性的节点

创建临时性的节点： create -e /wcg hello

加入查看节点信息，看到参数ephemeralOwner的值为0x0，说明该节点是一个持久化的节点，当该参数是一个字符串的时候，说明创建的是一个临时性的节点

创建一个序列化的节点：  create -s /wcg hello 创建序列化节点的作用：每个节点名称后面自动添加一个数值，保证当有两个相同节点注册的时候，不会出现节点重复的现象

zookeeper API： process类的作用：监听某个事件发生的具体类型以及该事件的详细信息，并将这些信息封装到一个类之中，zookeeper能做的就是回调客户端的函数，然后同调用process方法，通过回调函数来处理事件的具体情况

概述

Zookeeper是Apache下的项目之一，倾向于对大型应用的协同维护管理工作。IBM则给出了IBM对ZooKeeper的认知： Zookeeper 分布式服务框架是 Apache Hadoop 的一个子项目，它主要是用来解决分布式应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步服务、集群管理、分布式应用配置项的管理等。总之，可以用“协调”这个核心的词来形容它的作用。关于它能干吗，你可以看看 “Zookeeper能干什么？”。

特征

我们可以把Zookeeper理解为一个精简的文件系统（和Linux文件系统结构非常相似），其每一个节点称为znode，znode下可以存放子节点，也可以直接对节点进行赋值存值。

Zookeeper被应用与一些集群上，提高集群的高可用。它可以帮助你避免单点故障，使你的系统更加可靠。

Zookeeper的集群我们可以通俗的理解为，一个有Leader的团队，团队中各个成员的数据都是一致的。团队中的Leader采用选举算法推举，所以可以保证在Leader出现问题的时候，又会选举出新的Leader。（fast paxos 选举算法大家可以深入了解下）

Zookeeper使用路径来描述节点，节点可以被看做是一个目录，也可以被看做是一个文件，它同时具有两者的特点。

Zookeeper的Watch机制也是它的最大被应用的原因。当我们有很多客户端连接到Zookeeper时，当被设置了Watch的数据发生了改变的时候，则服务器将这个改变发送给设置了Watch的客户端，通知它们。所以我们经常用它来做业务系统的统一配置管理。使用zk的Watch要特别注意一点就是它的“一次性触发器”（最后的Java例子中有模拟这点）。

集群部署

1. 下载

官网：http://zookeeper.apache.org/releases.html
下载：zookeeper-3.4.8.tar.gz

2. 安装

因为资源有限，所以我在同一个服务器上面创建3个目录 server1、server2、server3 来模拟3台服务器集群。
cd server1
tar -zxvf zookeeper-3.4.8.tar.gz
mkdir data
mkdir dataLog
data 为数据目录，dataLog 为日志目录。

3. 配置

cd zookeeper-3.4.8/conf
创建文件 zoo.cfg，内容如下：

tickTime=2000
initLimit=5
syncLimit=2
dataDir=/opt/zookeeper/server1/data
dataLogDir=/opt/zookeeper/server1/dataLog
clientPort=2181
server.1=127.0.0.1:2888:3888
server.2=127.0.0.1:2889:3889
server.3=127.0.0.1:2890:3890
1
2
3
4
5
6
7
8
9
tickTime：zookeeper中使用的基本时间单位, 毫秒值。
initLimit：这个配置项是用来配置 Zookeeper 接受客户端（这里所说的客户端不是用户连接 Zookeeper 服务器的客户端，而是 Zookeeper 服务器集群中连接到 Leader 的 Follower 服务器）初始化连接时最长能忍受多少个 tickTime 时间间隔数。这里设置为5表名最长容忍时间为 5 * 2000 = 10 秒。
syncLimit：这个配置标识 Leader 与 Follower 之间发送消息，请求和应答时间长度，最长不能超过多少个 tickTime 的时间长度，总的时间长度就是 2 * 2000 = 4 秒。
dataDir 和 dataLogDir 看配置就知道干吗的了，不用解释。
clientPort：监听client连接的端口号，这里说的client就是连接到Zookeeper的代码程序。
server.{myid}={ip}:{leader服务器交换信息的端口}:{当leader服务器挂了后, 选举leader的端口}
maxClientCnxns：对于一个客户端的连接数限制，默认是60，这在大部分时候是足够了。但是在我们实际使用中发现，在测试环境经常超过这个数，经过调查发现有的团队将几十个应用全部部署到一台机器上，以方便测试，于是这个数字就超过了。

修改zoo.cfg非常简单，然后还需要创建myid文件：
cd server1
echo 1 > myid

然后拷贝server1为server2和server3，并修改其中的zoo.cfg配置，当然也要修改myid的内容为2和3。

下面给出3个server的zoo.cfg 内容：

# server1
tickTime=2000
initLimit=5
syncLimit=2
dataDir=/opt/zookeeper/server1/data
dataLogDir=/opt/zookeeper/server1/dataLog
clientPort=2181
server.1=127.0.0.1:2888:3888
server.2=127.0.0.1:2889:3889
server.3=127.0.0.1:2890:3890
1
2
3
4
5
6
7
8
9
10
# server2
tickTime=2000
initLimit=5
syncLimit=2
dataDir=/opt/zookeeper/server2/data
dataLogDir=/opt/zookeeper/server2/dataLog
clientPort=2182
server.1=127.0.0.1:2888:3888
server.2=127.0.0.1:2889:3889
server.3=127.0.0.1:2890:3890
1
2
3
4
5
6
7
8
9
10
# server3
tickTime=2000
initLimit=5
syncLimit=2
dataDir=/opt/zookeeper/server3/data
dataLogDir=/opt/zookeeper/server3/dataLog
clientPort=2183
server.1=127.0.0.1:2888:3888
server.2=127.0.0.1:2889:3889
server.3=127.0.0.1:2890:3890
1
2
3
4
5
6
7
8
9
10
这里做下说明：因为我们是在同一个机器上模拟的集群，所以要注意server端口号和clientPort不要重复了，不然会出现端口冲突。所以，如果我们是3个不同的机器上做的3个server，那么我们的zoo.cfg配置都是一样的（注意server.{myid}=后面的IP地址使用具体的IP地址，如192.168.0.88）。还有就是，每一个server的myid内容都不能一样，这也可以理解为不同server的标识。

4. 启动

进入 zookeeper-3.4.8/bin 目录，使用 ./zkServer.sh start 启动zk服务。（你也可以使用 ./zkServer.sh start myzoo.cfg 指定配置文件启动，这在自动化运维的时候很有用）
使用 tail -f zookeeper.out 查看日志。
要说的是：在启动第一个的时候，日志中会出现一堆错误，仔细一看就能明白，是因为另外2个server还没有启动它连接不上的错误。然后当我们启动第二个server的时候，日志中的错误将会减少。最后我们把所有server都启动起来后，日志中便没有错误了。

5. 测试

随便进入一个zk目录，连接一个server测试。
cd zookeeper-3.4.8/bin
zkCli.sh -server 127.0.0.1:2181
如果你要连接别的服务器，请指定具体的IP地址。

几个基本命令说明：
ls 查看指定节点中包含的子节点（如：ls / 或 ls /app1/server1）
create 创建节点并赋值
get 读取节点内容
set 改变节点内容
delete 删除节点
注意zk中所有节点都基于路径确定，如你要删除 /app1/server1/nodeA 的命令为：
delete /app1/server1/nodeA

下面是基本操作截图：
这里写图片描述

Java程序Demo

创建一个Maven工程
打开pom.xml文件添加zookeeper依赖

        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.6</version>
        </dependency>
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 依赖配置：

        <!--zkclient -->
        <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.7</version>
        </dependency>
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<String>() {

            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<String> 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描述的路径，预新增的最终节点之前的所有父节点都必须要存在，否则会抛出异常。所以根据自己需要做好处理。

常用的四字命令如下：

  • conf: 打印ZooKeeper的配置信息
  • cons: 列出所有的客户端会话链接
  • crst: 重置所有的客户端连接
  • dump: 打印集群的所有会话信息，包括ID，以及临时节点等信息。用在Leader节点上才有效果。
  • envi: 列出所有的环境参数
  • ruok: "谐音为Are you ok"。检查当前服务器是否正在运行。
  • stat: 获取ZooKeeper服务器运行时的状态信息，包括版本，运行时角色，集群节点个数等信息。
  • srst: 重置服务器统计信息
  • srvr: 和stat输出信息一样，只不过少了客户端连接信息。
  • wchs: 输出当前服务器上管理的Watcher概要信息
  • wchc: 输出当前服务器上管理的Watcher的详细信息，以session为单位进行归组
  • wchp: 和wchc非常相似，但是以节点路径进行归组
  • mntr: 输出比stat更为详细的服务器统计信息

调用这些四字命令的指令： echo stat | nc localhost 2181

JMX

JMX是用来远程监控Java应用的框架，这个也可以用来监控其他的Java应用。JMX使用起来也很简单。

在运行Java的jar的时候：

//不需要用户密码的
-Dcom.sun.management.jmxremote.port=5000
-Dcom.sun.management.jmxremote.authenticate=true
-Dcom.sun.management.jmxremote.ssl=false 

// 使用需要用户密码登录的
-Dcom.sun.management.jmxremote.port=5000
-Dcom.sun.management.jmxremote.authenticate=true
-Dcom.sun.management.jmxremote.ssl=false
-Dcom.sun.management.jmxremote.access.file=jmxremote.access
-Dcom.sun.management.jmxremote.password.file=jmxremote.password   

? cat jmxremote.access
monitorRole   readonly
controlRole   readwrite
? cat jmxremote.password
monitorRole mypassword
controlRole mypassword

接下来，我们可以使用jConsole或者VisualVM进行监控。

默认情况下，ZooKeeper允许本地进行监控。

如果想要远程监控，可以修改zkServer.sh文件中的shell脚本

修改方式为我们刚才看到的加上

-Dcom.sun.management.jmxremote.access.file=jmxremote.access
-Dcom.sun.management.jmxremote.password.file=jmxremote.password

Exhibitor

Exhibitor是一个ZooKeeper的管理工具，由Netfix公司开发，在ZooKeeper监控，备份恢复，清洁，在可视化上提供了不小的帮助。

  1. 首先我们下载exhibitor的pom文件

    mkdir build
cd build
wget -c https://raw.github.com/Netflix/exhibitor/master/exhibitor-standalone/src/main/resources/buildscripts/standalone/maven/pom.xml
  2. 打包编译jar包

    //这个打包的时间真心长
mvn clean package
// 测试是否正确打包，这个exhibitor根据你自己打包出来的文件名进行测试
java -jar target/exhibitor-1.6.0.jar --help
  3. 运行

    java -jar exhibitor-1.6.0.jar -c file
        1. 在浏览器中输入exhibitor的地址
          http://服务器地址:8080/exhibitor/v1/ui/index.html
        2. 配置Exhibitor

  1. 更多Exhitor的详细信息，参考github的wiki

https://github.com/soabase/exhibitor/wiki

 

原文地址：https://www.cnblogs.com/wcgstudy/p/11145498.html

时间： 2024-09-29 05:03:12

zookeeper学习（一）的相关文章

zookeeper 学习资料

zookeeper 学习资料 学习资料 网址 Zookeeper 教程(菜鸟教程) https://www.w3cschool.cn/zookeeper/ 原文地址:https://www.cnblogs.com/cag2050/p/10278027.html

zookeeper学习(零)_安装与启动

zookeeper学习(零)_安装与启动 最近换了新的电脑,终于买了梦寐以求的macbook.最近也换了新的公司,公司技术栈用到了zookeeper.当然自己也要安装学习下.省的渣渣的我,被鄙视就麻烦了.本篇文章只介绍如何安装,先安装上之后,再进行具体学习. 安装 本文使用brew 进行安装,默默说一句,mac的系统是比win好用.没有安装brew和jdk的童鞋请先安装这2个. 打开终端执行命令 brew install zookeeper 启动执行 zkServer start 执行zk连接

[转帖]Zookeeper学习系列【一】 教会你Zookeeper的一些基础概念

Zookeeper学习系列[一] 教会你Zookeeper的一些基础概念 https://segmentfault.com/a/1190000018927058 前言 最近加入了部门的技术兴趣小组,被分配了Zookeeper的研究任务.在研究过程当中,发现Zookeeper由于其开源的特性和其卓越的性能特点,在业界使用广泛,有很多的应用场景,而这些不同的应用场景实际上底层的原理都是差不多的,只要你真正理解了Zookeeper的一些基础概念和机制,就能够触类旁通. 于是乎,在第一次和项目小组内成员

ZooKeeper学习第二期--ZooKeeper安装配置

一.Zookeeper的搭建方式 Zookeeper安装方式有三种,单机模式和集群模式以及伪集群模式. ■ 单机模式:Zookeeper只运行在一台服务器上,适合测试环境:■ 伪集群模式:就是在一台物理机上运行多个Zookeeper 实例:■ 集群模式:Zookeeper运行于一个集群上,适合生产环境,这个计算机集群被称为一个"集合体"(ensemble) Zookeeper通过复制来实现高可用性,只要集合体中半数以上的机器处于可用状态,它就能够保证服务继续.为什么一定要超过半数呢?这

【Todo】Zookeeper学习

首先,Zookeeper是基于Paxos来进行分布式选举管理的,Paxos的内容可以参考我另一篇文章:http://www.cnblogs.com/charlesblc/p/6037004.html Zookeeper因为平时用的不多,主要也就是安装的其他系统中会带上.对Zookeeper有一个概念上的了解,就好.暂时不用深入实践了. 准备参考这个系列的文章进行学习:http://www.cnblogs.com/leocook/p/zk_0.html 然后还有这篇文章:http://blog.c

zookeeper学习系列：三、构建一个分布式master、slave系统

之前只理解zk可以做命名,配置服务,现在学习下他怎么用作构建master-slave模式的分布式系统. 为什么叫Zoo?“因为要协调的分布式系统是一个动物园”. ZooKeeper是一个中性化的Service,用于管理配置信息.命名.提供分布式同步,还能组合Service.所有这些种类的Service都会在分布式应用程序中使用到.每次编写这些Service都会涉及大量的修bug和竞争情况.正因为这种编写这些Service有一定难度,所以通常都会忽视它们,这就使得在应用程序有变化时变得难以管理应用

ZooKeeper学习第五期--ZooKeeper管理分布式环境中的数据

转:http://www.cnblogs.com/sunddenly/p/4092654.html 引言 本节本来是要介绍ZooKeeper的实现原理,但是ZooKeeper的原理比较复杂,它涉及到了paxos算法.Zab协议.通信协议等相关知识,理解起来比较抽象所以还需要借助一些应用场景,来帮我们理解.由于内容比较多,一口气吃不成胖子,得慢慢来一步一个脚印,因此我对后期ZooKeeper的学习规划如下: 第一阶段: |---理解ZooKeeper的应用 |---ZooKeeper是什么 |--

ZooKeeper学习总结 第二篇：ZooKeeper深入探讨

其实zookeeper系列的学习总结很早就写完了,这段时间在准备找工作的事情,就一直没有更新了.下边给大家送上,文中如有不恰当的地方,欢迎给予指证,不胜感谢!. 1. 数据模型 1.1. 只适合存储小数据 Zk维护着一个逻辑上的树形层次结构,树中的节点称为znode,个znode都有一个ACL(权限控制).Zookeeper是被设计用来协调服务的,因此znode里存储的都是小数据,而不是大容量的数据,数据容量一般在1MB范围内. 1.2. 操作的原子性 Znode的数据读写是原子的,要么读或写了

zookeeper学习第一天

Zookeeper用途场景: 1:zookeeper分布式服务框架:是Apache Hadoop的一个子项目,主要是用来解决分布式应用场景中经常遇到的一些数据管理问题. 2:如:集群管理.统一命名服务.分布式配置管理.分布式消息队列.分布式锁.分布式通知协调等. 3:越来越多的分布式计算开始强依赖ZK,比如Storm.Hbase. 4:Zookeeper对分布式开发带来很多便利,用ZK的独有特性巧妙的解决了很多难题:很多分布式技术用到Zookeeper或多或少特性,尤其是新生代分布式技术几乎都会

ZooKeeper 学习之 安装 部署

ZooKeeper是一个分布式的,开放源码的分布式应用程序协调服务,ZooKeeper是以Fast Paxos算法为基础,实现同步服务,配置维护和命名服务等分布式应用. Zookeeper 分布式服务框架是 Apache Hadoop 的一个子项目,它主要是用来解决分布式应用中经常遇到的一些数据管理问题,如:统一命名服务.状态同步服务.集群管理.分布式应用配置项的管理等.核心词就是一个,协调. 下面实践安装来学习下,分为独立部署.集群部署 一.下载安装 wget -c http://www.eu