(6)zookeeper的ACL权限控制机制介绍

最新推荐文章于 2021-04-01 18:04:44 发布

没头脑遇到不高兴

最新推荐文章于 2021-04-01 18:04:44 发布

阅读量2.3k

点赞数 1

分类专栏： ZooKeeper 文章标签： zookeeper的ACL机制介绍 zookeeper的权限控制机制介绍

本文链接：https://blog.csdn.net/u012988901/article/details/83388419

版权

ZooKeeper 专栏收录该内容

8 篇文章 2 订阅

订阅专栏

本节介绍

本节我们将给大家介绍一下什么是ACL，zookeeper中的权限都有哪些，权限是怎么控制的，并且也会写一个demo程序演示java api对于权限具体的使用方式。

ACL概述

首先什么是ACL呢？ACL全称为Access Control List 即访问控制列表，用于控制资源的访问权限。zookeeper利用ACL策略控制节点的访问权限，如节点数据读写、节点创建、节点删除、读取子节点列表、设置节点权限等。

在传统的文件系统中，ACL分为两个维度，一个是属组，一个是权限，一个属组包含多个权限，一个文件或目录拥有某个组的权限即拥有了组里的所有权限，文件或子目录默认会继承自父目录的ACL。而在Zookeeper中，znode的ACL是没有继承关系的，每个znode的权限都是独立控制的，只有客户端满足znode设置的权限要求时，才能完成相应的操作。Zookeeper的ACL，分为三个维度：scheme、id、permission，通常表示为：scheme:id:permission，schema代表授权策略，id代表用户，permission代表权限。下面从这三个维度分别来介绍。

scheme

scheme对应于采用哪种方案来进行权限管理，zookeeper的scheme的分类如下：

world: 它下面只有一个id, 叫anyone, world:anyone代表任何人，zookeeper中对所有人有权限的结点就是属于world:anyone的
auth: 它不需要id, 只要是通过authentication的user都有权限（zookeeper支持通过kerberos来进行authencation, 也支持username/password形式的authentication)
digest:是最常用的权限控制模式，也更符合我们对权限控制的认识，其类似于"username:password"形式的权限标识进行权限配置。它对应的id为username:BASE64(SHA1(password))，即对密码先做SHA1加密然后再进行BASE64摘要。
ip: 它对应的id为客户机的IP地址，设置的时候可以设置一个ip段，比如ip:192.168.1.0/16, 表示匹配前16个bit的IP段，也可以设置为某一个具体的ip
super: 在这种scheme情况下，对应的id拥有超级权限，可以做任何事情(cdrwa)

其实这几种scheme中最常用的也就是world，digest和ip，其他的都很少使用，了解一下就行了。

id

id是验证模式，不同的scheme，id的值也不一样。scheme为ip时，id的值为客户端的ip地址。scheme为world时，id的值为anyone。scheme为digest时，id的值为：username:BASE64(SHA1(password))。

permission

zookeeper目前支持下面一些权限：

CREATE(c): 创建权限，可以在在当前node下创建child node，即对子节点Create操作
DELETE(d): 删除权限，可以删除当前的node，即对子节点Delete操作
READ(r): 读权限，可以获取当前node的数据，可以list当前node所有的child nodes，即对本节点GetChildren和GetData操作
WRITE(w): 写权限，可以向当前node写数据，即对本节点SetData操作
ADMIN(a): 管理权限，可以设置当前node的permission，即对本节点setAcl操作

通过命令行操作ACL

获取ACL

通过zookeeper自带的客户端脚本zkCli.sh连接上zookeeper，我们创建一个节点，然后通过getAcl 命令可以查看节点的ACL信息，我们发现当我们创建节点没有设置ACL的时候，默认使用的是world这种scheme，任何客户端都可以访问。

[zk: localhost:2181(CONNECTED) 2] create /test aaa
Created /test
[zk: localhost:2181(CONNECTED) 3] getAcl /test
'world,'anyone
: cdrwa
[zk: localhost:2181(CONNECTED) 4]

设置digest

然后我们给这个节点添加一个digest权限，设置命令格式为

setAcl /node digest:[username]:[Encrypted password]:[perms]

我们可以看到密码时加密的，前面我们也提到了是先对密码做SHA1加密然后再做Base64，zookeeper的java api中有一个类可以帮助我们做这个加密操作：String str = DigestAuthenticationProvider.generateDigest("wkp:135791"); 这个方法返回的字符串str就会吧冒号后面的密码做加密操作，通过运行得到返回值为"wkp:NrLAZ6FuRnaPGI93r1uPKD67MLw="。我们可以看下这个方法的源码：

然后我们可以给上面创建的/test节点添加一个digest（wkp:135791）的权限

[zk: localhost:2181(CONNECTED) 44] setAcl /test digest:wkp:NrLAZ6FuRnaPGI93r1uPKD67MLw=:cdrwa
cZxid = 0x620000001a
ctime = Wed Oct 31 23:03:51 CST 2018
mZxid = 0x620000001a
mtime = Wed Oct 31 23:03:51 CST 2018
pZxid = 0x620000001a
cversion = 0
dataVersion = 0
aclVersion = 1
ephemeralOwner = 0x0
dataLength = 3
numChildren = 0
[zk: localhost:2181(CONNECTED) 45] getAcl /test
'digest,'wkp:NrLAZ6FuRnaPGI93r1uPKD67MLw=
: cdrwa
[zk: localhost:2181(CONNECTED) 46] create /test/aaa 111
Authentication is not valid : /test/aaa
[zk: localhost:2181(CONNECTED) 50] addauth digest wkp:135791
[zk: localhost:2181(CONNECTED) 51] create /test/aaa 111     
Created /test/aaa
[zk: localhost:2181(CONNECTED) 52]

通过上面的实验，我们可以看到：当我们添加了digest的权限之后，创建节点的时候报错了，然后我们通过权限认证之后才可以再创建节点，digest的认证方式为下面的格式，注意这里的密码为明文

addauth digest [username]:[password plain]

设置ip认证

我们创建一个/ipTest节点并且设置scheme为ip形式，限制连接ip为127.0.0.1，然后我们本机是可以访问的

[zk: localhost:2181(CONNECTED) 1] create /ipTest 111
Created /ipTest
[zk: localhost:2181(CONNECTED) 2] setAcl /ipTest ip:127.0.0.1:crwda
cZxid = 0x620000002a
ctime = Wed Oct 31 23:40:20 CST 2018
mZxid = 0x620000002a
mtime = Wed Oct 31 23:40:20 CST 2018
pZxid = 0x620000002a
cversion = 0
dataVersion = 0
aclVersion = 1
ephemeralOwner = 0x0
dataLength = 3
numChildren = 0
[zk: localhost:2181(CONNECTED) 3] getAcl /ipTest
'ip,'127.0.0.1
: cdrwa
[zk: localhost:2181(CONNECTED) 4] ls /ipTest
[]

下面我们切换到集群的另一台机器上进行操作，发现认证不通过

[zk: localhost:2181(CONNECTED) 0] ls /
[testRoot, dubbo, bhz, test, zookeeper, activemq2, switch, ipTest]
[zk: localhost:2181(CONNECTED) 1] ls /ipTest
Authentication is not valid : /ipTest
[zk: localhost:2181(CONNECTED) 2]

通过java api操作ACL

下面我们写了一个测试类ZookeeperAuth，演示了一下digest类型的权限使用，分别通过不加验证、使用错误的验证、使用正确的验证去操作测试的节点，代码当中的注释已经写得比较详细了，相信大家一定可以看懂的哈。

package com.wkp.test.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;

public class ZookeeperAuth implements Watcher {

	/** 连接地址 */
	final static String CONNECT_ADDR = "192.168.74.4:2181,192.168.74.5:2181,192.168.74.6:2181";
	/** 测试路径 */
	final static String PATH = "/testAuth";
	final static String PATH_DEL = "/testAuth/delNode";
	/** 认证类型 */
	final static String authentication_type = "digest";
	/** 认证正确方法 */
	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连接
	 * 
	 * @param connectString
	 *            ZK服务器地址列表
	 * @param sessionTimeout
	 *            Session超时时间
	 */
	public void createConnection(String connectString, int sessionTimeout) {
		this.releaseConnection();
		try {
			zk = new ZooKeeper(connectString, sessionTimeout, this);
			//添加节点授权
			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) {
			}
		}
	}
	
	public static void main(String[] args) throws Exception {
		
		ZookeeperAuth testAuth = new ZookeeperAuth();
		testAuth.createConnection(CONNECT_ADDR,2000);
		List<ACL> acls = new ArrayList<ACL>(1);
		for (ACL ids_acl : Ids.CREATOR_ALL_ACL) {
			acls.add(ids_acl);
		}
		try {
			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 badzk = new ZooKeeper(CONNECT_ADDR, 2000, null);
			//授权
			badzk.addAuthInfo(authentication_type,badAuthentication.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);
			ZooKeeper nozk = new ZooKeeper(CONNECT_ADDR, 2000, null);
			Thread.sleep(2000);
			System.out.println(prefix + "成功获取数据：" + nozk.getData(PATH, false, null));
		} catch (Exception e) {
			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();
		}
	}

}

运行上面java类的main方法，我们可以在控制台看到下面的关键输出信息。

【Main】开始连接ZK服务器
【Watcher-1】收到Watcher通知
【Watcher-1】连接状态:	SyncConnected
【Watcher-1】事件类型:	None
【Watcher-1】成功连接上ZK服务器
--------------------------------------------
使用授权key：123456创建节点：/testAuth, 初始内容是: init content
使用授权key：123456创建节点：/testAuth/delNode, 初始内容是: init content
[不使用任何授权信息]获取数据：/testAuth
[不使用任何授权信息]获取数据失败，原因：KeeperErrorCode = NoAuth for /testAuth
[使用错误的授权信息]获取数据：/testAuth
[使用正确的授权信息]获取数据：/testAuth
[使用错误的授权信息]获取数据失败，原因：KeeperErrorCode = NoAuth for /testAuth
[使用正确的授权信息]成功获取数据：[B@c77d0d6
[不使用任何授权信息]更新数据： /testAuth
[使用错误的授权信息]更新数据：/testAuth
[不使用任何授权信息]更新失败，原因是：KeeperErrorCode = NoAuth for /testAuth
[使用正确的授权信息]更新数据：/testAuth
[使用错误的授权信息]更新失败，原因是：KeeperErrorCode = NoAuth for /testAuth
[使用正确的授权信息]更新成功
[使用错误的授权信息]删除节点：/testAuth/delNode
[不使用任何授权信息]删除节点：/testAuth/delNode
[使用错误的授权信息]删除失败，原因是：KeeperErrorCode = NoAuth for /testAuth/delNode
[使用正确的授权信息]删除节点：/testAuth/delNode[不使用任何授权信息]删除失败，原因是：KeeperErrorCode = NoAuth for /testAuth/delNode

[使用正确的授权信息]删除成功

可以看到，不适用授权或者使用错误的授权都无法进行操作，会报KeeperErrorCode = NoAuth for XXX的异常。而只有使用正确的授权信息，才可以正常访问操作对应的节点。

关于zookeeper的ACL权限控制就介绍到这里，下节将会介绍一下zookeeper两个第三方客户端：ZKClient和Curator

没头脑遇到不高兴

关注

1
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
(6)zookeeper的ACL权限控制机制介绍

本节介绍本节我们将给大家介绍一下什么是ACL，zookeeper中的权限都有哪些，权限是怎么控制的，并且也会写一个demo程序演示java api对于权限具体的使用方式。ACL概述首先什么是ACL呢？ACL全称为Access Control List 即访问控制列表，用于控制资源的访问权限。zookeeper利用ACL策略控制节点的访问权限，如节点数据读写、节点创建、节点删除、读取子节...
复制链接

扫一扫