Linux云计算 |【第五阶段】ARCHITECTURE-DAY5

主要内容：

搭建Zookeeper高可用集群、搭建分布式消息队列kafka、搭建高可用hadoop集群

一、Zookeeper 介绍

Zookeeper是一个开源分布式应用程序协调服务，主要用于解决分布式集群中应用系统的一致性问题。它能提供类似文件系统的目录节点树方式的数据存储，主要用途是维护和监控所存数据的状态变化，以实现对集群的管理。而Zookeeper 集群通常由多个 Zookeeper 服务器组成，以提供高可用性和数据一致性。

Zookeeper应用场景：

① 集群分布式共享锁；
② 集群统一命名服务；
③ 分布式协调服务；
④ 队列管理

1、Zookeeper 关键字

1）ZooKeeper Ensemble：

Zookeeper 集群通常称为 Ensemble。一个 Ensemble 至少需要三台服务器，以确保在单台服务器故障时仍能正常工作。

2）Leader 和 Follower：

在 Ensemble 中，服务器分为 Leader 和 Follower。Leader 负责处理所有写请求，并将更改同步到 Followers。读请求可以由任何服务器处理。

3）Quorum：

为了达成一致性，Zookeeper 使用 Quorum 机制。Quorum 是指 Ensemble 中大多数服务器（超过一半）的同意。例如，一个三台服务器的 Ensemble 需要两台服务器的同意。

4）ZNode：

Zookeeper 的数据存储在树形结构中，每个节点称为 ZNode。ZNode 可以是持久性的或临时性的。

2、Zookeeper 角色与选举

1）Leader：

职责：

处理所有写请求。
将写请求的更改同步到所有 Followers。
管理集群的协调和同步。

特点：

只有一个 Leader，负责所有写操作。
Leader 故障时，会触发新的 Leader 选举。

2）Follower：

职责：

处理读请求。
参与 Leader 选举过程。
接收并应用 Leader 同步的写操作。

特点：

可以有多个 Followers。
在 Leader 故障时，参与新的 Leader 选举。

3）Observer（可选）：

职责：

处理读请求。
不参与 Leader 选举和写操作的投票。

特点：

用于扩展读性能，但不影响写操作的 Quorum。
不参与 Leader 选举和写操作的投票。

选举 Leader 遵循过半原则：
Zookeeper 使用 ZAB（Zookeeper Atomic Broadcast）协议来保证数据一致性和 Leader 选举。以下是 Leader 选举的基本过程：

① 初始化：所有服务器启动时，状态为 LOOKING，表示它们正在寻找 Leader。
② 选举消息：每个 LOOKING 状态的服务器会向其他服务器发送选举消息，包含自己的 ID 和最新的 ZXID（事务 ID）。
③ 比较 ZXID：服务器收到选举消息后，会比较 ZXID。ZXID 较大的服务器优先成为 Leader。如果 ZXID 相同，则比较服务器 ID，ID 较大的服务器优先。
④ 投票：每个服务器会向其他服务器发送投票消息，表示支持某个服务器成为 Leader。如果一个服务器收到超过半数的投票支持，它将成为 Leader。
⑤ Leader 确认：成为 Leader 的服务器会向其他服务器发送确认消息，表示自己已成为 Leader。其他服务器收到确认消息后，状态变为 FOLLOWING，表示它们已成为 Follower。
⑥ Leader 服务：Leader 开始处理写请求，并将更改同步到 Followers。Followers 处理读请求，并接收 Leader 同步的写操作。

补充：

- Quorum：选举过程中需要多数服务器（Quorum）的同意。例如，一个三台服务器的 Ensemble 需要两台服务器的同意。
- ZXID：ZXID 是事务 ID，用于比较服务器的数据更新情况。ZXID 较大的服务器优先成为 -Leader。
- 服务器 ID：如果 ZXID 相同，则比较服务器 ID。ID 较大的服务器优先。

3、Zookeeper 高可用

Zookeeper 的高可用性是通过其分布式架构和 Leader 选举机制来实现的。以下是确保 Zookeeper 高可用性的关键点和配置建议：

网络配置：

稳定网络：确保集群中各服务器之间的网络连接稳定，避免网络分区导致脑裂问题
低延迟：尽量减少网络延迟，以提高数据同步和 Leader 选举的效率

硬件配置：

高性能服务器：选择高性能的服务器，确保处理能力和存储容量满足需求
冗余硬件：使用冗余硬件（如 RAID、双电源），提高硬件可靠性

Zookeeper 配置：

tickTime：基本时间单位（毫秒），建议根据网络延迟和性能需求调整
initLimit：Follower 初始化连接到 Leader 的超时时间，建议根据网络延迟调整
syncLimit：Follower 与 Leader 同步的超时时间，建议根据网络延迟调整
dataDir：数据存储目录，建议使用高性能存储设备
clientPort：客户端连接端口，建议使用默认端口 2181

监控和日志：

监控工具：使用如 Zabbix、Prometheus监控 Zookeeper 集群的状态和性能

常见问题和解决方案

网络分区：确保网络稳定，使用冗余网络连接，避免单点故障。
Leader 选举失败：检查网络连接和配置参数，确保 Quorum 机制正常工作。
数据一致性问题：使用 ZAB 协议确保数据一致性，定期备份数据。

4、Zookeeper 可伸缩扩展性原理与设计

在Observer出现之前，Zookeeper的伸缩性由Follower来实现，可以通过添加Follower节点的数量来保证Zookeeper服务的读性能，但是随着Follower节点数量的增加，Zookeeper服务的写性能受到了影响。当客户端提交一个请求，若是读请求，则由每台Server的本地副本数据库直接响应；若是写请求，需要通过一致性协议（Zab）来处理。

Zab协议规定：

来自客户端的所有写请求都要转发给集群中唯一的Leader，当Leader收到一个写请求时，就会发起一个提案进行投票，然后其它的Server对该提案进行投票，之后Leader收集投票的结果，当投票数据量过半时，Leader会向所有的Server发送一个通知消息；最后当客户端所连接的Server收到该消息时，会把该操作更新并对客户端的写请求做出回应。

写性能问题：

① Zookeeper在上述协议中实际扮演了两个职能，一方面从客户端接收连接与操作请求，另一方面对操作结果进行投票，这两个职能在集群扩展的时候彼此制约；
② 从Zab协议对写请求的处理过程中可以发现，增加Follower的数量，则增加了协议投票的过程压力，因为Leader节点必须等待集群中过半Server响应投票，是节点的增加使得部分计算机运行较慢，从而拖慢整个投票过程的可能性也随之提高，随着集群变大，写操作也会随之下降；

解决办法：

为解决增加Follower的写性能问题，不得不在增加集群规模和保持较好吞吐性能之间进行权衡，为了打破这一耦合关系，引入了不参与投票的服务器Observer，Observer可以接受客户端的连接，并将写请求转发给Leader节点，但Leader节点不会要求Observer参加投票；
Observer的扩展，给Zookeeper的可伸缩性带来了全新的景象，加入很多Observer节点，无需担心严重影响写吞吐量，Observer提升读性能的可伸缩性，并且还提供了广域网能力；
但Observer因为协议中的通知阶段，仍然与服务器的数量呈线性关系，但是这里的串行开销非常低，因此，可以认为在通知服务器阶段不会成为瓶颈。

5、Zookeeper 配置步骤

- Zookeeper安装目录：/usr/local/zookeeper
- Zookeeper配置目录：/usr/local/zookeeper/conf/

① 安装 Zookeeper：

下载 Zookeeper 并解压到指定目录；配置环境变量 ZOOKEEPER_HOME 和 PATH

② 配置文件：

在 Zookeeper 的配置目录中创建 zoo.cfg 文件，配置示例：

tickTime=2000
dataDir=/var/lib/zookeeper
clientPort=2181
initLimit=5
syncLimit=2
server.1=zoo1:2888:3888
server.2=zoo2:2888:3888
server.3=zoo3:2888:3888

tickTime：基本时间单位（毫秒）。
dataDir：数据存储目录。
clientPort：客户端连接端口。
initLimit：Follower 初始化连接到 Leader 的超时时间。
syncLimit：Follower 与 Leader 同步的超时时间。
server.X：指定每个服务器的地址和端口。

③ 创建 myid 文件：

在 dataDir 目录下创建 myid 文件，内容为服务器的 ID（如 1、2、3）。

④ 启动 Zookeeper 服务：

在每台服务器上启动 Zookeeper 服务：

$ZOOKEEPER_HOME/bin/zkServer.sh start

⑤ 验证集群状态：确保每台服务器的状态正确（Leader 或 Follower）

$ZOOKEEPER_HOME/bin/zkServer.sh status

Zookeeper集群部署示例：

zookeeper集群图例：

主机名称	IP地址	相关配置	角色
hadpoo1	192.168.1.50	最低配置2核4G	Observer
node-0001	192.168.1.51	最低配置2核4G	自动选举分配
node-0002	192.168.1.52	最低配置2核4G	自动选举分配
node-0003	192.168.1.53	最低配置2核4G	自动选举分配

建议：重启4台云主机hadoop1、node-000、,node-0002、node-0003（清理缓存）

步骤1：配置Zookeeper，并同步安装目录给其他主机（hadoop1操作）

# 拷贝云盘public/hadoop/zookeeper-3.4.13.tar.gz到hadoop1

[root@ecs-proxy hadoop]# scp zookeeper-3.4.13.tar.gz 192.168.1.50:/root

① 安装JAVA运行环境，并准备Zookeepeer安装目录（已完成）

[root@hadoop1 ~]# yum install -y java-1.8.0-openjdk-devel
[root@hadoop1 ~]# tar -zxf zookeeper-3.4.13.tar.gz
[root@hadoop1 ~]# mv zookeeper-3.4.13 /usr/local/zookeeper
[root@hadoop1 ~]# cd /usr/local/zookeeper/
[root@hadoop1 zookeeper]# ls

② 修改配置文件（/usr/local/zookeeper/conf/zoo.cfg）

补充：Zookeeper配置文件默认是单机模式（Standalone），如果组建集群，在配置文件末尾添加集群节点成员，即成为集群模式

[root@hadoop1 zookeeper]# cd conf/     //切换到配置目录
[root@hadoop1 conf]# cp zoo_sample.cfg zoo.cfg     //拷贝配置模板文件
[root@hadoop1 conf]# vim zoo.cfg
server.1=node-0001:2888:3888      //自动选举leader\follower角色，无需指定
server.2=node-0002:2888:3888
server.3=node-0003:2888:3888
server.4=hadoop1:2888:3888:observer     //不参与投票，指定observer角色

说明：server.运行id=主机名称:端口:范围:Observer角色

解释：server表示服务，.1表示运行id（唯一），主机名，2888,3888为通信端口

注意：要保证主机名能够被解析且互相能够Ping通，主机名和server.id为对应关系

③ 同步Hadoop1的/usr/local/zookeeper安装目录到所有node主机

[root@hadoop1 conf]# for i in node-{0001..0003};do
> rsync -aXSH --delete /usr/local/zookeeper ${i}:/usr/local/
> done

步骤2：手工启动Zookeeper服务（hadoop1、node-0001、node-0002、node-0003操作）

# 根据Zookeeper配置文件中的dataDir定义，需在所有节点创建数据存储目录

[root@hadoop1 conf]# cat zoo.cfg

① 创建数据存储目录（以hadoop1为例）

[root@hadoop1 ~]# mkdir /tmp/zookeeper

② 创建myid文件，文件内容为主机运行id

# 本机的server.id与myid文件中的id必须对应，id的范围是1~255

[root@hadoop1 ~]# grep -Po "\d+(?==${HOSTNAME})" /usr/local/zookeeper/conf/zoo.cfg > /tmp/zookeeper/myid      //扩展：零宽断言
[root@hadoop1 ~]# cat /tmp/zookeeper/myid       //Hadoop1对应的id为4
4

② 启动集群服务

[root@hadoop1 ~]# /usr/local/zookeeper/bin/zkServer.sh start

③ 验证角色

[root@hadoop1 ~]# jps

④ 当所有节点集群服务启动完成后，使用命令验证

[root@hadoop1 ~]# for i in hadoop1 node-{0001..0003};do
> echo ${i};
> ssh ${i} "/usr/local/zookeeper/bin/zkServer.sh status"
> echo -e "\n";
> done

常见报错：查看角色，必须启动超过半数的机器才能选举角色，当节点未全部完成服务启动，即集群节点数量不足一半，查看状态会显示Error

Zookeeper集群管理示例：

[管理手册地址]：ZooKeeper Administrator's Guide

手册提供了一些简单的四字命令，用来管理集群；通过网络访问Zookeeper端口，来实现集群的状态查询，例如：健康状态ruok、配置文件conf、集群状态mntr

例如1：测试四字命令，需通过socat工具来实现网络接口、数据报文格式发送；

[root@hadoop1 ~]# yum install -y socat        //安装socat工具
[root@hadoop1 ~]# socat - TCP:node-0001:2181
ruok         //监测健康状态（交互界面）
imok

说明：标准输入ruok，转发给第二个地址处理，并通过标准输出返回结果imok；

解释：socat用途是把一组数据发送给第一个地址，再转发给第二个地址，让两个地址之间能够互相传输和通信；默认需要2组参数：

① -为占位符，表示默认地址，而默认地址即本地的标准输入输出键盘、鼠标显示器；

② 第二个地址是网络地址，协议是TCP、主机、端口号

[root@hadoop1 ~]# socat - TCP:node-0001:2181
conf         //配置文件conf

[root@hadoop1 ~]# socat - TCP:node-0001:2181
mntr          //集群状态mntr

例如2：使用zkstats脚本，查看Zookeeper各个服务器角色

[root@ecs-proxy ~]# scp zkstats 192.168.1.50:/root
[root@hadoop1 ~]# cat zkstats
#!/bin/bash
function getzkstat(){    //定义函数
    exec 2>/dev/null
    exec 8<>/dev/tcp/$1/2181
    echo stat >&8
    Msg=$(cat <&8 |grep -P "^Mode:")
    exec 8<&-
    printf "%15s " $1
    echo -e "${Msg:-Mode: \x1b[31mNULL\x1b[0m}"
}
 
if (( $# == 0 ));then
    echo "${0##*/} zk1 zk2 zk3 ... ..."
else
    for i in $@;do
        getzkstat ${i}
    done
fi

[root@hadoop1 ~]# chmod +x zkstats            //授予执行权限
[root@hadoop1 ~]# ./zkstats hadoop1 node-{0001..0003}
        hadoop1 Mode: observer
      node-0001 Mode: follower
      node-0002 Mode: leader
      node-0003 Mode: follower

二、分布式消息队列Kafka

Kafka是由Linkedln开发的一个分布式、高吞吐量、高扩展性的消息队列系统，使用Scale编写，是一个消息中间件，主要应用在日志收集系统和消息系统，它具有高吞吐量、低延迟、可扩展性和容错性等特点。其他的消息队列中间件比如RabbitMQ、AcitveMQ。

1、Kafka的架构与设计

一个Kafka集群包含一个或多个的Producer，一个或多个的Broker，一个或多个的Consumer Group，和一个Zookeeper集群。Kafka通过Zookeeper管理集群配置，管理集群在运行过程中负责均衡、故障转移和恢复；Producer使用Push（推送）的方式将消息发布到Broker，Consumer使用Pull（拉取）的方式从Broker获取消息，两者都是主动操作的。

集群结构示例：

图中包含了2个Producer（生产者），一个Topic（主题），3个Partition（分区），3个Replica（副本），3个Broker（Kafka实例或节点），一个Consumer Group（消费者组），其中包含3个Consumer（消费者）

2、集群的角色：

① Producer 生产者

负责发布消息，生产者每发送一个条消息必须有一个Topic（主题），也可以说是消息的类别，生产者源源不断的向kafka服务器发送消息。

定义：生产者是向 Kafka 发布消息的应用程序。
职责：将消息发送到指定的 Topic 和分区。

② Topic主题

每一个发送到Kafka的消息都有一个主题，也可叫做一个类别；

定义：Topic 是消息的逻辑分类，生产者将消息发布到特定的 Topic，消费者订阅 Topic 以接收消息。
分区：每个 Topic 可以分为多个分区（Partition），分区是 Kafka 并行处理和扩展性的基础。

③ Partition 分区

生产者发送的消息数据Topic会被存储在分区中，这个分区的概念和ElasticSearch中分片的概念是一致的，都是想把数据分成多个块，好达到负载均衡的效果；

定义：分区是 Topic 的物理存储单元，分布在不同的 Broker 上。
特点：每个分区是一个有序的、不可变的消息序列，新消息被追加到分区的末尾。

④ Replica 副本

副本就是分区中数据的备份，是Kafka为了防止数据丢失或者服务器宕机采取的保护数据完整性的措施；

⑤ Broker 实例或节点

即Kafka的实例，启动一个Kafka就是一个Broker，多个Broker构成一个Kafka集群，这就是分布式的体现，服务器多了自然吞吐率效率提升。

定义：Kafka 集群中的每个服务器称为 Broker。
职责：负责存储和处理消息，处理生产者和消费者的请求。

⑥ consumer 消费者

Consume消费者来读取Kafka中的消息，可以消费任何Topic的数据，多个Consume组成一个消费者组，一般的一个消费者必须有一个组（Group）名，如果没有的话会被分一个默认的组名。

定义：消费者是从 Kafka 订阅和读取消息的应用程序。
职责：从指定的 Topic 和分区读取消息，并处理这些消息。

Kafka对消息保存时根据Topic进行归类，发送消息者成为Producer，消息接受者成为Consumer，此外Kafka集群有多个Kafka实例组成，每个实例(server)成为broker。无论是Kafka集群，还是producer和consumer都依赖于zookeeper来保证系统可用性集群保存一些meta元数据，Kafka将元数据信息保存到Zookeeper中，Broker会在Zookeeper注册并保持相关的元数据更新；

3、Kafka 核心概念

消息（Message）：

定义：消息是 Kafka 中的基本数据单元，包含数据和元数据。
特点：消息被发布到 Topic 并存储在分区中。

偏移量（Offset）：

定义：偏移量是分区中每条消息的唯一标识符，表示消息在分区中的位置。
特点：消费者通过偏移量来跟踪已消费的消息。

副本（Replica）：

定义：副本是分区的备份，分布在不同的 Broker 上，确保数据的容错性。
特点：每个分区有一个 Leader 副本和多个 Follower 副本，Leader 处理读写请求，Follower 同步 Leader 的数据。

ISR（In-Sync Replica）：

定义：ISR 是与 Leader 保持同步的副本集合。
特点：只有 ISR 中的副本才能参与 Leader 选举和写操作。

- Kafka安装目录：/usr/local/kafka

- Kafka配置文件：/usr/local/kafka/config/server.properties

Kafka集群部署示例：

主机名称	IP地址	相关配置	角色
hadpoo1	192.168.1.50	最低配置2核4G	Observer
node-0001	192.168.1.51	最低配置2核4G	自动选举分配
node-0002	192.168.1.52	最低配置2核4G	自动选举分配
node-0003	192.168.1.53	最低配置2核4G	自动选举分配

步骤1：安装配置 kafka，并同步给其他主机（hadoop1操作）

# 拷贝云盘 public/hadoop/kafka_2.12-2.1.0.tgz 到 hadoop1

[root@ecs-proxy hadoop]# scp kafka_2.12-2.1.0.tgz 192.168.1.50:/root
[root@hadoop1 ~]# tar -zxf kafka_2.12-2.1.0.tgz
[root@hadoop1 ~]# mv kafka_2.12-2.1.0 /usr/local/kafka
[root@hadoop1 ~]# ls /usr/local/kafka/

[root@hadoop1 ~]# for i in node-{0001..0003};do
> rsync -aXSH --delete /usr/local/kafka ${i}:/usr/local/
> done

步骤2：修改配置文件并启动服务（node-0001、node-0002、node-0003操作）

[root@node-0001 ~]# vim /usr/local/kafka/config/server.properties
21   broker.id=1       //broker.id，集群中唯一标识（不能冲突）
123  zookeeper.connect=node-0001:2181,node-0002:2181,node-0003:2181    // 指定zookeeper集群地址
[root@node-0001 ~]# /usr/local/kafka/bin/kafka-server-start.sh -daemon /usr/local/kafka/config/server.properties     //启动所有主机的服务

补充：broker.id为每一个broker在集群中的唯一标识，要求是正数。当该服务器的IP地址发生改变时，broker.id没有变化，则不会影响consumers的消息情况；

步骤3：验证集群服务，发布订阅（不同主机上执行）

① Node-0001上，创建topic的消息类别

[root@node-0001 ~]# /usr/local/kafka/bin/kafka-topics.sh --create --partitions 1 --replication-factor 1 --zookeeper localhost:2181 --topic mymsg
Created topic "mymsg".

② Node-0002上，运行生产者程序

[root@node-0002 ~]# /usr/local/kafka/bin/kafka-console-producer.sh --broker-list  localhost:9092 --topic mymsg
>

③ Node-0003上，运行消费者程序

[root@node-0003 ~]# /usr/local/kafka/bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic mymsg

# 在Node-0002上随意输入字符串或其他，查看Node-0003是否同步

三、Hadoop高可用集群

1、NameNode高可用

想实现Hadoop高可用就必须实现NameNode的高可用，NameNode是HDFS的核心，HDFS又是Hadoop的核心组件，所以NameNode在Hadoop集群中至关重要；

NameNode宕机，将导致整个集群不可用，且NameNode上存储了文件块映射信息表，如果NameNode数据丢失将导致整个集群的数据丢失，而NameNode的数据的更新又比较频繁，所以NameNode的高可用配置势在必行；

官方提供了两种解决方案：

① HDFS with NFS
② HDFS with QJM

方案对比：

① 都能实现热备；
② 都是一个Active和一个Standby；
③ 都使用Zookeeper和ZKFC来实现高可用；
④ NFS方案：把数据存储在共享存储里，还需要考虑NFS的高可用设计；
⑤ QJM方案：不需要共享存储，但需要让每一个DataNode都知道两个NameNode的位置，并把块信息和心跳包发送给Active和Standby这两个NameNode；

2、QJM方案分析

为HDFS集群配置两个NameNode，一个处于Active状态，另一个处于Standby状态，Active NameNode对外提供服务，而Standby则仅监听和同步Active的状态，以便能够在Active失效时进行切换；在任何时候只能有一个NameNode处于活动状态，如果出现两个Active NameNode（这种情况通常称为“split-brain脑裂”，三个节点通讯阻断）会导致集群操作混乱，可能会导致数据丢失或状态异常；

① fsimage数据块映射信息，一致性

NameNode更新很频繁，为了保持主备数据的一致性，为了支持快速Failover故障切换，Standby NameNode持有集群中block块映射信息表的最新位置是非常必要的，为了达到这一目的，DataNodes上需要同时配置这两个NameNode的地址，同时和它们都建立心跳连接，并把客户端存储的block块信息位置汇报给两个NameNode生成fsimage，从而实现一致性；

② fsedit数据变更日志，主从同步

为了让Standby NameNode与Active NameNode保持同步，这两个NameNode都与一组称为JNS的互相独立的进程保持通信（Journal Nodes），当Active NameNode更新了，它将记录修改日志发送给Journal Node，Standby Node将会从Journal Node中读取这些日志，将日志变更应用在自己的数据中，并持续关注它们对日志的变更；

③ 主备切换

当Failover故障发生时，Standby Node首先读取Journal Node中所有的日志，并将它应用到自己的数据中；

获取Journal Node写权限：对于Journal Node而言，任何时候只允许一个NameNode作为Writer，在Failover期间，原来的Standby NameNode将会接管Active的所有职能，并负责向Journal Node写入日志记录；提升自己为Active NameNode；

高可用架构图：

- ZK为Zookeeper集群，用来存储元数据，保证元数据的一致性；
- Failover Controller为ZKFC，用来监控NameNode的存活状态；
- Journal Nodes用来记录Active NameNode的修改日志

Hadoop高可用集群部署示例：

高可用架构图：

- HDFS：NameNode —> DataNode
- YARN：ResourceManager —> NodeManager
- Zookeeper：QuorumPeerMain
- Journal Node：JournalNode
- ZKFC：DFSZKFailoverController

主机规划配置

步骤1：Standby NameNode节点-环境准备

① 配置主机名解析文件（hadoop1操作）

[root@hadoop1 ~]# vim /etc/hosts
192.168.1.50    hadoop1
192.168.1.56    hadoop2         //添加hadoop2
192.168.1.51    node-0001
192.168.1.52    node-0002
192.168.1.53    node-0003

② 同步SSH密钥给hadoop2主机

[root@hadoop1 ~]# rsync -aXSH --delete /root/.ssh hadoop2:/root/

补充：将整个/root/.ssh/目录中私钥和密钥同步到hadoop2，实现免密登录其它节点；

③ 同步主机名解析文件给所有主机

[root@hadoop1 ~]# for i in hadoop2 node-{0001..0003};do
> rsync -av /etc/hosts ${i}:/etc/
> done

④ 安装JAVA运行环境（hadoop2操作）

[root@hadoop2 ~]# yum install -y java-1.8.0-openjdk-devel

⑤ 禁用ssh key检测

[root@hadoop2 ~]# vim /etc/ssh/ssh_config
60: StrictHostKeyChecking no

步骤2：HDFS集群配置部署（hadoop1操作）

官方手册：Apache Hadoop 2.7.7 – HDFS High Availability Using the Quorum Journal Manager

① 修改环境配置文件：hadoop-env.sh

[root@hadoop1 ~]# vim /usr/local/hadoop/etc/hadoop/hadoop-env.sh
25:  export JAVA_HOME="/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.292.b10-1.el7_9.x86_64/"
33:  export HADOOP_CONF_DIR="/usr/local/hadoop/etc/hadoop"

② 修改节点配置文件：slaves

[root@hadoop1 ~]# vim /usr/local/hadoop/etc/hadoop/slaves
node-0001
node-0002
node-0003

③ 修改核心配置文件：core-site.xml

[root@hadoop1 ~]# vim /usr/local/hadoop/etc/hadoop/core-site.xml
<configuration>
    <property>
        <name>fs.defaultFS</name>           //定义文件系统
        <value>hdfs://mycluster</value>     //指定NameNode组（与后面的定义组名要一致）
    </property>
    <property>
        <name>hadoop.tmp.dir</name>     //数据目录配置参数
        <value>/var/hadoop</value>      //定义数据存放目录
    </property>
    <property>
        <name>ha.zookeeper.quorum</name>     //指定Zookeeper集群服务地址
        <value>node-0001:2181,node-0002:2181,node-0003:2181</value>
    </property>
    <property>
        <name>hadoop.proxyuser.nfsuser.groups</name>   //NFSGW相关授权（不影响）
        <value>*</value>
    </property>
    <property>
        <name>hadoop.proxyuser.nfsuser.hosts</name>    //NFSGW相关授权（不影响）
        <value>*</value>
    </property>
</configuration>

补充1：指定文件系统时，无法确定哪台NameNode作为Active节点，所以指定组

补充2：指定Zookeeper集群节点地址时，同时配置多个节点防止单点故障；

④ 修改分布式文件系统配置文件：hdfs-site.xml

[root@hadoop1 ~]# vim /usr/local/hadoop/etc/hadoop/hdfs-site.xml
<configuration>
    <property>
        <name>dfs.nameservices</name>    //定义NameNode组名（与core-site保持一致）
        <value>mycluster</value>
    </property>
    <property>
        <name>dfs.ha.namenodes.mycluster</name>      //定义HDFS服务中的角色
        <value>nn1,nn2</value>      //nn1代表NameNode1，nn2代表NameNode2
    </property>
    <property>
        <name>dfs.namenode.rpc-address.mycluster.nn1</name>   //定义角色nn1对应主机
        <value>hadoop1:8020</value>     //指定rpc地址及端口
    </property>
    <property>
        <name>dfs.namenode.rpc-address.mycluster.nn2</name>   //定义角色nn2对应主机
        <value>hadoop2:8020</value>     //指定rpc地址及端口
    </property>
    <property>
        <name>dfs.namenode.http-address.mycluster.nn1</name> //定义角色nn1对应NameNode1
        <value>hadoop1:50070</value>    //指定NameNode1的地址及端口号
    </property>
    <property>
        <name>dfs.namenode.http-address.mycluster.nn2</name>  //定义角色nn2对应NameNode1
        <value>hadoop2:50070</value>    //指定NameNode2的地址及端口号
    </property>
    <property>
        <name>dfs.namenode.shared.edits.dir</name>   //定义JournalNode集群的地址及端口号
        <value>qjournal://node-0001:8485;node-0002:8485;node-0003:8485/mycluster</value>
    </property>
    <property>
        <name>dfs.journalnode.edits.dir</name>     //定义JournalNode的数据存放地址
        <value>/var/hadoop/journal</value>
    </property>
    <property>
        <name>dfs.client.failover.proxy.provider.mycluster</name>    //Failover类服务名
        <value>org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider</value>
    </property>
    <property>
        <name>dfs.ha.fencing.methods</name>     //远程管理方式
        <value>sshfence</value>       //使用SSH远程管理
    </property>
    <property>
        <name>dfs.ha.fencing.ssh.private-key-files</name>     //定义SSH私钥的位置
        <value>/root/.ssh/id_rsa</value>      //SSH私钥存放地址
    </property>
    <property>
        <name>dfs.ha.automatic-failover.enabled</name>    //开启故障转移切换功能
        <value>true</value>
    </property>
    <property>
        <name>dfs.replication</name>        //定义副本数量
        <value>2</value>
    </property>
    <property>
        <name>dfs.hosts.exclude</name>      //移除主机列表（不影响）
        <value>/usr/local/hadoop/etc/hadoop/exclude</value>
    </property>
</configuration>

步骤3：Mapreduce分布式离线计算框架（Hadoop1操作）

① 修改计算框架配置文件：mapred-site.xml

[root@hadoop1 ~]# vim /usr/local/hadoop/etc/hadoop/mapred-site.xml
<configuration>
    <property>
        <name>mapreduce.framework.name</name>      //定义资源管理类
        <value>yarn</value>
    </property>
</configuration>

步骤4：YARN集群配置部署（Hadoop1操作）

① 修改资源管理配置文件：yarn-site.xml

[root@hadoop1 ~]# vim /usr/local/hadoop/etc/hadoop/yarn-site.xml
<configuration>
    <property>
        <name>yarn.resourcemanager.ha.enabled</name>    //激活HA配置
        <value>true</value>
    </property>
    <property>
        <name>yarn.resourcemanager.recovery.enabled</name>   //管理节点状态自动恢复
        <value>true</value>
    </property>
    <property>
        <name>yarn.resourcemanager.store.class</name>    //数据状态保存介质
        <value>org.apache.hadoop.yarn.server.resourcemanager.recovery.ZKRMStateStore</value>
    </property>
    <property>
        <name>yarn.resourcemanager.zk-address</name>    //Zookeeper服务器地址
        <value>node-0001:2181,node-0002:2181,node-0003:2181</value>
    </property>
    <property>
        <name>yarn.resourcemanager.cluster-id</name>    //定义集群ID
        <value>yarn-ha</value>
    </property>
    <property>
        <name>yarn.resourcemanager.ha.rm-ids</name>    //定义两个RM的角色
        <value>rm1,rm2</value>
    </property>
    <property>
        <name>yarn.resourcemanager.hostname.rm1</name>   //rm1对应主机地址
        <value>hadoop1</value>
    </property>
    <property>
        <name>yarn.resourcemanager.hostname.rm2</name>   //rm2对应主机地址
        <value>hadoop2</value>
    </property>
<!-- Site specific YARN configuration properties -->
    <property>
        <name>yarn.nodemanager.aux-services</name>   //计算框架配置
        <value>mapreduce_shuffle</value>
    </property>
</configuration>

步骤5：初始化启动集群

# 重启所有机器，包括hadoop1、hadoop2、node-0001、node-0002、node-0003

① 启动Zookeeper（node-0001、node-0002、node-0003操作）

[root@node-0001 ~]# /usr/local/zookeeper/bin/zkServer.sh start
[root@node-0002 ~]# /usr/local/zookeeper/bin/zkServer.sh start
[root@node-0003 ~]# /usr/local/zookeeper/bin/zkServer.sh start

# 在hadoop1上，使用脚本验证

[root@hadoop1 ~]# ./zkstats node-{0001..0003}      //投票自动选举
      node-0001 Mode: follower
      node-0002 Mode: leader
      node-0003 Mode: follower

② 清空日志和实验数据，并同步配置文件（hadoop1操作）

[root@hadoop1 ~]# rm -rf /var/hadoop/* /usr/local/hadoop/logs
[root@hadoop1 ~]# for i in hadoop2 node-{0001..0003};do
> rsync -av /etc/hosts ${i}:/etc/
> rsync -aXSH --delete /var/hadoop ${i}:/var/
> rsync -aXSH --delete /usr/local/hadoop ${i}:/usr/local/
> done

③ 启动 JournalNode 服务（node-0001、node-0002、node-0003操作）

[root@node-0001 ~]# /usr/local/hadoop/sbin/hadoop-daemon.sh start journalnode
starting journalnode, logging to /usr/local/hadoop/logs/hadoop-root-journalnode-node-0001.out
[root@node-0001 ~]# jps

[root@node-0002 ~]# /usr/local/hadoop/sbin/hadoop-daemon.sh start journalnode
[root@node-0003 ~]# /usr/local/hadoop/sbin/hadoop-daemon.sh start journalnode

④ 初始化集群（hadoop1操作）

# 格式化Zookeeper

[root@hadoop1 ~]# /usr/local/hadoop/bin/hdfs zkfc -formatZK

# 格式化HDFS

[root@hadoop1 ~]# /usr/local/hadoop/bin/hdfs namenode -format

# 格式化JournalNode

[root@hadoop1 ~]# /usr/local/hadoop/bin/hdfs namenode -initializeSharedEdits

补充：格式化的本质就是生成数据结构，其中包括随机的UUID，主节点和备节点的UUID要求保持一致，所以需要将主节点的数据结构拷贝给备节点，实现数据结构一致；

[root@hadoop1 ~]# tree /var/hadoop/

# 拷贝hadoop1的数据结构给hadoop2

[root@hadoop1 ~]# rsync -aXSH --delete /var/hadoop/dfs hadoop2:/var/hadoop/

⑤ 停止JournalNode 服务（node-0001、node-0002、node-0003操作）

[root@node-0001 ~]# /usr/local/hadoop/sbin/hadoop-daemon.sh stop journalnode
stopping journalnode
[root@node-0002 ~]# /usr/local/hadoop/sbin/hadoop-daemon.sh stop journalnode
stopping journalnode
[root@node-0003 ~]# /usr/local/hadoop/sbin/hadoop-daemon.sh stop journalnode
stopping journalnode

⑥ 启动集群（hadoop1、hadoop2操作）

[root@hadoop1 ~]# /usr/local/hadoop/sbin/start-all.sh

[root@hadoop2 ~]# /usr/local/hadoop/sbin/yarn-daemon.sh start resourcemanager

步骤6：验证集群

[root@hadoop1 ~]# /usr/local/hadoop/bin/hdfs haadmin -getServiceState nn1
standby
[root@hadoop1 ~]# /usr/local/hadoop/bin/hdfs haadmin -getServiceState nn2
active
[root@hadoop1 ~]# /usr/local/hadoop/bin/yarn rmadmin -getServiceState rm1
active
[root@hadoop1 ~]# /usr/local/hadoop/bin/yarn rmadmin -getServiceState rm2
standby
[root@hadoop1 ~]# /usr/local/hadoop/bin/hdfs dfsadmin -report

[root@hadoop1 ~]# /usr/local/hadoop/bin/yarn node -list

步骤7：使用高可用集群分析数据

[root@hadoop1 ~]# cd /usr/local/hadoop
[root@hadoop1 hadoop]# ./bin/hadoop fs -mkdir /input
[root@hadoop1 hadoop]# ./bin/hadoop fs -put *.txt /input/
[root@hadoop1 hadoop]# ./bin/hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-2.7.7.jar wordcount /input /output
[root@hadoop1 hadoop]# ./bin/hadoop fs -cat /output/*

步骤8：验证高可用服务

① 查看当前角色身份状态

[root@hadoop1 ~]# /usr/local/hadoop/bin/hdfs haadmin -getServiceState nn1
standby      //nn1为Hadoop1（备节点）
[root@hadoop1 ~]# /usr/local/hadoop/bin/hdfs haadmin -getServiceState nn2
active       //nn2为Hadoop2（主节点）

② 停止hadoop2的NameNode服务，查看角色身份状态是否切换

[root@hadoop2 ~]# /usr/local/hadoop/sbin/hadoop-daemon.sh stop namenode
stopping namenode

[root@hadoop1 ~]# /usr/local/hadoop/bin/hdfs haadmin -getServiceState nn2

[root@hadoop1 ~]# /usr/local/hadoop/bin/hdfs haadmin -getServiceState nn1
active

③ 开启hadoop2的NameNode服务，查看角色身份状态变化

[root@hadoop2 ~]# /usr/local/hadoop/sbin/hadoop-daemon.sh start namenode
starting namenode, logging to /usr/local/hadoop/logs/hadoop-root-namenode-hadoop2.out

[root@hadoop1 hadoop]# /usr/local/hadoop/bin/hdfs haadmin -getServiceState nn1
active
[root@hadoop1 hadoop]# /usr/local/hadoop/bin/hdfs haadmin -getServiceState nn2
standby

小结：

本篇章节为【第五阶段】ARCHITECTURE-DAY5 的学习笔记，这篇笔记可以初步了解到搭建Zookeeper高可用集群、搭建分布式消息队列kafka、搭建高可用hadoop集群，除此之外推荐参考相关学习网址：

Tip：毕竟两个人的智慧大于一个人的智慧，如果你不理解本章节的内容或需要相关笔记、视频，可私信小安，请不要害羞和回避，可以向他人请教，花点时间直到你真正的理解。