大数据 Ranger2.1.0 适配 Kafka3.4.0

已于 2023-06-01 17:07:13 修改
阅读量1k 收藏
点赞数
分类专栏： 大数据 ambari 文章标签： kafka java 大数据 ranger
于 2023-05-30 15:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40375601/article/details/130922389
版权

Ranger2.1.0 适配 Kafka3.4.0

根据官方说明Kafka3.0以上版本将会被替换权限认证方式，包括 类和方法 的变换，所以需要对ranger中继承 kafka 的实现中，修改相应的逻辑

官方说明

Kafka3.0以上版本将会被替换权限认证方式，包括 类和方法 的变换，

Github PR https://github.com/apache/kafka/pull/10450

在这里插入图片描述

POM

apache-ranger\pom.xml，该文件中主要涉及 kafka 的版本及 scala 的版本

<?xml version="1.0" encoding="UTF-8"?>
<project>
...
    <properties>
        ...
        <kafka.version>3.4.0</kafka.version>
        ...
        <scala.version>2.12.10</scala.version>
        <scala.binary.version>2.12</scala.binary.version>
        ...
    </properties>

</project>

apache-ranger\plugin-schema-registry\pom.xml，该文件中主要涉及 kafka 的版本及 scala 的版本

<?xml version="1.0" encoding="UTF-8"?>
<project>
...
    <properties>
        ...
        <kafka.version>3.4.0</kafka.version>
        <kafkaArtifact>kafka_2.12</kafkaArtifact>
        ...
    </properties>
</project>

代码

apache-ranger\plugin-kafka\src\main\java\org\apache\ranger\authorization\kafka\authorizer\RangerKafkaAuthorizer.java

这个类中是主要涉及的位置，包括类、方法等，所以相等于对原有逻辑适配于 kafka 的重构，主要修改包括认证方法 authorize，
判断操作及资源类型等。

说明：
Kaka中 Authorizer 的共有一种子接口（ClusterMetadataAuthorizer）和二种子类（AclAuthorizer 和 StandardAuthorizer），这两个子类是具体实现了方法的功能，由 官网提示 从原来的kafka低版本（3.0以下）使用 SimpleAclAuthorizer 替换成现在的kafka高版本（3.0以上）使用 AclAuthorizer ，所以继承改类，从而实现 Ranger2.1.0 适配 Kafka3.4.0

...

package org.apache.ranger.authorization.kafka.authorizer;

import java.util.*;
import java.util.concurrent.CompletionStage;

import com.google.gson.Gson;
import kafka.security.authorizer.AclAuthorizer;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.kafka.common.config.SaslConfigs;
import org.apache.kafka.common.network.ListenerName;
import org.apache.kafka.common.security.JaasContext;
import org.apache.kafka.common.security.auth.SecurityProtocol;
import org.apache.kafka.server.authorizer.*;
import org.apache.kafka.common.acl.*;
import org.apache.kafka.common.resource.*;

import org.apache.commons.lang.StringUtils;
import org.apache.ranger.audit.provider.MiscUtil;
import org.apache.ranger.plugin.policyengine.RangerAccessRequestImpl;
import org.apache.ranger.plugin.policyengine.RangerAccessResourceImpl;
import org.apache.ranger.plugin.policyengine.RangerAccessResult;
import org.apache.ranger.plugin.service.RangerBasePlugin;

import org.apache.ranger.plugin.util.RangerPerfTracer;

public class RangerKafkaAuthorizer extends AclAuthorizer {
	private static final Log logger = LogFactory
			.getLog(RangerKafkaAuthorizer.class);
	private static final Log PERF_KAFKAAUTH_REQUEST_LOG = RangerPerfTracer.getPerfLogger("kafkaauth.request");

	public static final String KEY_TOPIC = "topic";
	public static final String KEY_CLUSTER = "cluster";
	public static final String KEY_CONSUMER_GROUP = "consumergroup";
	public static final String KEY_TRANSACTIONALID = "transactionalid";
	public static final String KEY_DELEGATIONTOKEN = "delegationtoken";

	public static final String ACCESS_TYPE_READ = "consume";
	public static final String ACCESS_TYPE_WRITE = "publish";
	public static final String ACCESS_TYPE_CREATE = "create";
	public static final String ACCESS_TYPE_DELETE = "delete";
	public static final String ACCESS_TYPE_CONFIGURE = "configure";
	public static final String ACCESS_TYPE_DESCRIBE = "describe";
	public static final String ACCESS_TYPE_DESCRIBE_CONFIGS = "describe_configs";
	public static final String ACCESS_TYPE_ALTER_CONFIGS    = "alter_configs";
	public static final String ACCESS_TYPE_IDEMPOTENT_WRITE = "idempotent_write";
	public static final String ACCESS_TYPE_CLUSTER_ACTION   = "cluster_action";

	private static volatile RangerBasePlugin rangerPlugin = null;
	RangerKafkaAuditHandler auditHandler = null;

	public RangerKafkaAuthorizer() {
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see kafka.security.auth.Authorizer#configure(Map<String, Object>)
	 */
	@Override
	public void configure(Map<String, ?> configs) {
		RangerBasePlugin me = rangerPlugin;
		if (me == null) {
			synchronized(RangerKafkaAuthorizer.class) {
				me = rangerPlugin;
				if (me == null) {
					try {
						// Possible to override JAAS configuration which is used by Ranger, otherwise
						// SASL_PLAINTEXT is used, which force Kafka to use 'sasl_plaintext.KafkaServer',
						// if it's not defined, then it reverts to 'KafkaServer' configuration.
						final Object jaasContext = configs.get("ranger.jaas.context");
						final String listenerName = (jaasContext instanceof String
										&& StringUtils.isNotEmpty((String) jaasContext)) ? (String) jaasContext
										: SecurityProtocol.SASL_PLAINTEXT.name();
						final String saslMechanism = SaslConfigs.GSSAPI_MECHANISM;
						JaasContext context = JaasContext.loadServerContext(new ListenerName(listenerName), saslMechanism, configs);
						MiscUtil.setUGIFromJAASConfig(context.name());
						logger.info("LoginUser=" + MiscUtil.getUGILoginUser());
					} catch (Throwable t) {
						logger.error("Error getting principal.", t);
					}
					me = rangerPlugin = new RangerBasePlugin("kafka", "kafka");
				}
			}
		}
		logger.info("Calling plugin.init()");
		rangerPlugin.init();
		auditHandler = new RangerKafkaAuditHandler();
		rangerPlugin.setResultProcessor(auditHandler);
	}

	@Override
	public void close() {
		logger.info("close() called on authorizer.");
		try {
			if (rangerPlugin != null) {
				rangerPlugin.cleanup();
			}
		} catch (Throwable t) {
			logger.error("Error closing RangerPlugin.", t);
		}
	}

	@Override
	public List<AuthorizationResult> authorize(AuthorizableRequestContext authorizableRequestContext, List<Action> list) {

		List<AuthorizationResult> authResults = new ArrayList<>();
		AuthorizableRequestContext session = authorizableRequestContext;

		Gson gson = new Gson();
		logger.info("List<Action> list -> " + gson.toJson(list));
		for (Action actionData : list) {
			ResourcePattern resource = actionData.resourcePattern();
			AclOperation operation = actionData.operation();
			if (rangerPlugin == null) {
				MiscUtil.logErrorMessageByInterval(logger,
						"Authorizer is still not initialized");
				return new ArrayList<>();
			}

			RangerPerfTracer perf = null;

			if (RangerPerfTracer.isPerfTraceEnabled(PERF_KAFKAAUTH_REQUEST_LOG)) {
				perf = RangerPerfTracer.getPerfTracer(PERF_KAFKAAUTH_REQUEST_LOG, "RangerKafkaAuthorizer.authorize(resource=" + resource + ")");
			}
			String userName = null;
			if (session.principal() != null) {
				userName = session.principal().getName();
			}
			java.util.Set<String> userGroups = MiscUtil
					.getGroupsForRequestUser(userName);
			String ip = session.clientAddress().getHostAddress();

			// skip leading slash
			if (StringUtils.isNotEmpty(ip) && ip.charAt(0) == '/') {
				ip = ip.substring(1);
			}

			Date eventTime = new Date();
			String accessType = mapToRangerAccessType(operation);
			boolean validationFailed = false;
			String validationStr = "";

			if (accessType == null) {
				if (MiscUtil.logErrorMessageByInterval(logger,
						"Unsupported access type. operation=" + operation)) {
					logger.error("Unsupported access type. session=" + session
							+ ", operation=" + operation + ", resource=" + resource);
				}
				validationFailed = true;
				validationStr += "Unsupported access type. operation=" + operation;
			}
			String action = accessType;

			RangerAccessRequestImpl rangerRequest = new RangerAccessRequestImpl();
			rangerRequest.setUser(userName);
			rangerRequest.setUserGroups(userGroups);
			rangerRequest.setClientIPAddress(ip);
			rangerRequest.setAccessTime(eventTime);

			RangerAccessResourceImpl rangerResource = new RangerAccessResourceImpl();
			rangerRequest.setResource(rangerResource);
			rangerRequest.setAccessType(accessType);
			rangerRequest.setAction(action);
			rangerRequest.setRequestData(resource.name());

			if (resource.resourceType().equals(ResourceType.TOPIC)) {
				rangerResource.setValue(KEY_TOPIC, resource.name());
			} else if (resource.resourceType().equals(ResourceType.CLUSTER)) {
				rangerResource.setValue(KEY_CLUSTER, resource.name());
			} else if (resource.resourceType().equals(ResourceType.GROUP)) {
				rangerResource.setValue(KEY_CONSUMER_GROUP, resource.name());
			} else if (resource.resourceType().equals(ResourceType.TRANSACTIONAL_ID)) {
				rangerResource.setValue(KEY_TRANSACTIONALID, resource.name());
			} else if (resource.resourceType().equals(ResourceType.DELEGATION_TOKEN)) {
				rangerResource.setValue(KEY_DELEGATIONTOKEN, resource.name());
			} else {
				logger.error("Unsupported resourceType=" + resource.resourceType());
				validationFailed = true;
			}

			AuthorizationResult authResult = AuthorizationResult.DENIED;
			boolean returnValue = false;
			if (validationFailed) {
				MiscUtil.logErrorMessageByInterval(logger, validationStr
						+ ", request=" + rangerRequest);
			} else {

				try {
					RangerAccessResult result = rangerPlugin
							.isAccessAllowed(rangerRequest);
					if (result == null) {
						logger.error("Ranger Plugin returned null. Returning false");
					} else {
						returnValue = result.getIsAllowed();
						authResult = returnValue ? AuthorizationResult.ALLOWED : authResult;
					}
				} catch (Throwable t) {
					logger.error("Error while calling isAccessAllowed(). request="
							+ rangerRequest, t);
				} finally {
					auditHandler.flushAudit();
				}
			}
			RangerPerfTracer.log(perf);

			if (logger.isDebugEnabled()) {
				logger.debug("rangerRequest=" + rangerRequest + ", return="
							+ returnValue);
			}

			authResults.add(authResult);
		}

		logger.info("end authorize");
		return authResults;
	}

	@Override
	public List<? extends CompletionStage<AclCreateResult>> createAcls(AuthorizableRequestContext authorizableRequestContext, List<AclBinding> list) {
		logger.error("createAcls(AuthorizableRequestContext, List<AclBinding>) is not supported by Ranger for Kafka");
		return new ArrayList<>();
	}

	@Override
	public List<? extends CompletionStage<AclDeleteResult>> deleteAcls(AuthorizableRequestContext authorizableRequestContext, List<AclBindingFilter> list) {
		logger.error("deleteAcls(AuthorizableRequestContext, List<AclBindingFilter>) is not supported by Ranger for Kafka");
		return new ArrayList<>();
	}

	@Override
	public Iterable<AclBinding> acls(AclBindingFilter filter) {
		logger.error("getAcls(AclBindingFilter) is not supported by Ranger for Kafka");
		return new ArrayList<>();
	}

	/**
	 * @param operation
	 * @return
	 */
	private String mapToRangerAccessType(AclOperation operation) {
		if (operation.equals(AclOperation.READ)) {
			return ACCESS_TYPE_READ;
		} else if (operation.equals(AclOperation.WRITE)) {
			return ACCESS_TYPE_WRITE;
		} else if (operation.equals(AclOperation.ALTER)) {
			return ACCESS_TYPE_CONFIGURE;
		} else if (operation.equals(AclOperation.DESCRIBE)) {
			return ACCESS_TYPE_DESCRIBE;
		} else if (operation.equals(AclOperation.CLUSTER_ACTION)) {
			return ACCESS_TYPE_CLUSTER_ACTION;
		} else if (operation.equals(AclOperation.CREATE)) {
			return ACCESS_TYPE_CREATE;
		} else if (operation.equals(AclOperation.DELETE)) {
			return ACCESS_TYPE_DELETE;
		} else if (operation.equals(AclOperation.DESCRIBE_CONFIGS)) {
			return ACCESS_TYPE_DESCRIBE_CONFIGS;
		} else if (operation.equals(AclOperation.ALTER_CONFIGS)) {
			return ACCESS_TYPE_ALTER_CONFIGS;
		} else if (operation.equals(AclOperation.IDEMPOTENT_WRITE)) {
			return ACCESS_TYPE_IDEMPOTENT_WRITE;
		}
		return null;
	}

	@Override
	public AuthorizationResult authorizeByResourceType(AuthorizableRequestContext requestContext, AclOperation op, ResourceType resourceType) {
		return super.authorizeByResourceType(requestContext, op, resourceType);
	}
}

apache-ranger\ranger-kafka-plugin-shim\src\main\java\org\apache\ranger\authorization\kafka\authorizer\RangerKafkaAuthorizer.java

这个类没有什么很特殊的改动，主要是修改一些方法的参数为正确的继承参数，

...

package org.apache.ranger.authorization.kafka.authorizer;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletionStage;

import org.apache.kafka.common.Endpoint;
import org.apache.ranger.plugin.classloader.RangerPluginClassLoader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.apache.kafka.server.authorizer.*;
import org.apache.kafka.common.acl.*;
import org.apache.kafka.common.resource.*;


//public class RangerKafkaAuthorizer extends Authorizer {
public class RangerKafkaAuthorizer implements Authorizer {
	private static final Logger LOG  = LoggerFactory.getLogger(RangerKafkaAuthorizer.class);

	private static final String   RANGER_PLUGIN_TYPE                      = "kafka";
	private static final String   RANGER_KAFKA_AUTHORIZER_IMPL_CLASSNAME  = "org.apache.ranger.authorization.kafka.authorizer.RangerKafkaAuthorizer";

	private Authorizer  rangerKakfaAuthorizerImpl 						  = null;
	private static		RangerPluginClassLoader rangerPluginClassLoader   = null;
	
	public RangerKafkaAuthorizer() {
		if(LOG.isDebugEnabled()) {
			LOG.debug("==> RangerKafkaAuthorizer.RangerKafkaAuthorizer()");
		}

		this.init();

		if(LOG.isDebugEnabled()) {
			LOG.debug("<== RangerKafkaAuthorizer.RangerKafkaAuthorizer()");
		}
	}
	
	private void init(){
		if(LOG.isDebugEnabled()) {
			LOG.debug("==> RangerKafkaAuthorizer.init()");
		}

		try {
			
			rangerPluginClassLoader = RangerPluginClassLoader.getInstance(RANGER_PLUGIN_TYPE, this.getClass());
			
			@SuppressWarnings("unchecked")
			Class<Authorizer> cls = (Class<Authorizer>) Class.forName(RANGER_KAFKA_AUTHORIZER_IMPL_CLASSNAME, true, rangerPluginClassLoader);

			activatePluginClassLoader();

			rangerKakfaAuthorizerImpl = cls.newInstance();
		} catch (Exception e) {
			// check what need to be done
			LOG.error("Error Enabling RangerKafkaPlugin", e);
		} finally {
			deactivatePluginClassLoader();
		}

		if(LOG.isDebugEnabled()) {
			LOG.debug("<== RangerKafkaAuthorizer.init()");
		}
	}

	@Override
	public void configure(Map<String, ?> configs) {
		if(LOG.isDebugEnabled()) {
			LOG.debug("==> RangerKafkaAuthorizer.configure(Map<String, ?>)");
		}

		try {
			activatePluginClassLoader();

			rangerKakfaAuthorizerImpl.configure(configs);
		} finally {
			deactivatePluginClassLoader();
		}

		if(LOG.isDebugEnabled()) {
			LOG.debug("<== RangerKafkaAuthorizer.configure(Map<String, ?>)");
		}
	}

	@Override
	public void close() {
		if(LOG.isDebugEnabled()) {
			LOG.debug("==> RangerKafkaAuthorizer.close()");
		}

		try {
			activatePluginClassLoader();
			
			rangerKakfaAuthorizerImpl.close();
		} catch (Throwable t) {
			LOG.error("Error closing RangerPlugin.", t);
		} finally {
			deactivatePluginClassLoader();
		}

		if(LOG.isDebugEnabled()) {
			LOG.debug("<== RangerKafkaAuthorizer.close()");
		}
		
	}

	@Override
	public List<AuthorizationResult> authorize(AuthorizableRequestContext authorizableRequestContext, List<Action> list) {
		if(LOG.isDebugEnabled()) {
			LOG.debug(String.format("==> RangerKafkaAuthorizer.authorize(AuthorizableRequestContext=%s, List<Action>=%s)", authorizableRequestContext, list));
		}

		List<AuthorizationResult> ret = new ArrayList<>();

		try {
			activatePluginClassLoader();

			ret = rangerKakfaAuthorizerImpl.authorize(authorizableRequestContext, list);
		} finally {
			deactivatePluginClassLoader();
		}

		if(LOG.isDebugEnabled()) {
			LOG.debug("<== RangerKafkaAuthorizer.authorize: " + ret);
		}
		
		return ret;
	}

	@Override
	public List<? extends CompletionStage<AclCreateResult>> createAcls(AuthorizableRequestContext authorizableRequestContext, List<AclBinding> list) {
		if(LOG.isDebugEnabled()) {
			LOG.debug("==> RangerKafkaAuthorizer.addAcls(Set<Acl>, Resource)");
		}

		List<? extends CompletionStage<AclCreateResult>> createAcls = new ArrayList<>();
		try {
			activatePluginClassLoader();

			createAcls = rangerKakfaAuthorizerImpl.createAcls(authorizableRequestContext, list);
		} finally {
			deactivatePluginClassLoader();
		}

		if(LOG.isDebugEnabled()) {
			LOG.debug("<== RangerKafkaAuthorizer.addAcls(Set<Acl>, Resource)");
		}
		return createAcls;
	}

	@Override
	public List<? extends CompletionStage<AclDeleteResult>> deleteAcls(AuthorizableRequestContext authorizableRequestContext, List<AclBindingFilter> list) {
		if(LOG.isDebugEnabled()) {
			LOG.debug("==> RangerKafkaAuthorizer.removeAcls(Set<Acl>, Resource)");
		}
		List<? extends CompletionStage<AclDeleteResult>> ret = new ArrayList<>();
		try {
			activatePluginClassLoader();

			ret = rangerKakfaAuthorizerImpl.deleteAcls(authorizableRequestContext, list);
		} finally {
			deactivatePluginClassLoader();
		}

		if(LOG.isDebugEnabled()) {
			LOG.debug("<== RangerKafkaAuthorizer.removeAcls(Set<Acl>, Resource)");
		}
		
		return ret;
	}

	@Override
	public Iterable<AclBinding> acls(AclBindingFilter aclBindingFilter) {
		if(LOG.isDebugEnabled()) {
			LOG.debug("==> RangerKafkaAuthorizer.getAcls(Resource)");
		}

		Iterable<AclBinding> ret = new ArrayList<>();

		try {
			activatePluginClassLoader();

			ret = rangerKakfaAuthorizerImpl.acls(aclBindingFilter);
		} finally {
			deactivatePluginClassLoader();
		}

		if(LOG.isDebugEnabled()) {
			LOG.debug("<== RangerKafkaAuthorizer.getAcls(Resource)");
		}

		return ret;
	}

	@Override
	public Map<Endpoint, ? extends CompletionStage<Void>> start(AuthorizerServerInfo authorizerServerInfo) {
		if(LOG.isDebugEnabled()) {
			LOG.debug("==> RangerKafkaAuthorizer.start(AuthorizerServerInfo authorizerServerInfo)");
		}

		Map<Endpoint, ? extends CompletionStage<Void>> map;
		try {
			activatePluginClassLoader();
			map = rangerKakfaAuthorizerImpl.start(authorizerServerInfo);
		} finally {
			deactivatePluginClassLoader();
		}

		if(LOG.isDebugEnabled()) {
			LOG.debug("<== RangerKafkaAuthorizer.configure(Map<String, ?>)");
		}

		return map;
	}

	@Override
	public AuthorizationResult authorizeByResourceType(AuthorizableRequestContext requestContext, AclOperation op, ResourceType resourceType) {
		return Authorizer.super.authorizeByResourceType(requestContext, op, resourceType);
	}
	
	private void activatePluginClassLoader() {
		if(rangerPluginClassLoader != null) {
			rangerPluginClassLoader.activate();
		}
	}

	private void deactivatePluginClassLoader() {
		if(rangerPluginClassLoader != null) {
			rangerPluginClassLoader.deactivate();
		}
	}
		
}

说明

这里涉及了，两个 RangerKafkaAuthorizer 类

  1. ranger-kafka-plugin-shim 下的该类具体是暴露方法，被 kafka 的插件用于权限校验并返回校验结果

  2. plugin-kafka 下的类，是具体实现具体认证的逻辑

其他

相关命令

博主是在 Kerberos 环境下操作的，所以在执行命令时需要携带相关参数，这里时指定了配置文件，将以下命令添加到对应文件中即可

security.protocol=SASL_PLAINTEXT
sasl.kerberos.service.name=kafka
sasl.mechanism=GSSAPI

查看 topic 命令

bin/kafka-topics.sh --list --bootstrap-server node248:6667 --command-config conf/client.properties

生产者命令

bin/kafka-console-producer.sh --topic test1 --broker-list node248:6667 --producer.config conf/producer.properties

消费者命令

bin/kafka-console-consumer.sh --topic test1 --broker-list node248:6667 --consumer.config conf/consumer.properties
红桃∩
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
kafka之ranger插件的一个坑
hncscwc的博客
12-09 1287
之前文章写过kafka的鉴权，以及集成ranger插件的配置使用。但真正在用起来后，发现里面有个坑，本文就来聊聊这个坑的情况以及排查过程。【问题现象】kafka在集成了ranger插件实现鉴权功能后，发现过一段时间后，controller无法正确连接上broker，并有如下报错：// server.log中的日志 [2022-12-0615:32:48,068] ERROR [Controlle...
Kafka消息队列安装与使用（二）
木讷的鱼
10-21 460
Kafka消息队列安装与使用三. Kafka架构深入3.1 Kafka 工作流程及文件存储机制3.2 Kafka生产者3.2.1 分区策略3.2.2 数据可靠性保证3.2.3 Exactly Once 语义3.3 Kafka 消费者3.3.1 消费方式3.3.2 分区分配策略3.3.3 offset 的维护3.3.4 消费者组案例3.4 Kafka 高效读写数据3.5 Zookeeper 在 Kafka 中的作用3.6 Kafka 事务 三. Kafka架构深入 3.1 Kafka 工作流程及文件存储机
ranger-2.1.0-kafka-plugin.tar.gz
08-09
ranger-2.1.0-kafka-plugin.tar.gz
基于ranger的kafka权限控制
hncscwc的博客
08-16 1782
上一篇文章讲到了kafka中的ACL，也提到了是以插件式的形式实现的，本文就来聊聊基于ranger的kafka访问控制。【ranger插件安装】要使用ranger插件，首先需要对ranger的kafka插件包进行解压缩，然后进入解压缩后的目录，修改安装的配置文件`install.properties`，具体修改的配置项包括：# 插件安装位置(通常就是kafka的安装位置) COMPONENT_IN...
Rander搭建+kafka+hbase
weixin_44224087的博客
11-27 505
1.ranger-admin安装 1.1.解压ranger-2.0.0-admin.tar.gz tar -zxvf ranger-2.0.0-admin.tar.gz -C /var/local/ 1.2.进入ranger-2.0.0-admin目录修改 install.properties 文件 DB_FLAVOR=MYSQL SQL_CONNECTOR_JAR=/usr/share/java/mysql-connector-java.jar db_root_user=root db_root_pas
权限管理-Ranger的介绍和使用(集成Hive)
迷雾总会解
06-15 5591
Apache Ranger是一个Hadoop平台上的全方位数据安全管理框架，它可以为整个Hadoop生态系统提供全面的安全管理。随着企业业务的拓展，企业可能在多用户环境中运行多个工作任务，这就需要一个可以对安全策略进行集中管理，配置和监控用户访问的框架。Ranger由此产生！Ranger的官网：https://ranger.apache.org/RangerUsersync作为Ranger提供的一个管理模块，可以将Linux机器上的用户和组信息同步到RangerAdmin的数据库中进行管理。
CDH 6.3.1 ranger ranger-2.1.0-admin.tar.gz
11-04
总结来说，CDH 6.3.1中的Ranger 2.1.0-admin是实现大数据平台安全策略的核心工具，它提供了强大的权限管理、审计跟踪以及与多种服务的集成能力。对于任何希望确保数据安全的企业，理解和掌握Ranger的使用是至关重要...
apache-ranger-2.1.0
09-02
总之，"apache-ranger-2.1.0"压缩包提供的是一整套Ranger的安全解决方案，包括源码、管理工具、用户同步、迁移工具、KMS、管理员服务器、审计配置和标签同步等，这些组件协同工作，为企业的大数据环境提供了强大的...
ranger-2.1.0-hive-plugin.tar.gz
08-09
总结，Ranger 2.1.0 Hive 插件是大数据环境中的重要安全组件，通过提供细粒度的权限管理、数据屏蔽和审计功能，它极大地增强了 Hive 的安全性，同时也为企业的数据治理提供了有力的支持。在实际使用中，应根据具体...
ranger-2.0.0-kafka-plugin.zip
06-04
由于很多文章都是只有ranger的安装说明，却没有编译后的tar包，而且编译的时间有点长，编译期间会出现各种问题，导致编译不过，特此上传编译后的包，来提供大家下载
cdh6.3.2编译的ranger版本
08-03
2. ranger-2.1.0-kafka-plugin.tar.gz：这是Ranger针对Kafka的插件，使得Kafka集群可以通过Ranger进行权限控制。 3. ranger-2.1.0-hbase-plugin.tar.gz：对应HBase的插件，让HBase的数据访问也能够受到Ranger的权限...
使用ranger对kafka进行鉴权
微信公众号：大数据从业者
03-05 475
使用ranger对kafka进行鉴权测试环境：ranger-kafka-plugin为0.6.3版本，kafka版本为kafka_2.10-0.10.1.1，且kafka broker为一个节点。一、Ranger对kafka进行权限控制，前提需要kafka开启kerberos认证(注意：若kafka不开启kerberos的话Ranger无法获取kafka相关操作的用户，进而无法完成鉴权操作)二、...
【kafka】CDP集群 kafka-ranger-audit-spool 日志太大问题排查
Mrerlou的博客
06-13 711
最近发现 服务 的 审计目录假脱机日志过多，过大。这里整理并记录一下解决方案。 服务 日志过多。 问题原因 当为 启用 审计时，当写入 失败时，审计日志数据会在本地磁盘上假脱机。我们的 服务和 服务的相关配置如下：那么为什么写入 失败呢，通过查看上下文发现 ranger 没有写入 文件的权限。CDP 环境解决如下： -> ->如果环境不为 CDP 环境：实际上就是创建 服务对应的 目录，并对 目录赋予正确的权限，使得 能够正常写入数据到 即可。..............
离线数仓-09-基于Ranger进行权限管理
迷雾总会解
06-01 761
主要是介绍了ranger，以及基于ranger进行项目的权限管理。
ranger1.2 性能优化记录
狗走猫步的数据世界
04-01 1767
ranger1.2性能优化
Ranger-kafka-plugin
Nobigo
11-19 3623
ranger如何对在非安全模式下的kafka进行授权操作这部分主要是关于ranger如何对非安全模式下的kafka进行授权操作。1. 我可以通过ranger对非安全模式下的kafka进行访问控制？可以通过指定Ip地址对访问进行控制。2. 我可以通过ranger的用户/用户组来对非安全模式下的kafka进行访问控制？不能通过基于用户/用户组的条件来对非安全模式下的kafka进行控制，因为在非安全模式下
Kafka系列之：详细总结认证方式PLAINTEXT、GSSAPI、Scram的实现方式，通过Ranger、Kerberos实现kafka账号的Topic权限管理
zhengzaifeidelushang的博客
02-17 593
Kafka系列之：详细总结认证方式PLAINTEXT、GSSAPI、Scram的实现方式，通过Ranger、Kerberos实现kafka账号的Topic权限管理
Java增加线程后kafka仍然消费很慢
最新发布
paulwang040的博客
07-04 1008
概念：max.poll.interval.ms是Kafka消费者端的一个配置参数，用于设置消费者在轮询过程中处理消息的最大时间间隔。根据实际业务需求和消息处理的复杂性，设置合理的max.poll.interval.ms值，以确保消费者有足够的时间来处理消息。考虑到网络延迟和消息处理的时间，建议将max.poll.interval.ms设置为较大的值，以避免过早地将消费者标记为故障。同时，也要注意将max.poll.interval.ms设置为一个合理的值，以避免消费者长时间无响应而导致消息处理的延迟。
ranger-2.1.0-admin
11-22
ranger-2.1.0-admin 是一个用于 Apache Ranger 的版本为 2.1.0 的管理工具。Apache Ranger是一个开源的、跨平台的访问控制框架，旨在帮助企业管理和保护其大数据平台。 ranger-2.1.0-admin 工具提供了一组管理命令，用于配置和管理 Apache Ranger。使用该工具，管理员可以轻松地设置和管理策略、用户和组、资源和服务，以限制和监控对数据平台的访问。 ranger-2.1.0-admin 工具提供了一种直观且易于使用的方式来进行管理操作。管理员可以使用命令行界面或通过脚本批量处理任务。该工具通过简化和集中化管理，可以帮助管理员更有效地管理和维护数据平台的安全性。 除了基本的管理功能，ranger-2.1.0-admin 还提供了一些高级功能和扩展。例如，管理员可以根据需要自定义特定资源的访问控制策略。还可以与 LDAP、AD、Kerberos 等外部身份验证和授权系统集成，以便更好地管理和保护数据平台。 总之，ranger-2.1.0-admin 是一个用于管理 Apache Ranger 的工具，它提供了一组命令和功能，以帮助管理员设置和管理策略、用户、资源和服务。通过使用这个工具，管理员可以更好地管理和维护数据平台的安全性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值