Zookeeper学习笔记3

最新推荐文章于 2022-08-02 12:17:31 发布
最新推荐文章于 2022-08-02 12:17:31 发布
阅读量146 收藏
点赞数
文章标签： 大数据 java
原文链接：http://www.cnblogs.com/lanqie/p/8662769.html
版权

客户端的操作

zkCli.sh

官方文档

ls /

[zookeeper]

get /

cZxid = 0x0
ctime = Thu Jan 01 08:00:00 CST 1970
mZxid = 0x0
mtime = Thu Jan 01 08:00:00 CST 1970
pZxid = 0x0
cversion = -1
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 0
numChildren = 1

create /test 123

Created /test

set /test 456

cZxid = 0x2
ctime = Wed Mar 28 11:20:40 CST 2018
mZxid = 0x3
mtime = Wed Mar 28 11:21:22 CST 2018
pZxid = 0x2
cversion = 0
dataVersion = 1
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 3
numChildren = 0

delete /test

Java API

创建会话

public class ZkDemon4java implements Watcher {
    private static CountDownLatch countDownLatch = new CountDownLatch(1);

    public void process(WatchedEvent watchedEvent) {
        System.out.println("receive wathedEvent:" + watchedEvent);
        if (Event.KeeperState.SyncConnected == watchedEvent.getState()) {
            countDownLatch.countDown();
        }

    }

    public static void main(String[] args) throws IOException, InterruptedException {
        ZooKeeper zooKeeper = new ZooKeeper("192.168.2.192:2181", 5000, new ZkDemon4java());
        System.out.println("zk status:" + zooKeeper.getState());
        countDownLatch.await();
    }
}

输出：

zk status:CONNECTING
receive wathedEvent:WatchedEvent state:SyncConnected type:None path:null

使用sessionId，sessionPasswd

        ZooKeeper zooKeeper = new ZooKeeper("192.168.2.192:2181", 5000, new ZkDemon4java());
        System.out.println("zk status:" + zooKeeper.getState());
        countDownLatch.await();

        long sessionId = zooKeeper.getSessionId();
        byte[] sessionPasswd = zooKeeper.getSessionPasswd();
        zooKeeper = new ZooKeeper("192.168.2.192:2181", 5000, new ZkDemon4java(), sessionId, sessionPasswd);
        zooKeeper = new ZooKeeper("192.168.2.192:2181", 5000, new ZkDemon4java(), sessionId, "123456".getBytes());
        Thread.sleep(Integer.MAX_VALUE);

结果：

zk status:CONNECTING
receive wathedEvent:WatchedEvent state:SyncConnected type:None path:null
receive wathedEvent:WatchedEvent state:SyncConnected type:None path:null
receive wathedEvent:WatchedEvent state:Expired type:None path:null
receive wathedEvent:WatchedEvent state:Disconnected type:None path:null
receive wathedEvent:WatchedEvent state:Disconnected type:None path:null
receive wathedEvent:WatchedEvent state:SyncConnected type:None path:null

Expired 是使用错误sessionPasswd的结果
至于结果中的不断地SyncConnected，Disconnected尚不清楚。

创建节点

1226359-20180328161341451-1923920970.png

同步执行：创建临时节点，临时顺序节点
  //sync
        String s = zooKeeper.create("/test1", "value1".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        System.out.println("success create path:" + s);

        s = zooKeeper.create("/test1", "value1".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        System.out.println("success create path:" + s);

结果：

zk status:CONNECTING
receive wathedEvent:WatchedEvent state:SyncConnected type:None path:null
success create path:/test1
success create path:/test10000000001

临时，顺序在zkCli用-e， -s指定，临时节点会在会话结束时删除，顺序节点会自动添加序号。

同步执行：
public class ZkDemon4java implements Watcher {
    private static CountDownLatch countDownLatch = new CountDownLatch(1);

    public void process(WatchedEvent watchedEvent) {
        System.out.println("receive wathedEvent:" + watchedEvent);
        if (Event.KeeperState.SyncConnected == watchedEvent.getState()) {
            countDownLatch.countDown();
        }

    }

    public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
        ZooKeeper zooKeeper = new ZooKeeper("192.168.2.192:2181", 5000, new ZkDemon4java());
        System.out.println("zk status:" + zooKeeper.getState());
        countDownLatch.await();

        IStringCallBack iStringCallBack = new ZkDemon4java().new IStringCallBack();
        //async
        zooKeeper.create("/test1", "value1".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL, iStringCallBack, "i am ctx");
        zooKeeper.create("/test1", "value1".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL, iStringCallBack, "i am ctx");
        zooKeeper.create("/test1", "value1".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL, iStringCallBack, "i am ctx");

        Thread.sleep(Integer.MAX_VALUE);
    }

    class IStringCallBack implements AsyncCallback.StringCallback {

        public void processResult(int i, String s, Object o, String s1) {
            System.out.println("Create Path result resultCode:" + i + ",path:" + s + ",ctx:" + o.toString() + ",real path name:" + s1);
        }
    }
}

结果：

zk status:CONNECTING
receive wathedEvent:WatchedEvent state:SyncConnected type:None path:null
Create Path result resultCode:0,path:/test1,ctx:i am ctx,real path name:/test1
Create Path result resultCode:-110,path:/test1,ctx:i am ctx,real path name:null
Create Path result resultCode:0,path:/test1,ctx:i am ctx,real path name:/test10000000009

1226359-20180328161152417-2091539671.png

删除节点

1226359-20180328161905139-187517592.png

zooKeeper.delete("/test", -1);

其中version=-1表示不论节点的dataVersion是什么都删除，如果指定一个大于-1的数，则只当version不一样时不能删除。

读取数据

getChildren（同步）
public class ZkDemon4java implements Watcher {
    private static CountDownLatch countDownLatch = new CountDownLatch(1);
    private static ZooKeeper zooKeeper;

    public void process(WatchedEvent watchedEvent) {
        System.out.println("receive wathedEvent:" + watchedEvent);
        if (Event.KeeperState.SyncConnected == watchedEvent.getState()) {
            if (watchedEvent.getType() == Event.EventType.None && null == watchedEvent.getPath()) {
                countDownLatch.countDown();
            } else if (Event.EventType.NodeChildrenChanged == watchedEvent.getType()) {
                try {
                    //if you need get advice again you must set watch:true
                    System.out.println("ReGet child:" + zooKeeper.getChildren(watchedEvent.getPath(), false));
                } catch (KeeperException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
        zooKeeper = new ZooKeeper("192.168.2.192:2181", 5000, new ZkDemon4java());
        System.out.println("zk status:" + zooKeeper.getState());
        countDownLatch.await();

        String path = "/zk_book";
        zooKeeper.create(path, "123".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        //get children List and register Watch
        System.out.println("get child result:" + zooKeeper.getChildren(path, new ZkDemon4java()));
        zooKeeper.create(path + "/c1", "123".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        zooKeeper.create(path + "/c2", "123".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);

        Thread.sleep(Integer.MAX_VALUE);
    }
}

System.out.println("ReGet child:" + zooKeeper.getChildren(watchedEvent.getPath(), false));一次通知

zk status:CONNECTING
receive wathedEvent:WatchedEvent state:SyncConnected type:None path:null
get child result:[]
receive wathedEvent:WatchedEvent state:SyncConnected type:NodeChildrenChanged path:/zk_book
ReGet child:[c1]

System.out.println("ReGet child:" + zooKeeper.getChildren(watchedEvent.getPath(), true));多次通知

zk status:CONNECTING
receive wathedEvent:WatchedEvent state:SyncConnected type:None path:null
get child result:[]
receive wathedEvent:WatchedEvent state:SyncConnected type:NodeChildrenChanged path:/zk_book
ReGet child:[c1]
receive wathedEvent:WatchedEvent state:SyncConnected type:NodeChildrenChanged path:/zk_book
ReGet child:[c1, c2]
getChildren（异步）
class ZkDemon4java implements Watcher {
    private static CountDownLatch countDownLatch = new CountDownLatch(1);
    private static ZooKeeper zooKeeper;

    public void process(WatchedEvent watchedEvent) {
        System.out.println("receive wathedEvent:" + watchedEvent);
        if (Event.KeeperState.SyncConnected == watchedEvent.getState()) {
            if (watchedEvent.getType() == Event.EventType.None && null == watchedEvent.getPath()) {
                countDownLatch.countDown();
            } else if (Event.EventType.NodeChildrenChanged == watchedEvent.getType()) {
                try {
                    //if you need get advice again you must set watch:true
                    System.out.println("ReGet child:" + zooKeeper.getChildren(watchedEvent.getPath(), true));
                } catch (KeeperException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
        zooKeeper = new ZooKeeper("192.168.2.192:2181", 5000, new ZkDemon4java());
        System.out.println("zk status:" + zooKeeper.getState());
        countDownLatch.await();

        String path = "/zk_book";
        zooKeeper.create(path, "123".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        //get children List and register Watch
        zooKeeper.getChildren(path, true, new IChildren2Callback(), "i am ctx");
        zooKeeper.create(path + "/c1", "123".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        zooKeeper.create(path + "/c2", "123".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);

        Thread.sleep(Integer.MAX_VALUE);
    }


}

class IChildren2Callback implements AsyncCallback.Children2Callback {

    public void processResult(int i, String s, Object o, List<String> list, Stat stat) {
        System.out.println("get children node result: result code:" + i + ",param path:" + s + ",ctx:" + o.toString() + ",children List:" + list + ",stat:" + stat);
    }
}

结果：

zk status:CONNECTING
receive wathedEvent:WatchedEvent state:SyncConnected type:None path:null
get children node result: result code:0,param path:/zk_book,ctx:i am ctx,children List:[],stat:211,211,1522231252330,1522231252330,0,0,0,0,3,0,211

receive wathedEvent:WatchedEvent state:SyncConnected type:NodeChildrenChanged path:/zk_book
ReGet child:[c1]
receive wathedEvent:WatchedEvent state:SyncConnected type:NodeChildrenChanged path:/zk_book
ReGet child:[c1, c2]
getData(同步)
public class ZkDemon4java implements Watcher {
    private static CountDownLatch countDownLatch = new CountDownLatch(1);
    private static ZooKeeper zooKeeper;

    public void process(WatchedEvent watchedEvent) {
        System.out.println("receive wathedEvent:" + watchedEvent);
        try {
            if (Event.KeeperState.SyncConnected == watchedEvent.getState()) {
                if (watchedEvent.getType() == Event.EventType.None && null == watchedEvent.getPath()) {
                    countDownLatch.countDown();
                } else if (Event.EventType.NodeDataChanged == watchedEvent.getType()) {
                    System.out.println("ReGet Data:" + zooKeeper.getData(watchedEvent.getPath(), true, new Stat()));
                }
            }
        } catch (Exception e) {
            e.toString();
        }
    }

    public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
        zooKeeper = new ZooKeeper("192.168.2.192:2181", 5000, new ZkDemon4java());
        System.out.println("zk status:" + zooKeeper.getState());
        countDownLatch.await();
        String path = "/zk_book";

        System.out.println("get data result:" + zooKeeper.getData(path, true, new Stat()));
        zooKeeper.setData(path, "123".getBytes(), -1);
        zooKeeper.setData(path, "123".getBytes(), -1);

        Thread.sleep(Integer.MAX_VALUE);
    }
}

结果：

zk status:CONNECTING
receive wathedEvent:WatchedEvent state:SyncConnected type:None path:null
get data result:[B@73f792cf
receive wathedEvent:WatchedEvent state:SyncConnected type:NodeDataChanged path:/zk_book
ReGet Data:[B@20d91839
receive wathedEvent:WatchedEvent state:SyncConnected type:NodeDataChanged path:/zk_book
ReGet Data:[B@2e1ee252
getData(异步)

略

下面的api如果异步比较简单就都省略

setData
package com.xh.zk.javaapi;

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;

/**
 * Created by root on 3/28/18.
 */
public class ZkDemon4java implements Watcher {
    private static CountDownLatch countDownLatch = new CountDownLatch(1);
    private static ZooKeeper zk;

    public void process(WatchedEvent watchedEvent) {
        if (Event.KeeperState.SyncConnected == watchedEvent.getState()) {
            if (Event.EventType.None == watchedEvent.getType() && watchedEvent.getPath() == null) {
                countDownLatch.countDown();
            }
        }
    }

    public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
        String connection = "192.168.2.192:2181";
        String path = "/zk_book";
        zk = new ZooKeeper(connection, 5000, new ZkDemon4java());
        countDownLatch.await();

        zk.create(path, "hello".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        byte[] get_data = zk.getData(path, null, null);

        Stat set_stat = zk.setData(path, "456".getBytes(), -1);
        System.out.println(set_stat.getCzxid() + "," + set_stat.getMzxid() + "," + set_stat.getVersion());

        Stat set_stat2 = zk.setData(path, "qqq".getBytes(), set_stat.getVersion());
        System.out.println(set_stat2.getCzxid() + "," + set_stat2.getMzxid() + "," + set_stat2.getVersion());

        Stat set_stat3 = zk.setData(path, "aaa".getBytes(), set_stat.getVersion());
        System.out.println(set_stat3.getCzxid() + "," + set_stat3.getMzxid() + "," + set_stat3.getVersion());

        Thread.sleep(Integer.MAX_VALUE);
    }
}

结果：

13,14,1
13,15,2
Exception in thread "main" org.apache.zookeeper.KeeperException$BadVersionException: KeeperErrorCode = BadVersion for /zk_book

Version传入-1表示非原子操作，每次修改数据，版本号就递增，不一致就报错

exists
package com.xh.zk.javaapi;

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;

/**
 * Created by root on 3/28/18.
 */
public class ZkDemon4java implements Watcher {
    private static CountDownLatch countDownLatch = new CountDownLatch(1);
    private static ZooKeeper zk;
    static String path = "/zk_book";

    public void process(WatchedEvent watchedEvent) {
        try {
            if (Event.KeeperState.SyncConnected == watchedEvent.getState()) {
                if (Event.EventType.None == watchedEvent.getType() && watchedEvent.getPath() == null) {
                    countDownLatch.countDown();
                } else if (Event.EventType.NodeCreated == watchedEvent.getType()) {
                    System.out.println(watchedEvent.getPath() + " NodeCreated");
                    zk.exists(path, true);
                } else if (Event.EventType.NodeDataChanged == watchedEvent.getType()) {
                    System.out.println(watchedEvent.getPath() + " NodeDataChanged");
                    zk.exists(path, true);
                } else if (Event.EventType.NodeDeleted == watchedEvent.getType()) {
                    System.out.println(watchedEvent.getPath() + " NodeDeleted");
                    zk.exists(path, true);
                }
            }
        } catch (Exception e) {

        }


    }

    public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
        String connection = "192.168.2.192:2181";
        zk = new ZooKeeper(connection, 5000, new ZkDemon4java());
        countDownLatch.await();

        zk.exists(path, true);

        zk.create(path, "hello".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        zk.create(path + "/abc", "abc".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        zk.setData(path, "world".getBytes(), -1);
        zk.delete(path + "/abc", -1);
        zk.delete(path, -1);
        Thread.sleep(Integer.MAX_VALUE);
    }
}

结果：

/zk_book NodeCreated
/zk_book NodeDataChanged
/zk_book NodeDeleted

无论节点是否存在，都可用exists监听，对该节点增删改都会通知，但是不会通知其子节点的操作

addAuthInfo

创建一个需要权限访问的节点

public class ZkDemon4java implements Watcher {
    private static CountDownLatch countDownLatch = new CountDownLatch(1);
    private static ZooKeeper zk_auth;
    static String path = "/zk_book";

    public void process(WatchedEvent watchedEvent) {
    }

    public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
        String connection = "192.168.2.192:2181";
        zk_auth = new ZooKeeper(connection, 5000, new ZkDemon4java());
        zk_auth.addAuthInfo("digest", "foo:true".getBytes());
        zk_auth.create(path, "hello".getBytes(), ZooDefs.Ids.CREATOR_ALL_ACL, CreateMode.EPHEMERAL);
        Thread.sleep(Integer.MAX_VALUE);
    }
}

创建几个客户端访问之前的节点，分别是 ：没有权限信息，错误权限信息，正确权限信息

        /**
         * no auth info
         */
        zk_1 = new ZooKeeper(connection, 5000, new Zk1());
        zk_1.getData(path, false, null);
        Thread.sleep(Integer.MAX_VALUE);

结果：

Exception in thread "main" org.apache.zookeeper.KeeperException$NoAuthException: KeeperErrorCode = NoAuth for /zk_book
        /**
         * wrong auth info
         */
        zk_2 = new ZooKeeper(connection, 5000, new Zk2());
        zk_2.addAuthInfo("digest", "foo:true121".getBytes());
        zk_2.getData(path, false, null);
        Thread.sleep(Integer.MAX_VALUE);

结果：

Exception in thread "main" org.apache.zookeeper.KeeperException$NoAuthException: KeeperErrorCode = NoAuth for /zk_book
        /**
         * right auth info
         */
        zk_3 = new ZooKeeper(connection, 5000, new Zk3());
        zk_3.addAuthInfo("digest", "foo:true".getBytes());
        byte[] zk_3Data = zk_3.getData(path, false, null);
        System.out.println(zk_3Data);
        Thread.sleep(Integer.MAX_VALUE);

结果：

[B@37bba400

转载于:https://www.cnblogs.com/lanqie/p/8662769.html

weixin_33696822
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Zookeeper学习笔记
03-07
今晚上在上传学习笔记的时候，看了之前发布的文章，突然发现对于我上传的学习笔记是没有展示出来的，所以在这里对笔记进行重新的上传。不知道能不能上传成功！
kafaka 单机安装 及 连通性测试
hzdxw的专栏
06-29 4305
/user/local/kafka_2.9.2-0.8.1.1 KAFKA 单机测试连通性，成功：producer端输入什么内容，cusumer端就显示什么内容。 ok http://czj4451.iteye.com/blog/2041096 http://czj4451.iteye.com/blog/2041096 dataLength = 9 numChildren = 0 [zk: 127.0.0.1:2181(CONNECTED) 13] get /mykey2 myvalue22 cZx
zookeeper之watcher
qq_35689573的博客
03-05 663
客户端可以在节点上注册监听器，当特定的事件发生后，zk会通知感兴趣的客户端。 我们在zkCli.sh客户端输入help命令，可以看到只有stat、ls、ls2、get四个命令可以增加watch事件。 我们想某个路径加监听器，ls path [watch]，watch代表是否添加watch，1代表是的。 下面我们来看一下java源码。 zookeeper版本： &lt;depende...
记录一次程序与zookeeper断开session连接的问题
Eddie-Wang的博客
10-26 8342
在项目开发过程中，需要与zookeeper建立连接，但是在程序运行过程中，遇到了程序与zookeeper断开连接的问题： [2019-10-24 10:02:00.531] [Thread-7-SendThread(10.128.138.178:2181)] WARN org.apache.zookeeper.ClientCnxn - Client session timed out, ha...
启动zookeeper成功但无法查看status状态
ZhouQiYoung的博客
10-07 3735
这两天在研究hadoop，配置环境确实遇到了不少坎，记录一个让我挠破头的问题： 启动zookeeper成功但无法查看status状态 安装zookeeper，配置完各种文件之后 启动集群bin/zkServer.sh start： 然后输入jps查看是否启动成功 字面上告诉我启动成功了，然后兴致勃勃把剩下两个node一起启动，一切都是那么的和谐。 但是当我想查看节点在集群中的状态时却出现了问题。 没有启动成功？首先我相到的是是不是配置文件出了问题，立刻检查配置文件，完全看不出哪里不对劲。 全网查找解决方
zookeeper单机和集群搭建，start正常，无法查看status
codeLearner_CXW的博客
06-14 1292
集群搭建，包括单机启动那块，如果碰到zk的status无法查看，但是start正常启动的情况。 （本机环境 centos7.9 时间2021.06） 1.如果下的是高版本，例如3.6.或3.5之类的，建议用3.4的版本 （链接：https://pan.baidu.com/s/1E6A5rtojWglczjzVhKnc7A 提取码：vouo ） 2.单机启动很有可能无法查看status，只有搭建的了集群环境才能查看，我的就是这样，搞了4，5个小时，网上找了各种方法解决不了（防火墙之类的），搭建了集群之后就可以
zookeeper学习笔记
01-18
zookeeper学习笔记
Zookeeper学习笔记.docx
03-27
Zookeeper学习笔记
Zookeeper学习笔记.pdf
09-10
ZooKeeper是一种为分布式应用所设计的高可用、高性能且一致的开源协调服务，它提供了一项基本服务：**分布式锁服务**。由于ZooKeeper的开源特性，后来我们的开发者在分布式锁的基础上，摸索了出了其他的使用方法：**...
zookeeper学习笔记.pptx
04-16
本文适合但不限于软件开发人员阅读。本文档能够使阅读者对zookeeper有一个宏观且全面的了解，内容主要包含zookeeper架构、数据模型、读写及工作原理、典型应用场景、指令汇总等，
Zookeeper实例原生API--复用sessionId和sessionPasswd
weixin_33701564的博客
01-10 311
2019独角兽企业重金招聘Python工程师标准>>> ...
Zookeeper集群status状态一直失败解决方案
qq_36314579的博客
07-24 4519
Zookeeper集群status状态一直失败解决方案 最近在搭建Zookeeper集群，遇到这个问题头疼了非常久，看了很多网上的教程，还是没能解决相应的问题。最后的最后，终于被我发现了，哎，其实都是自己还不够细心，分享一下，希望有共同问题的朋友可以不用像我一样浪费太多的时间。 简单来说在我每次运行zookeeperd后都会显示启动成功： JMX enabled by default Using config: /data/programfiles/zookeeper-3.4.5/bin/…/conf/zo
启动zookeeper服务不成功，zkServer.sh status查看状态，显示not running。
renzhewudi77的博客
09-28 5202
在搭建hbase-hadoop-zookeeper集群的过程中，zookeeper总是起不来，遇到各种各样的问题，现在列出来做一个总结： 错误1：启动zookeeper服务不成功 用/usr/local/work/zookeeper-3.4.10/bin/zkServer.sh start开启zookeeper服务，显示STARTED，但是用zkServer.sh status查看状态，显示n...
zookeeper集群启动、停止、状态查询
xiaoc100200的博客
11-06 2126
解决Shell zookeeper集群启动、停止、状态查询问题 需要修改（hadoop201 hadoop202 hadoop203）为自己集群的ip或者hostname 需要修改（/opt/module/zookeeper-3.4.14/bin/zkServer.sh）为自己安装zookeeper的路径 需要给脚本赋予可执行权限如（chmod 777 zk） 使用：zk 【star,stop,status】既能实现启动、停止、状态查询 #! /bin/bash case $1 in "start").
zk-04-zookeeper客户端操作
qq_20633779的博客
12-29 3736
1、zkCli客户端操作 1.1 连接服务器 通过sh zkCli.sh命令连接 zookeeper 客户端服务器。 当出现WatchedEvent state:SyncConnected type:None path:null表示成功连接上了zookeeper服务器 [root@k8smaster bin]# pwd /opt/zookeeper-3.5.5/bin [root@k8smaster bin]# sh zkCli.sh ... WatchedEvent state:SyncC...
zookeeper集群管理(2) zookeeper集群在线扩容
新梦易明
10-22 2951
zookeeper是一个分布式(集群)应用程序协调系统，具有分布式以及开源的特性，也是大数据hadoop生态中的一个基础服务，但不去不止用于hadoop系统。本次实验记录zookeeper集群的部署，扩容，缩容，基本操作以及监控，本文档将实验结果记录下来，作为研究档案，供将来差缺补漏。 1. zookeeper集群结构与服务器信息 在前面一节记录 zookeeper集群管理(1) ...
Zookeeper客户端错误：Packet len* is out of range!
wejack的专栏
08-02 1939
这是一个生产环境使用zookeeper异常的情况，错误是。然后就换了一个namespace，就没有在出错，以为是偶然发生，所以没有重视。但是年后居然又出现问题，才意识到严重性。分析之后发现，每隔一段时间，某一个znode节点下超过客户端所设置的大小，客户端连接会失败，zkCli.sh操作该节点也会失败。如果对于简单依赖zookeeper的系统，这种错误可以容忍（但是必须解决）；如果是强依赖zookeeper的系统，这种错误可以说是灾难。...
ZooKeeper 常用命令
Erik_ly的博客
04-23 1242
本文主要介绍 ZooKeeper 的常用命令，包括常用命令行命令、ACL 访问控制、四字命令、解析日志和快照等命令。
zookeeper学习
最新发布
10-10
学习 ZooKeeper 可以帮助你理解分布式系统的原理和实现。 首先，你可以了解 ZooKeeper 的基本概念和架构。ZooKeeper 采用了主从架构，由一个 Leader 和多个 Follower 组成。Leader 负责处理客户端请求，Follower ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值