Zookeeper_安全认证讲解

比如ACL的认证

ACL的全称就是Access Control List,这个认证它是做什么事呢,你想修改这个节点,你可以加一个认证操作,认证一般有

这4种模式,IP模式,digest模式,world模式,super模式,其实没有太大的用,相当于别的客户端访问我zookeeper服务器的

时候,得有一个认证,才能允许你修改节点,要不然就不让你去修改,你自己有兴趣可以去看一看,咱们其实去运行一下

DEMO就行了

 

package com.learn.zookeeper.auth;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Stat;

/**
 * 
 * @author Leon.Sun
 *
 */
public class ZookeeperAuth implements Watcher {

	/** 连接地址 */
	final static String CONNECT_ADDR = "localhost:2181";
	/** 测试路径 */
	/**
	 * 这里有一个testAuth的路径
	 */
	final static String PATH = "/testAuth";
	/**
	 * 就是有两个路径
	 * 一个是父节点parent
	 * 还有一个是子节点delNode
	 * 
	 */
	final static String PATH_DEL = "/testAuth/delNode";
	/** 认证类型 */
	/**
	 * 认证类型就是用digest
	 * 这种类型也是最常用的
	 * 控制权限
	 * 首先把你这个认证进行两次的处理
	 * 第一次使用SHA-1
	 * 加密算法去加密
	 * BASE64编码
	 * 
	 */
	final static String authentication_type = "digest";
	/** 认证正确方法 */
	/**
	 * 第一次去连的时候需要输入一个字符串
	 * 以后机器连的时候必须使用一样的字符串才能修改
	 * 如果你想输入错误的不允许修改
	 * 其实就是一个非常easy的事
	 * 是从网上copy的一段代码
	 * 这不是我写的
	 * 但是这么做已经足够了
	 * 
	 */
	final static String correctAuthentication = "123456";
	/** 认证错误方法 */
	final static String badAuthentication = "654321";
	
	static ZooKeeper zk = null;
	/** 计时器 */
	AtomicInteger seq = new AtomicInteger();
	/** 标识 */
	private static final String LOG_PREFIX_OF_MAIN = "【Main】";
	
	private CountDownLatch connectedSemaphore = new CountDownLatch(1);
	
	@Override
	public void process(WatchedEvent event) {
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		if (event==null) {
			return;
		}
		// 连接状态
		KeeperState keeperState = event.getState();
		// 事件类型
		EventType eventType = event.getType();
		// 受影响的path
		String path = event.getPath();
		
		String logPrefix = "【Watcher-" + this.seq.incrementAndGet() + "】";

		System.out.println(logPrefix + "收到Watcher通知");
		System.out.println(logPrefix + "连接状态:\t" + keeperState.toString());
		System.out.println(logPrefix + "事件类型:\t" + eventType.toString());
		if (KeeperState.SyncConnected == keeperState) {
			// 成功连接上ZK服务器
			if (EventType.None == eventType) {
				System.out.println(logPrefix + "成功连接上ZK服务器");
				connectedSemaphore.countDown();
			} 
		} else if (KeeperState.Disconnected == keeperState) {
			System.out.println(logPrefix + "与ZK服务器断开连接");
		} else if (KeeperState.AuthFailed == keeperState) {
			System.out.println(logPrefix + "权限检查失败");
		} else if (KeeperState.Expired == keeperState) {
			System.out.println(logPrefix + "会话失效");
		}
		System.out.println("--------------------------------------------");
	}
	/**
	 * 创建ZK连接
	 * 
	 * createConnection的时候
	 * 第一次创建连接的时候
	 * 
	 * 
	 * @param connectString
	 *            ZK服务器地址列表
	 * @param sessionTimeout
	 *            Session超时时间
	 */
	public void createConnection(String connectString, int sessionTimeout) {
		this.releaseConnection();
		try {
			/**
			 * zookeeper加的东西是啥
			 * 肯定是this
			 * 就是一个Watcher
			 * 加了一个Watcher
			 * 
			 * 
			 */
			zk = new ZooKeeper(connectString, sessionTimeout, this);
			//添加节点授权
			/**
			 * 就是多了一个这个方法
			 * 这是zookeeper原生带的一个方法
			 * 就是提供认证
			 * 就是你第一次连接zookeeper的时候
			 * 你得加一个认证
			 * 认证的type就是上面的digest
			 * 这个字符串是固定的
			 * 当然你也可以用其他的
			 * 一般这种方式是最常用的
			 * 把这句话写到了这一行了
			 * 第一次连接的时候加上这个字符串
			 * authentication_type这个相当于一个key了
			 * correctAuthentication.getBytes()这个是value
			 * 这个value是自己随便写的
			 * 我这写的是123456
			 * 也就是我以后再连接zookeeper的时候
			 * 就是对这个节点进行增删改查的时候
			 * 我只能是加上这个认证才能去修改
			 * 要不然是不能去修改的
			 * 没有认证是不好使的
			 * 说白了就是这么一个简单的东西
			 * 其他的方式其实也都差不多
			 * 通过IP指定一台机器
			 * 只能这一台机器进行修改
			 * 其他机器是不允许修改
			 * 就是之前说的IP的模式
			 * 还有是world的模式
			 * 这个是开放的
			 * 这是一种特殊的digest
			 * 他仅仅是一个标识而已
			 * 还有一种是super
			 * 超级用户模式
			 * 基本上最常用的也就是这个了
			 * IP就是指定了一台机器
			 * 或者是按网段进行分配
			 * 192.168.1.*
			 * 简单的说完这些事情
			 * 咱们看一下吧
			 * 连完zookeeper以后
			 * 创建完connection之后
			 * 
			 * 自己定义的时候要加一个认证
			 * key是不变的
			 * value就相当于你的密码一样的
			 * 你可以自己随便定义一个很复杂的密码
			 * zk这个对象创建所有的节点
			 * 由于zk加认证创建的节点
			 * 
			 */
			zk.addAuthInfo(authentication_type,correctAuthentication.getBytes());
			System.out.println(LOG_PREFIX_OF_MAIN + "开始连接ZK服务器");
			//倒数等待
			connectedSemaphore.await();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 关闭ZK连接
	 */
	public void releaseConnection() {
		if (this.zk!=null) {
			try {
				this.zk.close();
			} catch (InterruptedException e) {
			}
		}
	}
	
	/**
	 * 
	 * 方法名称：测试函数

	 * 概要说明：测试认证

	 * @param args
	 * @throws Exception
	 */
	public static void main(String[] args) throws Exception {
		
		ZookeeperAuth testAuth = new ZookeeperAuth();
		testAuth.createConnection(CONNECT_ADDR,2000);
		List acls = new ArrayList(1);
		for (ACL ids_acl : Ids.CREATOR_ALL_ACL) {
			acls.add(ids_acl);
		}

		try {
			/**
			 * 就是创建的时候要加上acls认证
			 * 
			 * 这个认证是zookeeper给你提供的
			 * for循环加到list里就行了
			 * 你加上这个认证以后
			 * 那这个节点需要认证才能去删除
			 * 我这边连zookeeper是可以连上
			 * 我可以连上zookeeper
			 * 我要修改你刚创建的path节点
			 * 你要有一个认证才行
			 * 没有认证是不行的
			 * 要理解这个事情
			 * create(String path, byte[] data, List acl, CreateMode createMode) 
			 * create的时候要传一个list
			 * 或者你穿其他的也行
			 * 创建节点的时候需要指定一种方式
			 * 你千万要注意一点
			 * 你创建一个节点的是有认证的
			 * 我再创建一个新的节点
			 * 这个认证只是针对于这一个节点
			 * 我的zookeeper只要操作一个新的节点
			 * 我是可以不加任何认证的
			 * 那个认证只是针对于某一个节点
			 * 要明白这个事情
			 */
			zk.create(PATH, "init content".getBytes(), acls, CreateMode.PERSISTENT);
			System.out.println("使用授权key：" + correctAuthentication + "创建节点："+ PATH + ", 初始内容是: init content");
		} catch (Exception e) {
			e.printStackTrace();
		}
		try {
			zk.create(PATH_DEL, "will be deleted! ".getBytes(), acls, CreateMode.PERSISTENT);
			System.out.println("使用授权key：" + correctAuthentication + "创建节点："+ PATH_DEL + ", 初始内容是: init content");
		} catch (Exception e) {
			e.printStackTrace();
		}

		// 获取数据
		getDataByNoAuthentication();
		getDataByBadAuthentication();
		getDataByCorrectAuthentication();

		// 更新数据
		updateDataByNoAuthentication();
		updateDataByBadAuthentication();
		updateDataByCorrectAuthentication();

		// 删除数据
		deleteNodeByBadAuthentication();
		deleteNodeByNoAuthentication();
		deleteNodeByCorrectAuthentication();
		//
		Thread.sleep(1000);
		
		deleteParent();
		//释放连接
		testAuth.releaseConnection();
	}
	
	/** 获取数据：采用错误的密码 */
	/**
	 * 使用错的
	 * 错误的是什么意思
	 * 
	 */
	static void getDataByBadAuthentication() {
		String prefix = "[使用错误的授权信息]";
		try {
			/**
			 * 我连zookeeper的时候用认证
			 * 但是认证不对啊
			 * 我加了一个认证
			 * 但是是一个错误的认证
			 */
			ZooKeeper badzk = new ZooKeeper(CONNECT_ADDR, 2000, null);
			//授权
			/**
			 * 我加的是一个bad的认证badAuthentication
			 * 上面写的是什么
			 * 正确的是123456
			 * 我写的是654321
			 * 这个时候如果你认证写654321的时候
			 * 那就不行了
			 * 就认证失败了
			 * 打印的就是认证失败
			 * [使用错误的授权信息]更新失败，原因是：KeeperErrorCode = ConnectionLoss for /testAuth
			 * 使用的是error
			 * 为什么啊
			 * 如果这个改成正确的呢
			 * badAuthentication
			 * 不就是123456吗
			 * 
			 */
			badzk.addAuthInfo(authentication_type,badAuthentication.getBytes());
//			badzk.addAuthInfo(authentication_type,"123456".getBytes());
			Thread.sleep(2000);
			System.out.println(prefix + "获取数据：" + PATH);
			System.out.println(prefix + "成功获取数据：" + badzk.getData(PATH, false, null));
		} catch (Exception e) {
			System.err.println(prefix + "获取数据失败，原因：" + e.getMessage());
		}
	}

	/** 获取数据：不采用密码 */
	/**
	 * 没有认证的情况
	 * 
	 */
	static void getDataByNoAuthentication() {
		String prefix = "[不使用任何授权信息]";
		try {
			System.out.println(prefix + "获取数据：" + PATH);
			/**
			 * 直接new一个ZooKeeper去连接
			 * 拿到这个nozk去get
			 * 
			 */
			ZooKeeper nozk = new ZooKeeper(CONNECT_ADDR, 2000, null);
			Thread.sleep(2000);
			/**
			 * 这个是不允许的
			 * 
			 */
			System.out.println(prefix + "成功获取数据：" + nozk.getData(PATH, false, null));
		} catch (Exception e) {
			/**
			 * 会产生一个失败的信息
			 * 就是会打印error这句话
			 * 
			 */
			System.err.println(prefix + "获取数据失败，原因：" + e.getMessage());
		}
	}

	/** 采用正确的密码 */
	/**
	 * 只有正确的方式
	 * 它是可以去获取的
	 * 
	 */
	static void getDataByCorrectAuthentication() {
		String prefix = "[使用正确的授权信息]";
		try {
			System.out.println(prefix + "获取数据：" + PATH);
			
			System.out.println(prefix + "成功获取数据：" + zk.getData(PATH, false, null));
		} catch (Exception e) {
			System.out.println(prefix + "获取数据失败，原因：" + e.getMessage());
		}
	}

	/**
	 * 更新数据：不采用密码
	 */
	static void updateDataByNoAuthentication() {

		String prefix = "[不使用任何授权信息]";

		System.out.println(prefix + "更新数据： " + PATH);
		try {
			ZooKeeper nozk = new ZooKeeper(CONNECT_ADDR, 2000, null);
			Thread.sleep(2000);
			Stat stat = nozk.exists(PATH, false);
			if (stat!=null) {
				nozk.setData(PATH, prefix.getBytes(), -1);
				System.out.println(prefix + "更新成功");
			}
		} catch (Exception e) {
			System.err.println(prefix + "更新失败，原因是：" + e.getMessage());
		}
	}

	/**
	 * 更新数据：采用错误的密码
	 */
	static void updateDataByBadAuthentication() {

		String prefix = "[使用错误的授权信息]";

		System.out.println(prefix + "更新数据：" + PATH);
		try {
			ZooKeeper badzk = new ZooKeeper(CONNECT_ADDR, 2000, null);
			//授权
			badzk.addAuthInfo(authentication_type,badAuthentication.getBytes());
			Thread.sleep(2000);
			Stat stat = badzk.exists(PATH, false);
			if (stat!=null) {
				badzk.setData(PATH, prefix.getBytes(), -1);
				System.out.println(prefix + "更新成功");
			}
		} catch (Exception e) {
			System.err.println(prefix + "更新失败，原因是：" + e.getMessage());
		}
	}

	/**
	 * 更新数据：采用正确的密码
	 */
	static void updateDataByCorrectAuthentication() {

		String prefix = "[使用正确的授权信息]";

		System.out.println(prefix + "更新数据：" + PATH);
		try {
			Stat stat = zk.exists(PATH, false);
			if (stat!=null) {
				zk.setData(PATH, prefix.getBytes(), -1);
				System.out.println(prefix + "更新成功");
			}
		} catch (Exception e) {
			System.err.println(prefix + "更新失败，原因是：" + e.getMessage());
		}
	}

	/**
	 * 不使用密码 删除节点
	 */
	static void deleteNodeByNoAuthentication() throws Exception {

		String prefix = "[不使用任何授权信息]";

		try {
			System.out.println(prefix + "删除节点：" + PATH_DEL);
			ZooKeeper nozk = new ZooKeeper(CONNECT_ADDR, 2000, null);
			Thread.sleep(2000);
			Stat stat = nozk.exists(PATH_DEL, false);
			if (stat!=null) {
				nozk.delete(PATH_DEL,-1);
				System.out.println(prefix + "删除成功");
			}
		} catch (Exception e) {
			System.err.println(prefix + "删除失败，原因是：" + e.getMessage());
		}
	}

	/**
	 * 采用错误的密码删除节点
	 */
	static void deleteNodeByBadAuthentication() throws Exception {

		String prefix = "[使用错误的授权信息]";

		try {
			System.out.println(prefix + "删除节点：" + PATH_DEL);
			ZooKeeper badzk = new ZooKeeper(CONNECT_ADDR, 2000, null);
			//授权
			badzk.addAuthInfo(authentication_type,badAuthentication.getBytes());
			Thread.sleep(2000);
			Stat stat = badzk.exists(PATH_DEL, false);
			if (stat!=null) {
				badzk.delete(PATH_DEL, -1);
				System.out.println(prefix + "删除成功");
			}
		} catch (Exception e) {
			System.err.println(prefix + "删除失败，原因是：" + e.getMessage());
		}
	}

	/**
	 * 使用正确的密码删除节点
	 */
	static void deleteNodeByCorrectAuthentication() throws Exception {

		String prefix = "[使用正确的授权信息]";

		try {
			System.out.println(prefix + "删除节点：" + PATH_DEL);
			Stat stat = zk.exists(PATH_DEL, false);
			if (stat!=null) {
				zk.delete(PATH_DEL, -1);
				System.out.println(prefix + "删除成功");
			}
		} catch (Exception e) {
			System.out.println(prefix + "删除失败，原因是：" + e.getMessage());
		}
	}

	/**
	 * 使用正确的密码删除节点
	 */
	static void deleteParent() throws Exception {
		try {
			Stat stat = zk.exists(PATH_DEL, false);
			if (stat == null) {
				zk.delete(PATH, -1);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}