利用zookeeper模拟实现HA高可用

待我称王封你为后i 2022-01-11 05:53 332阅读 0赞

#  **利用zookeeper模拟实现HA高可用** #

#  #

# **1、需求** #

在分布式场景中，对于主从架构来说，最大的问题就是单点故障。当学过zookeeper之后，我们都知道，可以利用zookeeper集群来帮助实现Hadoop的HA，那到底Hadoop的HA是如何实现的呢？

# 2、实现思路 #

zookeeper给我们提供了两个非常重要的组件：

1、znode系统：提供了存储关键数据的能力

2、监听机制：提供了监听感兴趣数据变化的能力

利用zookeeper的这两点能力，我们实现HA

# 3、具体实现功能 #

1、当开始启动namenode的时候，所有刚启动的namenode都需要去争抢成为active的namenode，没有争抢成功的则成为standby的状态
    
    2、当active的namenode死掉之后，需要剩下的所有的stanby都需要去争抢成为active的状态

# 4、具体代码实现 #

package com.ghgj.zookeeper.zkapp1903;
    
    import org.apache.zookeeper.*;
    import org.apache.zookeeper.Watcher.Event.EventType;
    import org.apache.zookeeper.ZooDefs.Ids;
    
    import java.util.List;
    
    /**
     * 需求：
     * 模拟实现HA
     * <p>
     * 具体的功能：
     * 1、当开始启动namenode的时候，所有刚启动的namenode都需要去争抢成为active的namenode
     * 没有争抢成功的则成为standby的状态
     * 2、当active的namenode死掉之后，需要剩下的所有的stanby都需要去争抢成为active的状态
     * <p>
     * 在这个模拟实现中，假定所有的namenode之间的数据状态都是同步的。没有数据状态差别
     * <p>
     * 分析实现思路：
     * 见代码注释
     */
    public class NameNodeHA {
    
      // 连接信息
      private static final String CONNECT_STR = "hadoop02:2181,hadoop03:2181";
    
      // 会话超时时长   会话建立成功最长的等待时间
      private static final int TIME_OUT = 5000;
    
      // 存储active namenode的父级znode节点
      private static final String ACTIVE_PARENT = "/namenode_active";
      // 存储standby namenode的父级znode节点
      private static final String STANBY_PARENT = "/namenode_standbys";
      // 锁节点
      private static final String LOCK_ZNODE = "/namenode_lock";
    
      // 当前上线的节点名称
      private static final String NAMENODE_HOST = "hadoop02";
    
      static ZooKeeper zookeeper = null;
    
      public static void main(String[] args) throws Exception {
    
        /**
         * 获取连接
         *
         * 关于监听器的知识：
         * 有两种添加监听的方式：
         * 1、通过会话对象添加，这个会话对象中的所有的相应都能接收到，都在这个监听器对象中的process
         * 方法中执行业务逻辑的回调
         * 	在获取会话的时候添加的监听是属于全局监听，当前这个会话中的任何事件响应，都会回调这个监听器对象中的
         * process方法
         *
         * 2、在对应的三种添加监听的方式中，注入自定义的监听对象，那么注入的监听器对象是谁，
         * 当事件响应的时候，就回调这个监听器对象中的process方法
         */
        zookeeper = new ZooKeeper(CONNECT_STR, TIME_OUT, new Watcher() {
    
          @Override
          public void process(WatchedEvent event) {
            // 哪个znode节点
            String path = event.getPath();
            // 事件的类型
            EventType type = event.getType();
    
            // 如果是 ACTIVE_PARENT 的  NodeChildrenChanged 事件
            // 当active namenode死掉或者增加都会触发process回调
            if (path.equals(ACTIVE_PARENT) && type == EventType.NodeChildrenChanged) {
    
              try {
    
                // 争抢成为active namenode
                List<String> onlyAtiveNM = zookeeper.getChildren(ACTIVE_PARENT, null);
                if (onlyAtiveNM.size() == 0) {
                  // 原来的active namenode死掉了
                  // 正式实现：争抢成为active namenode
                  // 抢锁: 使用创建一个znode来模式实现抢锁，谁创建成功就是谁获取到了这把锁
    
                  // 注册监听
                  // 关注 LOCK_ZNODE 的  NodeCreated 事件
                  zookeeper.exists(LOCK_ZNODE, true);
    
                  // 创建锁节点
                  // 触发了 LOCK_ZNODE 的  NodeCreated 事件
                  if (zookeeper.exists(LOCK_ZNODE, false) == null) {
                    zookeeper.create(LOCK_ZNODE, NAMENODE_HOST.getBytes(),
                            Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
                  }
    
                } else if (onlyAtiveNM.size() == 1) {
                  // 相当于已经有一个anmenode把自己切换成为active了
                  // 所以不需要做什么操作
                }
              } catch (Exception e) {
                e.printStackTrace();
              }
    
            } else if (path.equals(LOCK_ZNODE) && type == EventType.NodeCreated) {
              String namenode_lock_znode = null;
              try {
                // 真正的来判断，谁创建成功的锁节点，如果是自己创建成功的，则切换自己的状态成为 active
                byte[] data = zookeeper.getData(LOCK_ZNODE, false, null);
                // namenode_lock_znode
                // 这个对象 namenode_lock_znode 就是谁创建成功的那个namenode的节点名称
                namenode_lock_znode = new String(data, "UTF-8");
              } catch (Exception e) {
                e.printStackTrace();
              }
    
              // 需要判断，是否是自己创建成功的锁节点
              if (NAMENODE_HOST.equals(namenode_lock_znode)) {
                // 是自己创建成功的锁节点
                // 切换自己的状态
    
                try {
                  // 首先删除自己在  STANDBY_PERENT节点下的该表自己的znode
                  String deletePath = STANBY_PARENT + "/" + NAMENODE_HOST;
                  if (zookeeper.exists(deletePath, false) != null) {
                    zookeeper.delete(deletePath, -1);
                  }
    
                  // 再创建一个znode节点在ACTIVE_PARNET下面
                  String createPath = ACTIVE_PARENT + "/" + NAMENODE_HOST;
                  zookeeper.create(createPath, NAMENODE_HOST.getBytes(),
                          Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
    
                  System.out.println(NAMENODE_HOST + " 注册成为active角色");
    
                } catch (InterruptedException e) {
                  e.printStackTrace();
                } catch (KeeperException e) {
                  e.printStackTrace();
                }
              } else {
    
                // 判断得出结果 锁节点不是自己创建成功，不要成为active
                // 什么都不做
              }
            }
          }
        });
    
    
        /**
         * 执行各种操作
         */
    
        // 确保两个父节点存在
        if (zookeeper.exists(ACTIVE_PARENT, null) == null) {
          zookeeper.create(ACTIVE_PARENT, "storage active namenode data".getBytes(),
                  Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
        if (zookeeper.exists(STANBY_PARENT, null) == null) {
          zookeeper.create(STANBY_PARENT, "storage standby namenode data".getBytes(),
                  Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
    
        // 先来判断是否有active的namenode
        List<String> activeNM = zookeeper.getChildren(ACTIVE_PARENT, null);
        if (activeNM.size() == 1) {
    
          System.out.println(activeNM.get(0) + " 节点是active角色, 自己 " + NAMENODE_HOST + "成为standby角色");
    
          // 如果有active的namenode， 则自动成为 standby的namenode
          // 到 STANBY_PARENT 这个znode节点下，创建一个子节点代表当前这个standby namenode
          String standByPath = STANBY_PARENT + "/" + NAMENODE_HOST;
          zookeeper.create(standByPath, NAMENODE_HOST.getBytes(),
                  Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
    
          // 注册监听：关注现在的active namenode 是否死掉
          // ACTIVE_PARENT 的  NodeChildrenChanged 事件
          // 关心是否 active 的namenode 死掉
          zookeeper.getChildren(ACTIVE_PARENT, true);
        } else {
    
          // 当发现没有active的namenode的时候：
          // 先争抢锁
          // 争抢锁争抢到了的话，就切换自己的状态
          // 注册监听
          // 关注 LOCK_ZNODE 的  NodeCreated 事件
          zookeeper.exists(LOCK_ZNODE, true);
    
          // 创建锁节点
          // 触发了 LOCK_ZNODE 的  NodeCreated 事件
          zookeeper.create(LOCK_ZNODE, NAMENODE_HOST.getBytes(),
                  Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
          System.out.println("发现没有active，去争抢成为" + NAMENODE_HOST + " 节点成为standby节点");
        }
    
        /**
         * 关闭连接
         */
        while (true) {
          try {
            Thread.sleep(10000);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
      }
    }

# 5、执行效果 #

当hadoop02节点启动：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob25ncWkyNTEz_size_16_color_FFFFFF_t_70][]

当hadoop03启动的时候：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob25ncWkyNTEz_size_16_color_FFFFFF_t_70 1][]

当hadoop04启动的时候：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob25ncWkyNTEz_size_16_color_FFFFFF_t_70 2][]

当现在为active的hadoop02宕机的时候：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob25ncWkyNTEz_size_16_color_FFFFFF_t_70 3][]

当hadoop02被宕机的时候，发现最终，hadoop03和hadoop04争抢成为active角色，最后发现hadoop04竞争成功成为active角色

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob25ncWkyNTEz_size_16_color_FFFFFF_t_70]: /images/20220111/2d4d118e4f364932b2898507f978540e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob25ncWkyNTEz_size_16_color_FFFFFF_t_70 1]: /images/20220111/ac678cb2f867446db28ef70996f4d46f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob25ncWkyNTEz_size_16_color_FFFFFF_t_70 2]: /images/20220111/f7502b82c086434693df315070ed4ef4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob25ncWkyNTEz_size_16_color_FFFFFF_t_70 3]: /images/20220111/32c08b7655e44a98911be829afd710af.png