ZooKeeper 高级特性与集群管理

前置知识

在学习本教程之前，请确保已经：

• 掌握 ZooKeeper 的基本使用
• 了解分布式系统的基本原理
• 具备 Linux 系统运维经验

集群部署

1. 集群架构

ZooKeeper 集群采用主从架构：

• Leader：处理写请求，保证集群数据一致性
• Follower：处理读请求，参与选举
• Observer：处理读请求，不参与选举（可选）

2. 集群配置

# zoo.cfg
tickTime=2000
initLimit=10
syncLimit=5
dataDir=/data/zookeeper
clientPort=2181

# 集群配置
server.1=zoo1:2888:3888
server.2=zoo2:2888:3888
server.3=zoo3:2888:3888

# 配置 Observer（可选）
server.4=zoo4:2888:3888:observer

# 高级参数
autoPurgeSnapRetainCount=3
autoPurgeInterval=1
preAllocSize=65536
snapCount=100000

3. 集群搭建步骤

# 1. 创建数据目录
mkdir -p /data/zookeeper

# 2. 创建 myid 文件
echo "1" > /data/zookeeper/myid  # 每个节点的 myid 不同

# 3. 启动服务
bin/zkServer.sh start

# 4. 检查状态
bin/zkServer.sh status

高级特性

1. ACL 权限控制

import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Id;

public class AclDemo {
    private final CuratorFramework client;
    
    public AclDemo(CuratorFramework client) {
        this.client = client;
    }
    
    public void setAcl() throws Exception {
        // 创建授权信息
        List<ACL> aclList = new ArrayList<>();
        
        // 添加认证用户权限
        Id authId = new Id("digest", "user:password");
        aclList.add(new ACL(ZooDefs.Perms.ALL, authId));
        
        // 添加只读权限
        aclList.add(new ACL(ZooDefs.Perms.READ, ZooDefs.Ids.ANYONE_ID_UNSAFE));
        
        // 设置节点ACL
        client.setACL()
              .withACL(aclList)
              .forPath("/protected-node");
    }
}

2. 配额管理

import org.apache.zookeeper.StatsTrack;

public class QuotaDemo {
    private final CuratorFramework client;
    
    public QuotaDemo(CuratorFramework client) {
        this.client = client;
    }
    
    public void setQuota() throws Exception {
        String path = "/quota-test";
        
        // 设置配额
        StatsTrack quota = new StatsTrack();
        quota.setCount(10);  // 限制子节点数量
        quota.setBytes(1024);  // 限制数据大小
        
        client.create()
              .withMode(CreateMode.PERSISTENT)
              .forPath(path + "/zookeeper_stats", quota.toString().getBytes());
    }
}

3. 监控与度量

import org.apache.curator.framework.api.CuratorEvent;
import org.apache.curator.framework.api.CuratorListener;

public class MonitoringDemo {
    private final CuratorFramework client;
    
    public MonitoringDemo(CuratorFramework client) {
        this.client = client;
    }
    
    public void setupMonitoring() {
        // 添加全局监听器
        client.getCuratorListenable().addListener(
            (client, event) -> {
                switch (event.getType()) {
                    case CREATE:
                        log.info("节点创建：{}", event.getPath());
                        break;
                    case DELETE:
                        log.info("节点删除：{}", event.getPath());
                        break;
                    case WATCHED:
                        log.info("触发监听：{}", event.getPath());
                        break;
                    default:
                        break;
                }
            }
        );
        
        // 监控连接状态
        client.getConnectionStateListenable().addListener(
            (client, state) -> {
                log.info("连接状态变更：{}", state);
            }
        );
    }
}

运维管理

1. 数据备份

public class BackupUtil {
    private final CuratorFramework client;
    
    public BackupUtil(CuratorFramework client) {
        this.client = client;
    }
    
    public void backup(String path, String backupFile) throws Exception {
        Map<String, String> dataMap = new HashMap<>();
        backupNode(path, dataMap);
        
        // 保存备份数据
        try (FileWriter writer = new FileWriter(backupFile)) {
            JsonUtils.writeValue(writer, dataMap);
        }
    }
    
    private void backupNode(String path, Map<String, String> dataMap) throws Exception {
        byte[] data = client.getData().forPath(path);
        dataMap.put(path, Base64.getEncoder().encodeToString(data));
        
        List<String> children = client.getChildren().forPath(path);
        for (String child : children) {
            backupNode(path + "/" + child, dataMap);
        }
    }
}

2. 性能调优

性能优化建议

1. JVM 调优

# JVM 参数示例
JAVA_OPTS="-Xms2g -Xmx2g -XX:+UseG1GC"

2. 网络调优

# zoo.cfg
syncLimit=5
initLimit=10
tickTime=2000

3. 磁盘调优

# zoo.cfg
preAllocSize=65536
snapCount=100000
autoPurgeSnapRetainCount=3

3. 监控告警

public class HealthCheck {
    private final CuratorFramework client;
    
    public HealthCheck(CuratorFramework client) {
        this.client = client;
    }
    
    public void checkClusterHealth() {
        try {
            // 检查集群状态
            List<String> servers = client.getChildren().forPath("/zookeeper/quota");
            
            // 检查节点数量
            if (servers.size() < 3) {
                sendAlert("集群节点数不足");
            }
            
            // 检查连接数
            String statCmd = "echo stat | nc localhost 2181";
            Process process = Runtime.getRuntime().exec(statCmd);
            // 解析输出并检查连接数
            
        } catch (Exception e) {
            log.error("健康检查失败", e);
            sendAlert("健康检查异常：" + e.getMessage());
        }
    }
    
    private void sendAlert(String message) {
        // 实现告警逻辑
        log.warn("告警：{}", message);
    }
}

最佳实践

运维注意事项

1. 定期备份：重要数据定期备份
2. 日志管理：合理配置日志级别和轮转
3. 监控告警：建立完善的监控体系
4. 版本升级：制定合理的升级策略

安全建议

1. 网络隔离：使用内网部署
2. 访问控制：合理配置ACL
3. 认证加密：启用SSL通信
4. 审计日志：记录关键操作

常见问题

1. 如何处理脑裂？

防止脑裂的措施：

1. 配置合适的超时时间
2. 使用奇数个节点
3. 配置防火墙规则

# zoo.cfg 配置建议
initLimit=10
syncLimit=5
electionAlg=3

2. 如何优化大量客户端连接？

处理大量连接的策略：

1. 使用连接池
2. 配置合适的最大连接数
3. 实现客户端限流

// 连接池配置示例
CuratorFrameworkFactory.builder()
    .connectString(connectString)
    .sessionTimeoutMs(sessionTimeout)
    .connectionTimeoutMs(connectionTimeout)
    .retryPolicy(new ExponentialBackoffRetry(1000, 3))
    .maxCloseWaitMs(2000)
    .build();

总结

本教程详细介绍了 ZooKeeper 的高级特性和运维管理：

1. ✅ 集群部署：架构设计和配置说明
2. ✅ 高级特性：ACL和配额管理
3. ✅ 运维管理：备份和监控
4. ✅ 性能调优：JVM和系统优化
5. ✅ 最佳实践：运维和安全建议

下一步学习

• 学习 ZooKeeper 源码分析
• 探索更多运维工具
• 实践大规模部署方案