ZooKeeper 摘要身份验证

2025 年 5 月 15 日 | 阅读 11 分钟

ZooKeeper 认证是保护 Apache ZooKeeper 的关键方面，ZooKeeper 在分布式系统中维护配置信息、命名、同步和提供组服务方面发挥着至关重要的作用。由于 ZooKeeper 通常用于涉及关键基础设施或敏感数据的场景，因此确保只有授权的客户端和服务器能够与其交互对于维护系统完整性和隐私至关重要。

1. ZooKeeper 认证简介

ZooKeeper 中的认证提供了验证与服务交互的客户端和服务器身份的机制。这可以防止对资源的未经授权访问，并确保只有受信任的客户端才能发出请求或执行操作。

ZooKeeper 认证通常涉及两个主要组件

认证机制： 用于识别和认证与系统交互的实体的各种方法。
授权： 确定已认证实体是否允许访问特定资源或执行某些操作的后续控制。

2. ZooKeeper 安全模型

ZooKeeper 使用基于认证、授权和数据完整性 的安全模型。虽然认证确保验证客户端或服务器的身份，但授权确定在实体经过身份验证后允许执行哪些操作。

认证： 通过验证凭据来验证客户端或服务器的身份。
授权： 根据客户端或服务器的已认证身份及其权限授予或拒绝对资源的访问。
数据完整性： 确保客户端和 ZooKeeper 服务器之间交换的数据在传输过程中未被篡改。

3. ZooKeeper 认证机制

ZooKeeper 支持多种认证方法，使其能够适应不同环境下的各种安全要求。最常见的机制包括 Digest、Kerberos、SSL/TLS 和自定义认证。

3.1 Digest 认证

Digest 认证使用简单的用户名-密码模型。客户端提供用户名和密码，这些用户名和密码将被哈希并与存储的凭据进行比较。Digest 认证是较简单的选项之一，适用于大多数通用用例。

机制

客户端发送格式为 digest:<username>:<password> 的认证请求。例如，如果客户端发送 digest:admin:password123，ZooKeeper 将通过将其哈希密码与记录进行匹配来验证它。

Digest 认证程序示例

import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.KeeperException;

public class DigestAuthExample {

    public static void main(String[] args) {
        String connectString = "localhost:2181";
        int sessionTimeout = 3000;
        try {
            // Connect to ZooKeeper
            ZooKeeper zk = new ZooKeeper(connectString, sessionTimeout, event -> {
                if (event.getState() == ZooKeeper.States.CONNECTED) {
                    System.out.println("Connected to ZooKeeper");
                }
            });

            // Add authentication
            zk.addAuthInfo("digest", "admin:password123".getBytes());

            // Create a node with ACL that allows only 'admin' to read
            String path = "/secure_node";
            byte[] data = "Confidential data".getBytes();
            zk.create(path, data, ZooDefs.Ids.CREATOR_ALL_ACL, CreateMode.PERSISTENT);

            System.out.println("Node created with Digest Authentication");

            // Fetch the node's data
            byte[] retrievedData = zk.getData(path, false, null);
            System.out.println("Data from node: " + new String(retrievedData));

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出

3.2 Kerberos 认证

Kerberos 是一种企业级网络认证协议，可提供安全的、基于票证的客户端-服务器认证。ZooKeeper 可以配置为使用 Kerberos，这非常适合高安全性的企业环境。

机制

ZooKeeper 依赖于密钥分发中心 (KDC) 发行的 Kerberos 票证进行客户端认证。ZooKeeper 服务器检查这些票证的真实性以验证客户端身份。

Kerberos 认证程序示例

首先，在服务器和客户端两侧设置 Kerberos Keytab 文件和 JAAS 配置。以下是一个使用 Kerberos 认证连接到 ZooKeeper 的示例客户端代码

对于 Kerberos 认证，您需要设置 Kerberos 密钥分发中心 (KDC)，这需要对 ZooKeeper 服务器和客户端进行额外的配置。

ZooKeeper 服务器配置

在 zoo.cfg 中，设置以下属性

通过创建一个 zookeeper_jaas.conf 文件来设置 ZooKeeper 的 Kerberos JAAS 配置

Server {
   com.sun.security.auth.module.Krb5LoginModule required
   useKeyTab=true
   storeKey=true
   keyTab="/path/to/zookeeper.keytab"
   principal="zookeeper/localhost@YOUR_REALM";
};

然后，使用此 JAAS 配置启动 ZooKeeper

export JVMFLAGS="-Djava.security.auth.login.config=/path/to/zookeeper_jaas.conf"
bin/zkServer.sh start

客户端代码

使用 client_jaas.conf 文件配置客户端

Client {
   com.sun.security.auth.module.Krb5LoginModule required
   useTicketCache=true
   principal="user@YOUR_REALM";
};

使用 JAAS 配置运行以下客户端代码

import org.apache.zookeeper.ZooKeeper;

public class KerberosAuthExample {

    public static void main(String[] args) {
        String connectString = "localhost:2181";
        int sessionTimeout = 3000;

        System.setProperty("java.security.auth.login.config", "/path/to/client_jaas.conf");

        try {
            // Connect to ZooKeeper using Kerberos
            ZooKeeper zk = new ZooKeeper(connectString, sessionTimeout, event -> {
                if (event.getState() == ZooKeeper.States.CONNECTED) {
                    System.out.println("Connected to ZooKeeper with Kerberos Authentication");
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出

3.3 SSL/TLS 认证

SSL/TLS 在客户端和 ZooKeeper 服务器之间提供加密通信，允许双方使用 SSL 证书进行认证。

机制

ZooKeeper 服务器和客户端使用相互 SSL/TLS 认证，在握手期间双方都会向对方出示证书。如果两个证书都有效，则连接继续。

SSL/TLS 认证程序示例

配置客户端的密钥库和信任库，并使用以下代码与 ZooKeeper 建立 SSL 连接

ZooKeeper 服务器配置

将以下属性添加到 zoo.cfg

secureClientPort=2281
ssl.keyStore.location=/path/to/keystore.jks
ssl.keyStore.password=keystore_password
ssl.trustStore.location=/path/to/truststore.jks
ssl.trustStore.password=truststore_password

客户

import org.apache.zookeeper.ZooKeeper;

public class SSLAuthExample {

    public static void main(String[] args) {
        String connectString = "localhost:2281"; // Use secure port
        int sessionTimeout = 3000;
        System.setProperty("zookeeper.clientCnxnSocket", "org.apache.zookeeper.ClientCnxnSocketNetty");
        System.setProperty("zookeeper.ssl.keyStore.location", "/path/to/client_keystore.jks");
        System.setProperty("zookeeper.ssl.keyStore.password", "keystore_password");
        System.setProperty("zookeeper.ssl.trustStore.location", "/path/to/client_truststore.jks");
        System.setProperty("zookeeper.ssl.trustStore.password", "truststore_password");

        try {
            // Connect to ZooKeeper over SSL
            ZooKeeper zk = new ZooKeeper(connectString, sessionTimeout, event -> {
                if (event.getState() == ZooKeeper.States.CONNECTED) {
                    System.out.println("Connected to ZooKeeper with SSL/TLS Authentication");
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出

3.4 自定义认证

ZooKeeper 允许通过实现自定义 AuthProvider 类来进行自定义认证方案，这有助于与 OAuth 或 LDAP 等外部认证系统集成。

机制

开发人员实现自定义 AuthProvider 类并将其插入 ZooKeeper 服务器，从而允许 ZooKeeper 使用自定义方法来验证客户端身份。

自定义认证程序示例

实现自定义 AuthProvider 并将其注册到 ZooKeeper 配置中，然后使用自定义令牌进行认证

服务器端：实现自定义 AuthProvider

通过扩展 org.apache.zookeeper.server.auth.AuthProvider 来实现自定义 AuthProvider 类。

import org.apache.zookeeper.server.auth.AuthProvider;
import org.apache.zookeeper.KeeperException;

public class CustomAuthProvider implements AuthProvider {

    @Override
    public String getScheme() {
        return "custom";
    }

    @Override
    public byte[] authenticate(String auth) throws KeeperException.AuthFailedException {
        // Implement custom authentication logic here
        if ("customToken".equals(auth)) {
            return auth.getBytes();
        } else {
            throw new KeeperException.AuthFailedException();
        }
    }

    @Override
    public boolean matches(String id, String aclExpr) {
        // Implement match logic for ACL checks
        return id.equals(aclExpr);
    }
}

将以下内容添加到 zoo.cfg 以注册自定义认证提供程序

客户端代码

使用自定义认证方案连接到 ZooKeeper

import org.apache.zookeeper.ZooKeeper;

public class CustomAuthExample {

    public static void main(String[] args) {
        String connectString = "localhost:2181";
        int sessionTimeout = 3000;

        try {
            ZooKeeper zk = new ZooKeeper(connectString, sessionTimeout, event -> {
                if (event.getState() == ZooKeeper.States.CONNECTED) {
                    System.out.println("Connected to ZooKeeper with Custom Authentication");
                }
            });

            // Authenticate using the custom token
            zk.addAuthInfo("custom", "customToken".getBytes());

            // Interact with ZooKeeper nodes (add further logic as needed)

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出

4. ZooKeeper 中的认证过程

ZooKeeper 中的认证过程通常涉及以下步骤

客户端发起连接： 当客户端尝试连接到 ZooKeeper 服务器时，它可能会根据所使用的认证机制提供认证凭据（例如，用户名/密码、Kerberos 票证或 SSL 证书）。
认证请求： 包含凭据的请求到客户端，通常在初始握手之后（例如，对于 SSL/TLS，这发生在握手期间，对于 Digest，凭据是单独传递的）。
服务器验证凭据： ZooKeeper 服务器处理认证请求。它根据所选机制验证凭据（例如，为 digest 认证哈希密码或验证 Kerberos 票证）。
响应客户端： 如果凭据有效，服务器将响应成功消息。如果无效，则发送认证失败消息，连接将被终止。

5. ZooKeeper 中的授权

ZooKeeper 的授权系统在成功进行客户端认证后，可以对资源进行受控访问。通过使用访问控制列表 (ACL)，ZooKeeper 指定哪些客户端可以在 ZooKeeper 树中的每个节点上执行某些操作。ACL 由分配给用户、组或客户端的权限组成，并提供了一个灵活的模型来定义访问限制。

5.1 ZooKeeper ACL（访问控制列表）

ZooKeeper 中的每个 ACL 条目都有三个组成部分

ID： 表示正在授予或拒绝访问的实体（用户、组或客户端）。
权限： 指定实体可以执行的操作，例如 READ、WRITE、CREATE、DELETE 或 ADMIN。
Scheme： 定义使用的认证方案（例如，digest、ip、kerberos）。

ACL 结构示例

典型的 ACL 条目可能看起来像 digest:admin:password123:READ，其中

Scheme： digest（表示 digest 认证方案）。
ID： admin（用户名）。
Permissions： READ（表示用户只能读取指定节点）。

ACL 权限

ZooKeeper 支持以下权限

READ： 允许读取节点数据和列出其子节点。
WRITE： 允许为节点设置数据。
CREATE： 允许创建子节点。
DELETE： 允许删除节点。
ADMIN： 允许修改节点的 ACL。

程序示例：设置 ACL

下面的示例演示了如何创建一个具有自定义 ACL 的 ZooKeeper 节点，该自定义 ACL 仅允许管理员用户（使用 digest 认证）读取和写入该节点。

import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.CreateMode;
import java.util.Collections;

public class ACLExample {
    public static void main(String[] args) {
        String connectString = "localhost:2181";
        int sessionTimeout = 3000;

        try {
            // Connect to ZooKeeper
            ZooKeeper zk = new ZooKeeper(connectString, sessionTimeout, event -> {
                if (event.getState() == ZooKeeper.States.CONNECTED) {
                    System.out.println("Connected to ZooKeeper");
                }
            });

            // Add authentication for the 'admin' user
            zk.addAuthInfo("digest", "admin:password123".getBytes());

            // Define ACLs that only allow 'admin' to read and write
            ACL adminAcl = new ACL(ZooDefs.Perms.READ | ZooDefs.Perms.WRITE, new org.apache.zookeeper.data.Id("digest", "admin:password123"));

            // Create a node with this ACL
            String path = "/secure_node";
            byte[] data = "Confidential Data".getBytes();

            zk.create(path, data, Collections.singletonList(adminAcl), CreateMode.PERSISTENT);
            System.out.println("Node created with custom ACL for 'admin'.");

            // Retrieve data from the node
            byte[] retrievedData = zk.getData(path, false, null);
            System.out.println("Data from node: " + new String(retrievedData));

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出

5.2 默认 ACL

ZooKeeper 节点可以继承默认 ACL，这使得跨多个节点的权限管理更加简单。在父级设置的默认 ACL 可以在创建子节点时传播到子节点，从而在节点层次结构中实现一致的访问控制策略。

5.3 管理 ACL

ZooKeeper 提供了一个 API 来管理任何节点的 ACL。管理员可以根据需要添加、修改或删除 ACL 条目。

示例：修改现有节点上的 ACL

以下示例演示了如何更新现有 ZooKeeper 节点的 ACL。该程序首先对客户端进行认证，然后更改节点的 ACL 以授予另一个用户 READ 权限。

import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZKUtil;
import java.util.ArrayList;
import java.util.List;

public class ModifyACLExample {
    public static void main(String[] args) {
        String connectString = "localhost:2181";
        int sessionTimeout = 3000;

        try {
            // Connect to ZooKeeper
            ZooKeeper zk = new ZooKeeper(connectString, sessionTimeout, event -> {
                if (event.getState() == ZooKeeper.States.CONNECTED) {
                    System.out.println("Connected to ZooKeeper");
                }
            });

            // Authenticate as 'admin'
            zk.addAuthInfo("digest", "admin:password123".getBytes());

            // Define a new ACL to grant READ access to 'user1'
            ACL readAclForUser1 = new ACL(ZooDefs.Perms.READ, new org.apache.zookeeper.data.Id("digest", "user1:password456"));

            // Fetch current ACL and add the new entry
            String path = "/secure_node";
            List<ACL> currentAcls = zk.getACL(path, null);
            currentAcls.add(readAclForUser1);

            // Set the updated ACL list for the node
            zk.setACL(path, currentAcls, -1);
            System.out.println("ACL modified to allow READ access for 'user1'.");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出

示例：删除 ACL

此示例通过先识别 ACL 条目，然后设置不包含它的 ACL 列表来从节点中删除特定的 ACL 条目。

import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.data.ACL;
import java.util.List;

public class RemoveACLExample {
    public static void main(String[] args) {
        String connectString = "localhost:2181";
        int sessionTimeout = 3000;

        try {
            // Connect to ZooKeeper
            ZooKeeper zk = new ZooKeeper(connectString, sessionTimeout, event -> {
                if (event.getState() == ZooKeeper.States.CONNECTED) {
                    System.out.println("Connected to ZooKeeper");
                }
            });

            // Authenticate as 'admin'
            zk.addAuthInfo("digest", "admin:password123".getBytes());

            // Retrieve current ACL
            String path = "/secure_node";
            List<ACL> currentAcls = zk.getACL(path, null);

            // Filter out the ACL for 'user1'
            currentAcls.removeIf(acl -> acl.getId().getScheme().equals("digest") && acl.getId().getId().startsWith("user1:"));

            // Set the updated ACL list
            zk.setACL(path, currentAcls, -1);
            System.out.println("Removed ACL for 'user1'.");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出

6. ZooKeeper 与外部安全系统集成

在许多环境中，将 ZooKeeper 认证和授权与外部安全系统集成非常重要。常见的集成包括

6.1 LDAP 集成

LDAP（轻量级目录访问协议）广泛用于管理大型组织中的用户凭据。通过将 ZooKeeper 与 LDAP 服务器集成，组织可以集中控制和认证用户对 ZooKeeper 资源的访问。

LDAP 集成在 ZooKeeper 中如何工作

要将 LDAP 与 ZooKeeper 集成，您需要

实现自定义 AuthProvider： 这涉及编写与 LDAP 服务器交互的自定义认证提供程序。
在 ZooKeeper 中配置自定义提供程序： 然后，在 ZooKeeper 的配置文件中配置自定义提供程序以处理认证。

程序示例：LDAP 认证提供程序

下面是一个自定义 LDAPAuthProvider 类的示例，该类连接到 LDAP 服务器进行认证。

LDAPAuthProvider.java

import org.apache.zookeeper.server.auth.AuthenticationProvider;
import org.apache.zookeeper.server.auth.ProviderRegistry;
import javax.naming.Context;
import javax.naming.directory.DirContext;
import javax.naming.directory.InitialDirContext;
import javax.naming.AuthenticationException;
import java.util.Hashtable;

public class LDAPAuthProvider implements AuthenticationProvider {

    private static final String LDAP_URL = "ldap://your-ldap-server:389";
    private static final String LDAP_SEARCH_BASE = "dc=example,dc=com";

    @Override
    public String getScheme() {
        return "ldap";
    }

    @Override
    public KeeperException.Code handleAuthentication(ServerCnxn cnxn, byte[] authData) {
        String[] credentials = new String(authData).split(":");
        if (credentials.length != 2) {
            return KeeperException.Code.AUTHFAILED;
        }
        String username = credentials[0];
        String password = credentials[1];
        return authenticateWithLDAP(username, password) ? KeeperException.Code.OK : KeeperException.Code.AUTHFAILED;
    }

    private boolean authenticateWithLDAP(String username, String password) {
        Hashtable<String, String> env = new Hashtable<>();
        env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
        env.put(Context.PROVIDER_URL, LDAP_URL);
        env.put(Context.SECURITY_AUTHENTICATION, "simple");
        env.put(Context.SECURITY_PRINCIPAL, "cn=" + username + "," + LDAP_SEARCH_BASE);
        env.put(Context.SECURITY_CREDENTIALS, password);

        try {
            DirContext ctx = new InitialDirContext(env);
            ctx.close();
            return true;
        } catch (AuthenticationException e) {
            System.out.println("Authentication failed for user: " + username);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public boolean matches(String id) {
        return id.startsWith("ldap:");
    }

    @Override
    public boolean isAuthenticated() {
        return true;
    }
}

输出 1

输出 2

启用 LDAP 认证提供程序的步骤

1. 编译上面的 Java 代码，并将生成的类文件放在 ZooKeeper 的类路径中。

2. 在 zoo.cfg 中注册自定义 Auth Provider

3. 使用 LDAP 凭据进行认证

在客户端应用程序中，按以下方式提供 LDAP 凭据

ZooKeeper zk = new ZooKeeper("localhost:2181", 3000, null);
zk.addAuthInfo("ldap", "username:password".getBytes());

6.2 OAuth 集成

OAuth 是一种流行的基于令牌的协议，用于在不暴露用户凭据的情况下授予对资源的访问权限。尽管 ZooKeeper 不原生支持 OAuth，但可以通过实现类似于 LDAP 示例的自定义认证提供程序来集成 OAuth。

OAuth 集成在 ZooKeeper 中如何工作

要使用 OAuth 对 ZooKeeper 客户端进行认证

实现自定义 AuthProvider： 此类会验证 OAuth 提供程序中的令牌。
在 ZooKeeper 中配置自定义提供程序。

程序示例：OAuth 认证提供程序

这是一个简单的 OAuthAuthProvider 示例，它连接到 OAuth 授权服务器来验证令牌。

OAuthAuthProvider.java

import org.apache.zookeeper.server.auth.AuthenticationProvider;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class OAuthAuthProvider implements AuthenticationProvider {

    private static final String OAUTH_VALIDATE_URL = "https://oauth-server.com/validateToken";

    @Override
    public String getScheme() {
        return "oauth";
    }

    @Override
    public KeeperException.Code handleAuthentication(ServerCnxn cnxn, byte[] authData) {
        String token = new String(authData);
        return validateToken(token) ? KeeperException.Code.OK : KeeperException.Code.AUTHFAILED;
    }

    private boolean validateToken(String token) {
        try {
            URL url = new URL(OAUTH_VALIDATE_URL + "?access_token=" + token);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");

            int responseCode = connection.getResponseCode();
            return responseCode == 200;

        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public boolean matches(String id) {
        return id.startsWith("oauth:");
    }

    @Override
    public boolean isAuthenticated() {
        return true;
    }
}

输出 1

输出 2

启用 OAuth 认证提供程序的步骤

1. 编译上面的 Java 代码，并将编译后的类添加到 ZooKeeper 的类路径中。

2. 在 zoo.cfg 中注册 OAuth Auth Provider

3. 使用 OAuth 令牌进行认证

在客户端应用程序中，按以下方式传递 OAuth 令牌

ZooKeeper zk = new ZooKeeper("localhost:2181", 3000, null);
zk.addAuthInfo("oauth", "your_oauth_access_token".getBytes());

7. ZooKeeper 安全配置

可以通过其配置文件 (zoo.cfg) 中的各种属性来设置 ZooKeeper 的安全配置。关键配置包括

authProvider： 指定要使用的认证提供程序（例如，org.apache.zookeeper.server.auth.DigestAuthenticationProvider 用于 Digest 认证）。
requireClientAuthScheme： 确定客户端所需的认证机制。
sslKeyStoreLocation： 如果启用了 SSL 认证，则指定 SSL 密钥库的位置。

8. ZooKeeper 认证和安全最佳实践

为了在使用 ZooKeeper 时确保最佳安全性，建议遵循以下最佳实践

使用 Digest 认证： 与 Kerberos 相比，Digest 认证更易于配置和部署，同时仍为大多数用例提供强大的安全性。
限制对 ZooKeeper 集群的访问： 将 ZooKeeper 服务器的访问限制在受信任的主机或 IP 地址范围内。这可以防止未经授权的客户端访问服务。
使用强密码： 确保为 Digest 认证使用强密码。弱密码会增加未经授权访问的风险。
启用 ACL： 始终使用 ACL 来限制对敏感节点的访问，并限制哪些客户端可以对 ZooKeeper 节点执行某些操作。

下一主题Kafka 数据捕获

ZooKeeper 摘要身份验证

1. ZooKeeper 认证简介

2. ZooKeeper 安全模型

3. ZooKeeper 认证机制

3.1 Digest 认证

3.2 Kerberos 认证

3.3 SSL/TLS 认证

3.4 自定义认证

4. ZooKeeper 中的认证过程

5. ZooKeeper 中的授权

5.1 ZooKeeper ACL（访问控制列表）

5.2 默认 ACL

5.3 管理 ACL

6. ZooKeeper 与外部安全系统集成

6.1 LDAP 集成

6.2 OAuth 集成

7. ZooKeeper 安全配置

8. ZooKeeper 认证和安全最佳实践

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Kafka 教程

Kafka 安装

Kafka CLI

Kafka 编程

实时示例

Kafka 监控

Kafka Connect

Kafka Streams

杂项

ZooKeeper 摘要身份验证

1. ZooKeeper 认证简介

2. ZooKeeper 安全模型

3. ZooKeeper 认证机制

3.1 Digest 认证

3.2 Kerberos 认证

3.3 SSL/TLS 认证

3.4 自定义认证

4. ZooKeeper 中的认证过程

5. ZooKeeper 中的授权

5.1 ZooKeeper ACL（访问控制列表）

5.2 默认 ACL

5.3 管理 ACL

6. ZooKeeper 与外部安全系统集成

6.1 LDAP 集成

6.2 OAuth 集成

7. ZooKeeper 安全配置

8. ZooKeeper 认证和安全最佳实践

相关帖子

Kafka 到 Cosmos DB 数据流中的延迟优化

模式演进

Kafka 和数字孪生架构

Kafka 在网络安全事件管理中的作用

Kafka Streams vs Spark Streaming

Kafka 到 Cosmos DB 故障的死信队列

最佳 Apache Kafka 书籍

从 Kafka 到 Cosmos DB 的变更数据捕获 (CDC)

Kafka 中的日志压缩

用于物联网数据摄取管道的 Kafka

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器