//进入conf目录
cd /usr/local/apache-zookeeper-3.6.2/conf
//复制配置文件
cp zoo_sample.cfg zoo.cfg
//zookeeper根目录下新建data目录
mkdir data
//vi 修改配置文件中的dataDir 
//此路径用于存储zookeeper中数据的内存快照、及事务日志文件
dataDir=/usr/local/apache-zookeeper-3.6.2/data

//进入zookeeper的bin目录
cd /usr/local/apache-zookeeper-3.6.2-bin/bin
//启动zookeeper
./zkServer.sh start

//启动:./zkServer.sh start
//停止:./zkServer.sh stop
//查看状态:./zkServer.sh status

连接客户端：
./zkCli.sh

退出会话：
quit

查看节点信息
ls -s /节点名称
get -s path

create [-s] [-e] path data #其中-s为有序节点，-e临时节点

create /hadoop "123456"

//进入zookeeper shell后
create -s /a "aaa"
create -s /b "bbb"
create -s /c "ccc"

create -e /tmp "tmp"

create -e -s /aa "aa"

set /hadoop "345"

每次对节点的修改都会使之版本号+1

也可以基于版本号进行更改，此时类似于乐观锁机制，当你传入的数据版本号(dataVersion)和当前节点的数据版本号不符合时，zookeeper会拒绝本次修改
set -v 版本号 path data

setAcl /test2 ip:192.168.0.1:crwda --将节点权限设置为Ip：192.168.0.1的客户端可以对节点进行增删改查管理权限

echo -n super:admin | openssl dgst -binary -sha1 | openssl base64

nohup $JAVA "-Dzookeeper.log.dir=${ZOO_LOG_DIR}" "-Dzookeeper.root.logger=
${ZOO_LOG$_PROP}"

"-Dzookeeper.DigestAuthenticationProvider.superDigest=super:xQJmxlMiHGwaqBvst5y6rkB6HQs="

nohup $JAVA "-Dzookeeper.log.dir=${ZOO_LOG_DIR}" "-Dzookeeper.root.logger=
${ZOO_LOG$_PROP}" "-Dzookeeper.DigestAuthenticationProvider.superDigest=super:密码密文="\
	-cp "$CLASSPATH" $JVMFLAGS $ZOOMAIN "ZOOCFG" > "$_ZOO_DAEMON_OUT" 2>&! < /dev/null&

addauth digest super:admin #添加认证用户

    public static void main(String[] args) {
        try{
            //计数器对象
            final CountDownLatch countDownLatch = new CountDownLatch(1);
            //param1 服务器的ip和端口
            //param2 客户端和服务器之间的会话超市时间 以毫秒为单位
            //param3 监视器对象
            org.apache.zookeeper.ZooKeeper zooKeeper = new org.apache.zookeeper.ZooKeeper("121.196.108.172:2181", 5000, new Watcher() {
                public void process(WatchedEvent watchedEvent) {
                    if(watchedEvent.getState() == Event.KeeperState.SyncConnected){
                        System.out.println("连接创建成功！");
                        countDownLatch.countDown();
                    }
                }
            });
            //主线程阻塞等待连接对象的创建成功
            countDownLatch.await();
            //打印会话编号
            System.out.println(zooKeeper.getSessionId());
            zooKeeper.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

//同步方法
create(String path,byte[] data,List<ACL> acl,CreateMode createMode)
//异步方法
create(String path,byte[] data,List<ACL> acl,CreateMode createMode,
      AsyncCallback.StringCallback callBack,Object ctx)

//使用连接对象的监视器
exists(String path,boolean b)
//自定义监视器
exists(String path,watcher w)
  
  //NodeCreated:节点创建
  //NodeDeleted:节点删除
  //NodeDataChanged:节点数据发生变化

//使用连接对象的监视器
getData(String path,boolean b ,Stat stat)
//自定义监视器
getData(String path,Wathcher w,Stat stat)  
  
  //NodeDeleted:节点删除
  //NodeDataChanged：节点内容发生变化

//使用连接对象的监视器
getChildren(String path,boolean b)
//自定义监视器
getChildren(String path,Watcher w)
  
  //NodeChildrenChanged:子节点发生变华
  //NodeDeleted:节点删除

cp -r zookeeper zookeeper2181
cp -r zookeeper zookeeper2182
cp -r zookeeper zookeeper2183

#服务器对应端口号
clientPort=2181
#数据快照文件所在路径
dataDir=/home/zookeeper/zookeeper2181/data
#集群配置信息
	#server .A=B:C:D
	#A：是一个数字，表示这个是服务器的编号
	#B：是这个服务器的IP地址
	#：ZooKeeper服务器之间的通信接口
	#D：Leader选举的端口
server .1 =192.168.60.130:2287:3387
server .2 =192.168.60.130:2288:3388
server .3 =192.168.60.130:2289:3389

#zookeeper2181对应的数字是1
#/home/zookeeper/zookeeper2181/data目录下执行命令
echo "1"->myid

peerType=observer

server .3=192.168.60.130:2289:3389:observer

ZooKeeper(String connectionString,int sessionTimeout,Watcher watcher)

 <dependencies>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>4.2.0</version>
        </dependency>
   <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.6.2</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.30</version>
        </dependency>
        <dependency>
            <groupId>jline</groupId>
            <artifactId>jline</artifactId>
            <version>0.9.94</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

package com.xzy.curator;

import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.api.BackgroundCallback;
import org.apache.curator.framework.api.CuratorEvent;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Id;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/**
 * @author xiongziyang
 * @date 2021/1/13 11:37 上午
 * @describe
 */
public class CuratorCreate {

    String IP = "121.196.108.172:2181";
    CuratorFramework client;

    @Before
    public void before() {
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
        client = CuratorFrameworkFactory.builder()
                .connectString(IP)
                .sessionTimeoutMs(5000)
                .retryPolicy(retryPolicy)
                .namespace("create")
                .build();
        client.start();
    }

    @After
    public void after() {
        client.close();
    }

    @Test
    public void create1() throws Exception {
        //新增节点
        client.create()
                //节点的类型
                .withMode(CreateMode.PERSISTENT)
                //节点权限列表
                .withACL(ZooDefs.Ids.OPEN_ACL_UNSAFE)
                //arg1:节点的路径
                //arg2:节点的数据
                .forPath("/node1","node1".getBytes());
        System.out.println("结束");
    }

    @Test
    public void create2() throws Exception {
        //自定义权限列表
        List<ACL> list = new ArrayList<ACL>();
        //授权模式和授权对象
        Id id = new Id("ip","121.196.108.172");
        list.add(new ACL(ZooDefs.Perms.ALL,id));
        client.create()
                .withMode(CreateMode.PERSISTENT)
                .withACL(list)
                .forPath("/node2","node2".getBytes());
        System.out.println("结束");
    }

    @Test
    public void create3() throws Exception {
        //递归创建节点树
        client.create().creatingParentsIfNeeded()
                .withMode(CreateMode.PERSISTENT)
                .withACL(ZooDefs.Ids.OPEN_ACL_UNSAFE)
                .forPath("/node3/node31","node31".getBytes());
        System.out.println("结束");
    }

    @Test
    public void create4() throws Exception {
        //异步方式创建节点
        client.create().creatingParentsIfNeeded()
                .withMode(CreateMode.PERSISTENT)
                .withACL(ZooDefs.Ids.OPEN_ACL_UNSAFE)
                .inBackground(new BackgroundCallback() {
                    @Override
                    public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
                        System.out.println(curatorEvent.getPath());
                        System.out.println(curatorEvent.getType());
                    }
                })
                .forPath("/node4","node4".getBytes());
        Thread.sleep(5000);
        System.out.println("结束");
    }
}

package com.xzy.curator;

import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.api.BackgroundCallback;
import org.apache.curator.framework.api.CuratorEvent;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * @author xiongziyang
 * @date 2021/1/13 4:11 下午
 * @describe
 */
public class CuratorSet {

    String IP = "121.196.108.172:2181";
    CuratorFramework client;

    @Before
    public void before() {
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
        client = CuratorFrameworkFactory.builder()
                .connectString(IP)
                .sessionTimeoutMs(5000)
                .retryPolicy(retryPolicy)
                .namespace("set")
                .build();
        client.start();
    }

    @After
    public void after() {
        client.close();
    }

    @Test
    public void set1() throws Exception {
        //更新节点
        client.setData()
                .forPath("/node1","node11".getBytes());
        System.out.println("结束");
    }

    @Test
    public void set2() throws Exception {
        client.setData().withVersion(-1).forPath("/node1","node1111".getBytes());
        System.out.println("结束");
    }

    @Test
    public void set3() throws Exception {
        //异步方式修改节点
        client.setData().withVersion(-1).inBackground(new BackgroundCallback() {
            @Override
            public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
                System.out.println(curatorEvent.getPath());
                System.out.println(curatorEvent.getType());
            }
        })
                .forPath("/node1","node1".getBytes());
        Thread.sleep(5000);
        System.out.println("结束");
    }
}

package com.xzy.curator;

import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.api.BackgroundCallback;
import org.apache.curator.framework.api.CuratorEvent;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * @author xiongziyang
 * @date 2021/1/13 4:21 下午
 * @describe
 */
public class CuratorDelete {

    String IP = "121.196.108.172:2181";
    CuratorFramework client;

    @Before
    public void before() {
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
        client = CuratorFrameworkFactory.builder()
                .connectString(IP)
                .sessionTimeoutMs(5000)
                .retryPolicy(retryPolicy)
                .namespace("delete")
                .build();
        client.start();
    }

    @After
    public void after() {
        client.close();
    }

    @Test
    public void delete1()throws Exception{
        client.delete()
                .forPath("/node1");
        System.out.println("结束");
    }

    @Test
    public void delete2()throws Exception{
        //删除指定版本号的子节点
        client.delete()
                .withVersion(-1)
                .forPath("/node1");
        System.out.println("结束");
    }

    @Test
    public void delete3()throws Exception{
        //删除带有子节点的节点
        client.delete()
                .deletingChildrenIfNeeded()
                .withVersion(-1)
                .forPath("/node1");
        System.out.println("结束");
    }

    @Test
    public void delete4()throws Exception{
        client.delete()
                .withVersion(-1)
                .inBackground(new BackgroundCallback() {
                    @Override
                    public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
                        System.out.println(curatorEvent.getPath());
                        System.out.println(curatorEvent.getType());
                    }
                }).forPath("node1");

        Thread.sleep(5000);
        System.out.println("结束");
    }
}

package com.xzy.curator;

import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.api.BackgroundCallback;
import org.apache.curator.framework.api.CuratorEvent;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.apache.zookeeper.data.Stat;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * @author xiongziyang
 * @date 2021/1/13 4:27 下午
 * @describe
 */
public class CuratorGet {


    String IP = "121.196.108.172:2181";
    CuratorFramework client;

    @Before
    public void before() {
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
        client = CuratorFrameworkFactory.builder()
                .connectString(IP)
                .sessionTimeoutMs(5000)
                .retryPolicy(retryPolicy)
                .namespace("get")
                .build();
        client.start();
    }

    @After
    public void after() {
        client.close();
    }

    @Test
    public void Get1()throws Exception{
        //读取节点数据
        byte[] bys=client.getData().forPath("/node1");
        System.out.println(new String(bys));
    }

    @Test
    public void Get2()throws Exception{
        //读取数据时读取数据的属性
        Stat stat = new Stat();
        byte[] bys = client.getData().storingStatIn(stat).forPath("/node1");
        System.out.println(new String(bys));
        System.out.println(stat.getAversion());
    }

    @Test
    public void Get3()throws Exception{
        //异步读取数据
        client.getData()
                .inBackground(new BackgroundCallback() {
                    @Override
                    public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
                        System.out.println(curatorEvent.getPath());
                        System.out.println(curatorEvent.getType());
                        System.out.println(new String(curatorEvent.getData()));
                    }
                })
                .forPath("/node1");
        Thread.sleep(5000);
        System.out.println("结束");
    }
}

package com.xzy.curator;

import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.api.BackgroundCallback;
import org.apache.curator.framework.api.CuratorEvent;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.List;

/**
 * @author xiongziyang
 * @date 2021/1/13 4:34 下午
 * @describe
 */
public class CuratorGetChild {
    String IP = "121.196.108.172:2181";
    CuratorFramework client;

    @Before
    public void before() {
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
        client = CuratorFrameworkFactory.builder()
                .connectString(IP)
                .sessionTimeoutMs(5000)
                .retryPolicy(retryPolicy)
                .build();
        client.start();
    }

    @After
    public void after() {
        client.close();
    }

    @Test
    public void getChild1()throws Exception{
        //读取子节点数据
        List<String> list = client.getChildren().forPath("/get");
        for(String s:list){
            System.out.println(s);
        }
    }

    @Test
    public void getChild2()throws Exception{
        //异步
        client.getChildren()
                .inBackground(new BackgroundCallback() {
                    @Override
                    public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
                        System.out.println(curatorEvent.getType());
                        System.out.println(curatorEvent.getPath());
                        List<String> list = curatorEvent.getChildren();
                        System.out.println(list);
                    }
                })
                .forPath("/get");
        Thread.sleep(5000);
        System.out.println("结束");
    }
}

package com.xzy.curator;

import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.api.BackgroundCallback;
import org.apache.curator.framework.api.CuratorEvent;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.apache.zookeeper.data.Stat;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * @author xiongziyang
 * @date 2021/1/13 4:41 下午
 * @describe
 */
public class CuratorExists {

    String IP = "121.196.108.172:2181";
    CuratorFramework client;

    @Before
    public void before() {
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
        client = CuratorFrameworkFactory.builder()
                .connectString(IP)
                .sessionTimeoutMs(5000)
                .retryPolicy(retryPolicy)
                .namespace("get")
                .build();
        client.start();
    }

    @After
    public void after() {
        client.close();
    }

    @Test
    public void exists1()throws Exception{
        //判断节点是否存在
        Stat stat = client.checkExists().forPath("/node1");
        System.out.println(stat);
    }
    @Test
    public void exists2()throws Exception{
        client.checkExists()
                .inBackground(new BackgroundCallback() {
                    @Override
                    public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
                        System.out.println(curatorEvent.getPath());
                        System.out.println(curatorEvent.getType());
                        System.out.println(curatorEvent.getStat());
                    }
                }).forPath("/node2");
        Thread.sleep(5000);
        System.out.println("结束");
    }
}

package com.xzy.curator;

import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.cache.*;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * @author xiongziyang
 * @date 2021/1/13 4:49 下午
 * @describe
 */
public class curatorWatcher {

    String IP = "121.196.108.172:2181";
    CuratorFramework client;

    @Before
    public void before() {
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
        client = CuratorFrameworkFactory.builder()
                .connectString(IP)
                .sessionTimeoutMs(10000)
                .retryPolicy(retryPolicy)
                .build();
        client.start();
    }

    @After
    public void after() {
        client.close();
    }

    @Test
    public void watcher1()throws Exception{
        //监视某个节点的数据变化
        //arg1：连接对象
        //arg2：监视的节点路径
        final NodeCache nodeCache = new NodeCache(client,"/watcher1");
        //启动监听器
        nodeCache.start();
        nodeCache.getListenable().addListener(new NodeCacheListener() {
            @Override
            public void nodeChanged() throws Exception {
                //节点变化时回调的方法
                System.out.println(nodeCache.getCurrentData().getPath());
                System.out.println(new String(nodeCache.getCurrentData().getData()));
            }
        });
        Thread.sleep(10000);
        System.out.println("结束");
        //关闭监视器
        nodeCache.close();
    }

    @Test
    public void watcher2()throws Exception{
        //监视子节点的方法
        final PathChildrenCache pathChildrenCache = new PathChildrenCache(client,"/watcher1",true);
        pathChildrenCache.start();
        pathChildrenCache.getListenable().addListener(new PathChildrenCacheListener() {
            //当子节点发生变化时回调的方法
            @Override
            public void childEvent(CuratorFramework curatorFramework, PathChildrenCacheEvent pathChildrenCacheEvent) throws Exception {
                //节点的时间类型
                System.out.println(pathChildrenCacheEvent.getType());

                System.out.println(pathChildrenCacheEvent.getData().getPath());

                System.out.println(new String(pathChildrenCacheEvent.getData().getData()));
            }
        });
        Thread.sleep(10000);
        System.out.println("结束");
        pathChildrenCache.close();
    }
}

package com.xzy.curator;

import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * @author xiongziyang
 * @date 2021/1/13 5:15 下午
 * @describe
 */
public class CuratorTransaction {
    String IP = "121.196.108.172:2181";
    CuratorFramework client;

    @Before
    public void before() {
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
        client = CuratorFrameworkFactory.builder()
                .connectString(IP)
                .sessionTimeoutMs(10000)
                .retryPolicy(retryPolicy)
                .namespace("create")
                .build();
        client.start();
    }

    @After
    public void after() {
        client.close();
    }

    @Test
    public void tra1() throws Exception {
        client.inTransaction()
                .create().forPath("/node1","node111".getBytes())
                .and()
                .setData().forPath("/node2","node222".getBytes())
                .and().commit();
    }
}

package com.xzy.curator;

import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessLock;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.framework.recipes.locks.InterProcessReadWriteLock;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * @author xiongziyang
 * @date 2021/1/13 5:25 下午
 * @describe
 */
public class CuratorLock {

    String IP = "121.196.108.172:2181";
    CuratorFramework client;

    @Before
    public void before() {
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
        client = CuratorFrameworkFactory.builder()
                .connectString(IP)
                .sessionTimeoutMs(5000)
                .retryPolicy(retryPolicy)
                .build();
        client.start();
    }

    @After
    public void after() {
        client.close();
    }

    @Test
    public void lock1()throws Exception{
        //排它锁
        //arg1:连接对象
        //arg2:节点路径
        InterProcessLock lock = new InterProcessMutex(client,"/lock1");
        System.out.println("等待获取锁对象");
        //获取锁
        lock.acquire();

        for(int i = 1;i<=5;i++){
            Thread.sleep(3000);
            System.out.println(i);
        }

        //释放锁
        lock.release();
        System.out.println("等待释放锁");
    }

    @Test
    public void lock2()throws Exception{
        //读写锁
        InterProcessReadWriteLock lock = new InterProcessReadWriteLock(client,"/lock1");
        //获取读锁对象
        InterProcessLock interProcessLock = lock.readLock();
        System.out.println("等待获取锁对象");
        interProcessLock.acquire();
        for(int i = 1;i<=5;i++){
            Thread.sleep(3000);
            System.out.println(i);
        }
        interProcessLock.release();
        System.out.println("等待释放锁对象");
    }

    @Test
    public void lock3()throws Exception{
//读写锁
        InterProcessReadWriteLock lock = new InterProcessReadWriteLock(client,"/lock1");
        //获取写锁对象
        InterProcessLock interProcessLock = lock.writeLock();
        System.out.println("等待获取锁对象");
        interProcessLock.acquire();
        for(int i = 1;i<=5;i++){
            Thread.sleep(3000);
            System.out.println(i);
        }
        interProcessLock.release();
        System.out.println("等待释放锁对象");
    }
}

#root用户安装
#下载安装包
wget http://vault.centos.org/6.6/os/x86_64/Packages/nc-1.84-22.el.x86_64.rpm
#rpm安装
rpm -iUv nc-1.84-22.el6.x86_64.rpm

#现在服务器上登陆
telnet 121.196.108.172 2181
#登陆后使用对应的四字命令

#服务器中输入
echo cons|nc 121.196.108.172 2181