Zookeeper+Hadoop+Spark+Flink+Kafka+Hbase+Hive

说明

Zookeeper+Hadoop+Spark+Flink+Kafka+Hbase+Hive 完全分布式高可用集群搭建

下载

https://archive.apache.org/dist/

Mysql下载地址

Index of /MySQL/Downloads/

我最终选择 Zookeeper3.7.1 +Hadoop3.3.5 + Spark-3.2.4 + Flink-1.16.1 + Kafka2.12-3.4.0 + HBase2.4.17 + Hive3.1.3** +JDK1.8.0_391**

一、服务器

IP规划
IPhostname192.168.1.5node1192.168.1.6node2192.168.1.7node3

二、系统配置

2.1配置hostname、ip

hostnamectl set-hostname node1
hostnamectl set-hostname node2
hostnamectl set-hostname node3

2.2编辑hosts

vim /etc/hosts

[root@node1 ~]# cat >> /etc/hosts << EOF
192.168.1.5 node1
192.168.1.6 node2
192.168.1.7 node3
EOF
[root@node1 ~]# for i in {5,6,7}
do
scp /etc/hosts 192.168.1.$i:/etc/hosts
done

2.3优化ssh连接

优化ssh连接

#优化ssh连接速度
vim /etc/ssh/sshd_config
UseDNS no
GSSAPIAuthentication no
#或者写成
sed -i 's/#UseDNS\ yes/UseDNS\ no/g; s/GSSAPIAuthentication\ yes/GSSAPIAuthentication\ no/g' /etc/ssh/sshd_config
systemctl restart sshd

2.4配置时间同步

#以node1为服务端
[root@node1 ~]# yum install chrony -y
[root@node1 ~]# grep -vE '^#|^$' /etc/chrony.conf 
pool ntp.aliyun iburst
driftfile /var/lib/chrony/drift
makestep 1.0 3
rtcsync
allow 192.168.0.0/24
local stratum 10
logdir /var/log/chrony
[root@node1 ~]# systemctl enable --now chronyd
[root@node1 ~]# chronyc sources -v
210 Number of sources = 1
  .-- Source mode  '^' = server, '=' = peer, '#' = local clock.
 / .- Source state '*' = current synced, '+' = combined , '-' = not combined,
| /   '?' = unreachable, 'x' = time may be in error, '~' = time too variable.
||                                                 .- xxxx [ yyyy ] +/- zzzz
||      Reachability register (octal) -.           |  xxxx = adjusted offset,
||      Log2(Polling interval) --.      |          |  yyyy = measured offset,
||                                \     |          |  zzzz = estimated error.
||                                 |    |           \
MS Name/IP address         Stratum Poll Reach LastRx Last sample               
===============================================================================
^* 203.107.6.88                  2   6     7     0    +54ms[  +69ms] +/-  193ms
#其他节点为客户端
#node2配置
[root@node2 ~]# yum install chrony -y
[root@node2 ~]# grep -vE '^#|^$' /etc/chrony.conf
pool 192.168.1.11 iburst
driftfile /var/lib/chrony/drift
makestep 1.0 3
rtcsync
logdir /var/log/chrony
[root@node2 ~]# systemctl enable --now chronyd
#验证
[root@node2 ~]# chronyc sources -v
210 Number of sources = 1
  .-- Source mode  '^' = server, '=' = peer, '#' = local clock.
 / .- Source state '*' = current synced, '+' = combined , '-' = not combined,
| /   '?' = unreachable, 'x' = time may be in error, '~' = time too variable.
||                                                 .- xxxx [ yyyy ] +/- zzzz
||      Reachability register (octal) -.           |  xxxx = adjusted offset,
||      Log2(Polling interval) --.      |          |  yyyy = measured offset,
||                                \     |          |  zzzz = estimated error.
||                                 |    |           \
MS Name/IP address         Stratum Poll Reach LastRx Last sample               
===============================================================================
^? node1                         0   6     0     -     +0ns[   +0ns] +/-    0ns
#node3配置
[root@node3 ~]# yum install chrony -y
[root@node3 ~]# scp 192.168.1.12:/etc/chrony.conf /etc/chrony.conf
[root@node3 ~]# systemctl enable --now chronyd
#验证
[root@node3 ~]# chronyc sources -v
210 Number of sources = 1
  .-- Source mode  '^' = server, '=' = peer, '#' = local clock.
 / .- Source state '*' = current synced, '+' = combined , '-' = not combined,
| /   '?' = unreachable, 'x' = time may be in error, '~' = time too variable.
||                                                 .- xxxx [ yyyy ] +/- zzzz
||      Reachability register (octal) -.           |  xxxx = adjusted offset,
||      Log2(Polling interval) --.      |          |  yyyy = measured offset,
||                                \     |          |  zzzz = estimated error.
||                                 |    |           \
MS Name/IP address         Stratum Poll Reach LastRx Last sample               
===============================================================================
^? node1                         0   6     0     -     +0ns[   +0ns] +/-    0ns

2.5关闭防火墙和selinux

#永久关闭防火墙
[root@node1 ~]#for i in {5,6,7}
do
ssh 192.168.1.$i "systemctl disable --now firewalld"
done
#永久关闭selinux
[root@node1 ~]# for i in {5,6,7}
do
ssh 192.168.1.$i "setenforce 0 && sed -i s/SELINUX=enforcing/SELINUX=disabled/g /etc/selinux/config"
done

2.6修改文件打开限制

[root@node1 ~]# vim /etc/security/limits.conf
#End of file
* soft nofile 65536
* hard nofile 65536
* soft nproc 131072
* hard nproc 131072
[root@node1 ~]# for i in {node2,node3}
do
scp /etc/security/limits.conf $i:/etc/security/limits.conf
done

2.7JDK环境

本次安装hadoop3.3.5，根据官网描述Apache Hadoop 3.3.5需要Java 8以上或Java 11才能运行，这里建议使用Java 8;查看habase与jdk对应版本，根据官方描述，建议安装使用 JDK8

上传jdk-8u391-linux-x64.tar.gz

解压

tar -zxvf jdk-8u391-linux-x64.tar.gz -C /usr/local

配置java环境变量
[root@node1 ~]# cat >> .bash_profile  << 'EOF'
#Java环境变量
export JAVA_HOME=/usr/local/jdk1.8.0_391
export PATH=$PATH:$JAVA_HOME/bin
EOF
#让配置环境变量生效
[root@node1 ~]# source .bash_profile
#其他节点重复上述步骤安装，或者直接发送过去
[root@node1 ~]# for i in {node2,node3}
do
scp -r /usr/local/jdk1.8.0_391/ $i:/usr/local/
scp /root/.bash_profile $i:/root/
done

2.8创建大数据用户

创建用户

adduser bigdata

设置密码

passwd bigdata

2.9配置免密登录

node1节点操作

切换用户

su bigdata

ssh-keygen -t rsa -P '' -f ~/.ssh/id_rsa

for i in {5,6,7}
do
ssh-copy-id 192.168.1.$i
done

三、部署zookeeper集群

node1服务

su bigdata

下载上传apache-zookeeper-3.7.1-bin.tar.gz 到bigdata用户

tar -zxvf apache-zookeeper-3.7.1-bin.tar.gz

mv apache-zookeeper-3.7.1-bin zookeeper

配置zookeeper

cd zookeeper/conf/
cp zoo_sample.cfg zoo.cfg
#修改完如下
[bigdata@node1 conf]# grep -Ev '^#|^$' zoo.cfg 
tickTime=2000
initLimit=10
syncLimit=5
dataDir=/home/bigdata/zookeeper/data
clientPort=2181
server.1=node1:2888:3888
server.2=node2:2888:3888
server.3=node3:2888:3888

说明：Zookeeper 集群中有三种角色：Leader、Follower 和 Observer。在一个 Zookeeper 集群中，同一时刻只会有一个 Leader，其他都是 Follower 或 Observer。Zookeeper 的配置很简单，每个节点的配置文件（zoo.cfg）都是一样的，只有 myid 文件不一样，Observer 角色是在 Zookeeper 集群中的一种特殊角色，它的作用是在集群中提供一个只读服务，不参与 Leader 选举，不参与写操作，只是接收 Leader 发送的数据变更通知，并将这些变更通知转发给客户端

设置myid

cd ..
mkdir data
echo 1>data/myid

配置zk环境变量

bigdata@node1 zookeeper]# cd
[bigdata@node1 ~]# cat >> .bash_profile << 'EOF'
#zookeeper环境变量
export ZOOKEEPER_HOME=/home/bigdata/zookeeper
export PATH=$PATH:$ZOOKEEPER_HOME/bin
EOF
[root@node1 ~]# source .bash_profile

分发文件到其他节点并配置

#将zookeeper文件夹发送到其他节点
[bigdata@node1 ~]$ for i in {node2,node3}
do
scp -r ~/zookeeper $i:~/
scp ~/.bash_profile $i:~/
done
#修改其他节点的myid
[bigdata@node2 ~]$ echo 2 > ~/zookeeper/data/myid
[bigdata@node3 ~]$ echo 3 > ~/zookeeper/data/myid

启动，停止，重启服务

#所有节点启动，需要在每个节点执行
zkServer.sh start
#编写脚本对zookeeper集群实现批量启动，停止，重启
[bigdata@node1 ~]$ cat > zkserver_manage_all.sh << 'EOF'
#!/bin/bash
echo "$1 zkServer ..."
for i in node1 node2 node3
do
ssh $i "source ~/.bash_profile && zkServer.sh $1"
done
EOF
#添加可执行权限
[bigdata@node1 ~]$ chmod +x zkserver_manage_all.sh
#启动
[bigdata@node1 ~]$ ./zkserver_manage_all.sh start
#停止
[bigdata@node1 ~]$ ./zkserver_manage_all.sh stop
#重启
[bigdata@node1 ~]$ ./zkserver_manage_all.sh restart
[bigdata@node1 ~]$ mv zkserver_manage_all.sh ~/zookeeper/bin/

查看状态

#查看服务状态，只能查看执行节点的zookeeper状态
zkServer.sh status
#通过编写脚本实现批量检查
[bigdata@node1 ~]$ cat > zkstatus_all.sh << 'EOF'
#!/bin/bash
for node in {node1,node2,node3}
do
    status=$(ssh $node 'source ~/.bash_profile && zkServer.sh status 2>&1 | grep  Mode')
    if [[ $status == "Mode: follower" ]];then
        echo "$node是从节点"
    elif [[ $status == "Mode: leader" ]];then
        echo "$node是主节点"
    else
        echo "未查询到$node节点zookeeper状态,请检查服务"
    fi
done
EOF
#添加执行权限
[bigdata@node1 ~]$ chmod +x zkstatus_all.sh
#通过脚本查看主从
[bigdata@node1 ~]$ ./zkstatus_all.sh
node1是从节点
node2是主节点
node3是从节点

四、部署Hadoop集群

介绍：
Hadoop 是一个开源的分布式计算平台，其中包含了一个分布式文件系统 HDFS。在 HDFS 中，NameNode 和 DataNode 是两个重要的组件。NameNode 是 HDFS 的主服务器，负责管理文件系统的命名空间和客户端对文件的访问。DataNode 是存储实际数据块的服务器，负责存储和检索数据块。

具体来说，NameNode 负责维护整个文件系统的目录树和文件元数据信息，包括文件名、文件属性、文件块列表等。它还负责处理客户端的读写请求，并将这些请求转发给相应的 DataNode。DataNode 负责存储和检索数据块，并向 NameNode 定期汇报自己所持有的数据块列表。

NameNode 和 DataNode 的主要区别在于它们所管理的信息不同。NameNode 管理文件系统的元数据信息，而 DataNode 管理实际的数据块。

本次安装的Hadoop集群为3个节点，两个namenode，三个datanode，规划如下：
IP节点NameNodeDataNode192.168.1.5node1YY192.168.1.6node2YY192.168.1.7node3NY
下载上传hadoop-3.3.5.tar.gz

解压并配置环境变量

#解压缩
[bigdata@node1 ~]$ tar -xf hadoop-3.3.5.tar.gz -C /home/bigdata/
[bigdata@node1 ~]$ mv ~/hadoop-3.3.5/ ~/hadoop
#配置hadoop环境变量
[bigdata@node1 ~]$ cat >> /root/.bash_profile << 'EOF'
#Hadoop环境变量
export HADOOP_HOME=/home/bigdata/hadoop
export PATH=$PATH:$HADOOP_HOME/bin:$HADOOP_HOME/sbin
EOF
[bigdata@node1 ~]$ source ~/.bash_profile
#验证
[bigdata@node1 ~]$ hadoop version
Hadoop 3.3.5
Source code repository https://github/apache/hadoop.git -r 706d88266abcee09ed78fbaa0ad5f74d818ab0e9
Compiled by stevel on 2023-03-15T15:56Z
Compiled with protoc 3.7.1
From source with checksum 6bbd9afcf4838a0eb12a5f189e9bd7
This command was run using /opt/bigdata/hadoop-3.3.5/share/hadoop/common/hadoop-common-3.3.5.jar

创建hadoop需要用到的目录

#所有节点执行，不然启动服务会报错，可以根据自己hdfs-site.xml文件自行配置
[bigdata@node1 ~]$ mkdir -p /home/bigdata/data/hadoop/tmp
[bigdata@node1 ~]$ mkdir -p /home/bigdata/data/hadoop/hdfs/name
[bigdata@node1 ~]$ mkdir -p /home/bigdata/data/hadoop/hdfs/data
[bigdata@node1 ~]$ mkdir -p /home/bigdata/data/hadoop/hdfs/ha/jn
[bigdata@node2 ~]$ mkdir -p /home/bigdata/data/hadoop/tmp
[bigdata@node2 ~]$ mkdir -p /home/bigdata/data/hadoop/hdfs/name
[bigdata@node2 ~]$ mkdir -p /home/bigdata/data/hadoop/hdfs/data
[bigdata@node2 ~]$ mkdir -p /home/bigdata/data/hadoop/hdfs/ha/jn
[bigdata@node3 ~]$ mkdir -p /home/bigdata/data/hadoop/tmp
[bigdata@node3 ~]$ mkdir -p /home/bigdata/data/hadoop/hdfs/name
[bigdata@node3 ~]$ mkdir -p /home/bigdata/data/hadoop/hdfs/data
[bigdata@node3 ~]$ mkdir -p /home/bigdata/data/hadoop/hdfs/ha/jn
#一次执行方式
mkdir -p /home/bigdata/data/hadoop/tmp && mkdir -p /home/bigdata/data/hadoop/hdfs/name && mkdir -p /home/bigdata/data/hadoop/hdfs/data && mkdir -p /home/bigdata/data/hadoop/hdfs/ha/jn

配置集群节点

workers

文件是用来指定Hadoop集群中所有的工作节点（即DataNode和NodeManager节点）的配置文件

[bigdata@node1 ~]$ cd /home/bigdata/hadoop/etc/hadoop/
[bigdata@node1 hadoop]$ cat > workers << 'EOF'
node1
node2
node3
EOF

修改核心配置文件

#三个节点配置一样
[bigdata@node1 hadoop]$ vim core-site.xml
<configuration>
    <property>
        <!--配置默认的文件系统-->
        <name>fs.defaultFS</name>
        <!--用的是HDFS作为文件系统，还要指定HDFS放在哪台主机上运行，9000默认端口号,如果配置了HA,fs.defaultFs的值应该是nameservice的名称，如hdfs-site.xml文件中dfs.nameservices的值为mycluster，此处填写hdfs://mycluster-->
        <value>hdfs://mycluster</value>
    </property>
    <property>
        <name>hadoop.tmp.dir</name>
        <value>/home/bigdata/data/hadoop/tmp</value>
    </property>
    
    <property>
        <name>ha.zookeeper.quorum</name>
        <value>node1:2181,node2:2181,node3:2181</value>
        <!--HDFS连接zookeeper集群的地址和端口-->
    </property>
    <property>
        <name>ipc.client.connect.max.retries</name>
        <value>100</value>
        <!--设置重连次数，默认10次-->
    </property>
    
    <property>
          <name>ipc.client.connect.retry.interval</name>
          <value>10000</value>
        <!--设置客户端在重试建立服务器连接之前等待的毫秒数，默认1000-->
    </property>
    
    <property>
        <name>io.file.buffer.size</name>
        <value>65536</value>
        <!--设置在读写数据时的缓存大小,这个缓存区的大小应该是硬件页面大小的倍数（在 Intel x86 上是 4096），它决定了在读写操作中缓冲了多少数据。较大的缓存可以提供更高的数据传输，但这也意味着更大的内存消耗和延迟.默认情况下，io.file.buffer.size 的值为 4096，但是建议将其设置为65536（64k）,也可以设置更高，比如131702等-->
    </property>
</configuration>

修改HDFS配置文件

#多master高可用配置，所有节点配置一样
#HA中的NameNode最少要有2个，也可以配置更多。建议不要超过5个，最好是3个，因为更多的NameNode意味着更多的通讯开销。
#fencing 和 edits 在实验中，如果你不想配置，可以去掉
[bigdata@node1 hadoop]$ vim hdfs-site.xml
<configuration>
    <property>
        <name>dfs.nameservices</name>
        <value>mycluster</value>
        <!--定义hdfs集群id号，需要和core-site.xml中的fs.defaultFS保持一致-->
    </property>    
    <property>
        <name>dfs.ha.namenodes.mycluster</name>
        <value>nn1,nn2</value>
        <!--定义hdfs集群中的namenode的id号-->
    </property>
    
    <property>
        <name>dfs.namenode.rpc-address.mycluster.nn1</name>
        <value>node1:9000</value>
        <!--nn1的RPC通信地址-->
    </property>
    <property>
        <name>dfs.namenode.http-address.mycluster.nn1</name>
        <value>node1:50070</value>
        <!--nn1的http通信地址-->
    </property> 
        <property>
        <name>dfs.namenode.rpc-address.mycluster.nn2</name>
        <value>node2:9000</value>
    </property>
    <property>
        <name>dfs.namenode.http-address.mycluster.nn2</name>
        <value>node2:50070</value>
    </property>
    <property>
        <name>dfs.namenode.name.dir</name>
        <value>/home/bigdata/data/hadoop/hdfs/name</value>
        <description>namenode上存储hdfs命名空间元数据 </description>
    </property>
    <property>
        <name>dfs.datanode.data.dir</name>
        <value>/home/bigdata/data/hadoop/hdfs/data</value>
        <description>datanode上数据块的物理存储位置</description>
    </property>
    <property>
        <name>dfs.replication</name>
        <value>3</value>
        <description>副本个数，默认是3,应小于datanode数量</description>
    
    </property>
    <!--如果想让solr索引存放到hdfs中，则还须添加下面2个属性-->
    <property>
        <name>dfs.webhdfs.enabled</name>
        <value>true</value>
    </property>
    <property>
        <name>dfs.permissions.enabled</name>
        <value>false</value>
        <!--用于启用或禁用 HDFS ACL（简单权限）。当 dfs.permissions.enabled 设置为 false 时，任何用户都可以在 HDFS 中的任何位置创建或删除文件或目录。将此属性设置为 false 后，您可以访问所有其他 Hadoop 服务，例如 Hive、HBase 等-->
    </property>
    
    <property>
        <name>dfs.datanode.max.transfer.threads</name>
        <value>4096</value>
        <!--用于设置 DataNode 在进行文件传输时的最大线程数. 如果集群中有某台 DataNode 主机的这个值比其他主机的大，那么出现的问题是，这台主机上存储的数据相对别的主机比较多，导致数据分布不均匀的问题，即使 balance 仍然会不均匀-->
    </property>
       
    <property>
        <name>dfs.ha.fencing.methods</name>
        <value>sshfence</value>
        <!-- HDFS集群中两个namenode切换状态时的隔离方法 -->
    </property>
    <property>
        <name>dfs.ha.fencing.ssh.private-key-files</name>
        <value>/home/bigdata/.ssh/id_rsa</value>
        <!-- HDFS集群中两个namenode切换状态时的隔离方法的密钥 -->
    </property>
    <property>
        <name>dfs.ha.automatic-failover.enabled</name>
        <value>true</value>
        <!-- 故障自动转移，HA的HDFS集群自动切换namenode的开关-->
    </property>
    
    <property>
        <name>dfs.namenode.shared.edits.dir</name>
        <value>qjournal://node1:8485;node2:8485/mycluster</value>
        <!-- 指定NameNode的元数据在JournalNode上的存放位置 -->
    </property>
    <property>
        <name>dfs.journalnode.edits.dir</name>
        <value>/home/bigdata/data/hadoop/hdfs/ha/jn</value>
        <!-- journalnode集群中用于保存edits文件的目录 -->
    </property>
    
    <property>
        <name>dfs.client.failover.proxy.provider.mycluster</name>
        <value>org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider</value>
        <!-- 定义HDFS的客户端连接HDFS集群时返回active namenode地址 -->
    </property>
    
</configuration>

hadoop-env.sh配置

vim $HADOOP_HOME/etc/hadoop/hadoop-env.sh

export JAVA_HOME=/usr/local/jdk1.8.0_391
export HADOOP_HOME=/home/bigdata/hadoop
export HADOOP_CONF_DIR=/home/bigdata/hadoop/etc/hadoop
export YARN_CONF_DIR=/home/bigdata/hadoop/etc/hadoop

同步hadoop文件到其他节点

for i in {node2,node3}
do
scp -r ~/hadoop $i:~/
scp ~/.bash_profile $i:~/
done

启动服务

#启动JN,格式化之前要优先启动JN,现在是两个nn，要通过JN传递数据。
[bigdata@node1 ~]$ hdfs --daemon start journalnode
[bigdata@node2 ~]$ hdfs --daemon start journalnode
#格式化NN，将node1作为主节点
[bigdata@node1 ~]$ hdfs namenode -format
#格式化NameNode会在指定的NameNode数据目录中创建一个名为current的子目录，用于存储NameNode的元数据和命名空间信息
[bigdata@node1 ~]$ ll /home/bigdata/data/hadoop/hdfs/name/
总用量 0
drwx------ 2 bigdata bigdata 112 7月  21 21:51 current
#node2上的nn作为主备，在node2执行拷贝元数据之前，需要先启动node1上的namanode
[bigdata@node1 ~]$ hdfs --daemon start namenode
#拷贝元数据，在Hadoop HDFS中初始化一个备用的NameNode节点。当主要的NameNode节点出现故障时，备用的NameNode节点就可以快速启动并接管服务，而无需重新加载整个文件系统的元数据，提供高可用性。注意在node2上执行
[bigdata@node2 ~]$ hdfs namenode -bootstrapStandby
#启动node2上的namenode
[bigdata@node2 ~]$ hdfs --daemon start namenode
#格式化zk，用于监控和管理Hadoop HDFS中的主备NameNode节点切换的组件。此命令会创建一个ZooKeeper目录结构，并将初始的主备NameNode节点信息存储在ZooKeeper中。这样，ZKFC就可以使用ZooKeeper来进行主备节点的管理和切换。
#在设置Hadoop HDFS的高可用性环境时，需要先使用hdfs namenode -bootstrapStandby命令初始化备用的NameNode节点，然后使用hdfs zkfc -formatZK 命令初始化ZKFC。这两个命令的组合可以确保Hadoop HDFS的主备节点切换的可靠性和高可用性。
[bigdata@node1 ~]$ hdfs zkfc -formatZK
#启动zk客户端
zkCli.sh  #可以通过ls查看目录结构
[zk: localhost:2181(CONNECTED) 0] ls /
[hadoop-ha, zookeeper]
#启动datanode，或者下面用集群命令 start-dfs.sh 一键启动所有服务
hdfs --daemon start datanode
#注意：以后启动hdfs就只需要先启动zookeeper，然后执行start-dfs.sh就可以了
[bigdata@node1 hadoop]$ stop-dfs.sh 
Stopping namenodes on [node1 node2]
Stopping datanodes
Stopping journal nodes [node2 node1]
Stopping ZK Failover Controllers on NN hosts [node1 node2]
#启动所有节点
[bigdata@node1 hadoop]$ start-dfs.sh
Starting namenodes on [node1 node2]
Starting datanodes
node3: WARNING: /home/bigdata/hadoop/logs does not exist. Creating.
Starting journal nodes [node2 node1]
Starting ZK Failover Controllers on NN hosts [node1 node2]
#验证高可用
[bigdata@node1 hadoop]$ hdfs haadmin -getServiceState nn1
active
[bigdata@node1 hadoop]$ hdfs haadmin -getServiceState nn2
standby
#如果两台都是standby，可以通过 hdfs haadmin -transitionToActive --forcemanual nn1 命令强制将nn1转换为为active
#访问页面验证
到浏览器访问，192.168.1.5:50070 和 192.168.1.6:50070 验证

配置yarn和MapReduce

修改mapred-site.xml

[bigdata@node1 hadoop]$ pwd
/home/bigdata/hadoop/etc/hadoop
[bigdata@node1 hadoop]$ vim mapred-site.xml
<configuration>    
    <property>
            <name>mapreduce.framework.name</name>
            <value>yarn</value>
            <description>指定mapreduce使用yarn框架</description>
    </property>
</configuration>

修改yarn-site.xml

[bigdata@node1 hadoop]$ vim yarn-site.xml
<configuration> 
  <property>
    <name>yarn.nodemanager.aux-services</name>
    <value>mapreduce_shuffle</value>
  </property>
  <property>
    <name>yarn.resourcemanager.ha.enabled</name>
    <value>true</value>
    <description>是否开启高可用</description>
  </property>
  <property>
    <name>yarn.resourcemanager.cluster-id</name>
    <value>yrc</value>
  </property>
  <property>
    <name>yarn.resourcemanager.ha.rm-ids</name>
    <value>rm1,rm2</value>
  </property>
  <property>
    <name>yarn.resourcemanager.hostname.rm1</name>
    <value>node1</value>
  </property>
  <property>
    <name>yarn.resourcemanager.hostname.rm2</name>
    <value>node2</value>
  </property>
   
  <!-- 指定 rm 的内部通信地址 --> 
  <property> 
    <name>yarn.resourcemanager.address.rm1</name>  
    <value>node1:8032</value> 
  </property>  
  <property> 
    <name>yarn.resourcemanager.address.rm2</name>  
    <value>node2:8032</value> 
  </property> 
  <!-- 指定 AM 向 rm 申请资源的地址 -->  
  <property> 
    <name>yarn.resourcemanager.scheduler.address.rm1</name>  
    <value>node1:8030</value> 
  </property>    
  <property> 
    <name>yarn.resourcemanager.scheduler.address.rm2</name>  
    <value>node2:8030</value> 
  </property>
  <!-- 指定供 NM 连接的地址 -->  
  <property> 
    <name>yarn.resourcemanager.resource-tracker.address.rm1</name>  
    <value>node1:8031</value> 
  </property>  
  <property> 
    <name>yarn.resourcemanager.resource-tracker.address.rm2</name>  
    <value>node2:8031</value> 
  </property>    
  
  <property>
    <name>yarn.resourcemanager.zk-address</name>
    <value>node1:2181,node2:2181,node3:2181</value>
  </property>
  
  <!-- 启用自动恢复 -->  
  <property> 
    <name>yarn.resourcemanager.recovery.enabled</name>  
    <value>true</value> 
  </property>  
  <!-- 指定 resourcemanager 的状态信息存储在 zookeeper 集群 -->  
  <property> 
    <name>yarn.resourcemanager.store.class</name>  
    <value>org.apache.hadoop.yarn.server.resourcemanager.recovery.ZKRMStateStore</value> 
  </property>  
  <!-- 环境变量的继承 -->  
  <property> 
    <name>yarn.nodemanager.env-whitelist</name>  
    <value>JAVA_HOME,HADOOP_COMMON_HOME,HADOOP_HDFS_HOME,HADOOP_CONF_DIR,CLAS SPATH_PREPEND_DISTCACHE,HADOOP_YARN_HOME,HADOOP_MAPRED_HOME</value> 
  </property>  
</configuration>

同步配置文件到其他节点

[bigdata@node1 hadoop]$ for i in {node2,node3}
do
scp mapred-site.xml yarn-site.xml $i:~/hadoop/etc/hadoop/
done

启动yarn服务

#启动服务
[bigdata@node1 hadoop]$ start-yarn.sh
Starting resourcemanagers on [ node1 node2]
Starting nodemanagers
#查看resourcemanagers主从
[bigdata@node1 hadoop]$ yarn rmadmin -getServiceState rm1
active
[bigdata@node1 hadoop]$ yarn rmadmin -getServiceState rm2
standby
#如果某些原因yarn没有启动成功，可以单独启动
yarn-daemon.sh start resourcemanager

验证


浏览器访问 192.168.1.5:8088
浏览器访问 192.168.1.6:8088
可以看到自动跳转到http://node1:8088/cluster，前提需要在电脑的hosts里配置上如下信息，不然ip变成node1时访问会失败
#配置电脑文件路径
C:\Windows\System32\drivers\etc\hosts
192.168.1.5 node1
192.168.1.6 node2

#访问hdfs目录，查看是否正常 
[bigdata@node3 ~]$ hdfs dfs -ls /
#hdfs相关命令
hdfs dfsadmin -report    #获取HDFS集群的详细报告信息：数据节点状态，容量和使用情况，块数量，网络拓扑信息
hdfs dfsadmin -safemode get        #查看hdfs是否为安全模式
hdfs haadmin -getServiceState nn1        #nn1 为配置文件中设置的namenode的id
hdfs haadmin -getServiceState nn2
#hdfs相关命令
hdfs dfs -mkdir -p /a/b/c
hdfs dfs -ls /a/b/
touch mytest.txt
hdfs dfs -put mytest.txt /a/b/c
hdfs dfs -get /a/b/c/mytest.txt
hdfs dfs -cp /a/b/c/mytest.txt /home/
hdfs dfs -cat /a/b/c/mytest.txt
hdfs dfs -mv /a/b/c/mytest.txt /a/
hdfs dfs -du [-s] [-h] /a
hdfs dfs -rm /a/mytest.txt
hdfs dfs -chown oldsixl /a/b/c
hdfs dfs -chomd 777 /a/b/c

五、部署Spark集群

集群节点规划，双master实现高可用，所有节点也可以同时配置成master和worker
节点角色node1masternode2Master，slavenode3slave
上传 spark-3.2.4-bin-hadoop3.2-scala2.13.tgz

解压缩并配置环境变量

解压 tar -zxvf spark-3.2.4-bin-hadoop3.2-scala2.13.tgz -C /home/bigdata/
mv spark-3.2.4-bin-hadoop3.2-scala2.13 spark
[bigdata@node1 ~]$ cat >> .bash_profile << 'EOF'
#Spark环境变量
export SPARK_HOME=/home/bigdata/spark
export PATH=$PATH:$SPARK_HOME/bin
EOF

配置spark文件

[bigdata@node1 ~]$ cd /home/bigdata/spark/conf/
[bigdata@node1 conf]$ cp spark-env.sh.template spark-env.sh
#修改spark-env.sh
[bigdata@node1 conf]$ grep -v ^# spark-env.sh
export JAVA_HOME=/usr/local/jdk1.8.0_391/
export HADOOP_CONF_DIR=/home/bigdata/hadoop/etc/hadoop/
export YARN_CONF_DIR=/home/bigdata/hadoop/etc/hadoop/
export SPARK_MASTER_IP=node1
export SPARK_MASTER_PORT=7077
export SPARK_MASTER_WEBUI_PORT=8090
export SPARK_WORKER_WEBUI_PORT=8091
export SPARK_DAEMON_JAVA_OPTS="-Dspark.deploy.recoveryMode=ZOOKEEPER -Dspark.deploy.zookeeper.url=node1:2181,node2:2181,node3:2181 -Dspark.deploy.zookeeper.dir=/home/bigdata/zookeeper"
说明:
JAVA_HOEM：设置Java安装目录的路径
HADOOP_CONF_DIR：设置Hadoop的配置目录路径
YARN_CONF_DIR：设置YARN的配置目录路径，YARN是Hadoop的资源管理器
SPARK_MASTER_IP：设置Spark主节点的IP地址或主机名。Spark主节点负责协调集群中的各个工作节点。
SPARK_MASTER_PORT：设置Spark主节点的端口号。通过该端口，工作节点可以与Spark主节点进行通信。
SPARK_MASTER_WEBUI_PORT：设置Spark主节点的Web界面端口号。可以通过该端口访问Spark主节点的Web界面。
SPARK_WORKER_WEBUI_PORT：设置Spark工作节点的Web界面端口号。可以通过该端口访问Spark工作节点的Web界面。
[bigdata@node1 conf]$ cp workers.template workers
#修改workers文件
[bigdata@node1 conf]$ cat > workers << EOF
node2
node3
EOF

复制hadoop配置到spark配置目录下

[bigdata@node1 conf]$ cd /home/bigdata/hadoop/etc/hadoop/
[bigdata@node1 hadoop]$ cp core-site.xml hdfs-site.xml /home/bigdata/spark/conf/

将spark文件分发到其他节点

[bigdata@node1 hadoop]$ for i in {node2,node3}
do
scp -r /home/bigdata/spark $i:/home/bigdata/
scp ~/.bash_profile $i:~/
done
#在node2上配置备用master节点
[bigdata@node2 ~]$ vim /home/bigdata/spark/conf/spark-env.sh
#将 export SPARK_MASTER_IP=node1  改为
export SPARK_MASTER_IP=node2

启动spark

#由于启动命令和hadoop下的命令文件名一样，我们需要cd到spark目录下执行
[bigdata@node1 hadoop]$ cd /home/bigdata/spark/sbin/
[bigdata@node1 sbin]$ ./start-all.sh 
#启动备master
[bigdata@node2 ~]$ cd /home/bigdata/spark/sbin
[bigdata@node2 sbin]$ ./start-master.sh
#jps查看主节点都有Master，node3节点有Worker

页面访问查看主备

浏览器访问 192.168.1.5:8090 可以看到上面状态 Status: ALIVE

浏览器访问 192.168.1.6:8090 可以看到上面状态 Status: STANDBY

可以看到两个master，node1节点alive为主，node2节点standby为备用master

我们关闭node1上的master

[bigdata@node1 sbin]$ jps
5265 DFSZKFailoverController
4835 DataNode
2133 QuorumPeerMain
4693 NameNode
6901 Master
5079 JournalNode
6167 ResourceManager
7191 Jps
6319 NodeManager
[bigdata@node1 sbin]$ kill -9 6901

刷新页面，192.168.1.5:8090 已经访问不到了，我们在访问node2，多刷新几次，可以看到master已经切换到node2

再次启动node1上的master，关闭node2 可以看到，master切换回了node1，状态为alive

运行测试

[bigdata@node1 sbin]$ spark-submit --class org.apache.spark.examples.SparkPi --master yarn --deploy-mode cluster /home/bigdata/spark/examples/jars/spark-examples_2.13-3.2.4.jar 
#再次测试,没有报错了
[bigdata@node1 sbin]$ spark-submit --class org.apache.spark.examples.SparkPi --master yarn --deploy-mode cluster /home/bigdata/spark/examples/jars/spark-examples_2.13-3.2.4.jar
  client token: N/A
 diagnostics: N/A
 ApplicationMaster host: node2
 ApplicationMaster RPC port: 39869
 queue: default
 start time: 1704966405185
 final status: SUCCEEDED
 tracking URL: http://node1:8088/proxy/application_1704964396313_0001/
 user: bigdata

查看yarn

浏览器访问 http://192.168.1.5:8088

可以看到执行的任务，第一次失败，第二次成功

配置历史服务器

配置yarn历史服务器

#修改Hdfs配置
[bigdata@node1 ~]$ cd /home/bigdata/hadoop/etc/hadoop/
# vim mapred-site.xml 编辑 添加以下内容
    <!--Spark on Yarn-->
    <property>
        <name>mapreduce.jobhistory.address</name>
        <value>node1:10020</value>
    </property>
    <property>
        <name>mapreduce.jobhistory.webapp.address</name>
        <value>node1:19888</value>
    </property>
#修改yarn配置文件
# vim yarn-site.xml 编辑添加以下内容
  <!--Spark on Yarn-->
  <!-- 是否开启聚合日志 -->
  <property>
    <name>yarn.log-aggregation-enable</name>
    <value>true</value>
  </property>
  <!-- 配置日志服务器的地址 -->
  <property>
    <name>yarn.log.server.url</name>
    <value>http://node1:19888/jobhistory/logs/</value>
  </property>
  <!-- 配置日志过期时间,单位秒 -->
  <property>
    <name>yarn.log-aggregation.retain-seconds</name>
    <value>86400</value>
  </property>
#同步配置到其他节点以及saprk目录下
[bigdata@node1 ~]$ cd /home/bigdata/hadoop/etc/hadoop/
[bigdata@node1 hadoop]$ for i in {node1,node2,node3}
do
scp mapred-site.xml yarn-site.xml $i:/home/bigdata/hadoop/etc/hadoop/
scp mapred-site.xml yarn-site.xml $i:/home/bigdata/spark/conf/
done

配置spark历史服务器

#修改配置文件
[bigdata@node1 sbin]$ cd ../conf/
[bigdata@node1 conf]$ cp spark-defaults.conf.template spark-defaults.conf
[bigdata@node1 conf]$ vim spark-defaults.conf
#添加或者放开注释并修改
spark.eventLog.enabled              true
spark.eventLogpress             true
spark.eventLog.dir                  hdfs://mycluster/spark-logs
spark.yarn.historyServer.address    node1:18080,node2:18080
spark.history.ui.port               18080
spark.history.fs.logDirectory       hdfs://mycluster/spark-logs
spark.history.retainedApplications  30
#说明：
spark.eventLog.enabled 设置为 true 表示启用Spark事件日志记录功能。
spark.eventLogpress 指定Spark事件日志是否需要进行压缩
spark.eventLog.dir 指定了事件日志的存储路径
spark.yarn.historyServer.address 指定了YARN历史服务器的地址
spark.history.ui.port 指定了Spark历史服务器UI的端口号
spark.history.fs.logDirectory 指定了历史记录文件在文件系统中的存储路径
spark.history.retainedApplications 指定了历史服务器要保留的应用程序数量，设置为 30，表示历史服务器将保留最近提交的30个应用程序的历史记录。
#同步上述文件至其他节点
[bigdata@node1 conf]$ scp spark-defaults.conf node2:/home/bigdata/spark/conf/
[bigdata@node1 conf]$ scp spark-defaults.conf node3:/home/bigdata/spark/conf/
#创建时间日志的存储路径，需要在启动历史服务器之前创建，不然报错找不到路径或文件
[bigdata@node1 conf]$ hdfs dfs -mkdir /spark-logs

重启服务并验证

#重启hdfs，yarn，spark
#停止spark服务
[bigdata@node1 ~]$ $SPARK_HOME/sbin/stop-all.sh
#停止yarn，hdfs
[bigdata@node1 ~]$ $HADOOP_HOME/sbin/stop-all.sh
#启动hadoop服务
[bigdata@node1 ~]$ which start-all.sh
/home/bigdata/hadoop/sbin/start-all.sh
[bigdata@node1 ~]$ start-all.sh
#启动yarn历史服务器
[bigdata@node1 ~]$ mapred --daemon start historyserver
#启动spark
[bigdata@node1 ~]$ $SPARK_HOME/sbin/start-all.sh
#启动spark历史服务器
[bigdata@node1 ~]$ $SPARK_HOME/sbin/start-history-server.sh
[bigdata@node2 ~]$ $SPARK_HOME/sbin/start-history-server.sh
#停止spark历史服务器
# $SPARK_HOME/sbin/stop-history-server.sh

浏览器访问查看

配置 C:\Windows\System32\drivers\etc\hosts 添加
192.168.1.5 node1
192.168.1.6 node2
192.168.1.7 node3

访问 http://192.168.1.5:19888
访问 http://192.168.1.6:18080
查看日志

至此，spark集群部署完成

六、部署Flink集群

上传flink-1.16.1-bin-scala_2.12.tgz

解压缩并配置环境变量

#解压安装包
[bigdata@node1 ~]$ tar -xf flink-1.16.1-bin-scala_2.12.tgz -C /home/bigdata/
[bigdata@node1 ~]$ mv /home/bigdata/flink-1.16.1/ /home/bigdata/flink
#配置环境变量
[bigdata@node1 ~]$ cat >> .bash_profile << 'EOF'
#Flink环境变量
export FLINK_HOME=/home/bigdata/flink
export PATH=$PATH:$FLINK_HOME/bin
EOF
#让环境变量生效
[bigdata@node1 ~]$ source .bash_profile

配置FLINK

#查看并修改flink的配置文件
[bigdata@node1 ~]$ cd /home/bigdata/flink/conf/
#修改masters文件
[bigdata@node1 conf]$ cat > masters << 'EOF'
node1:8081
node2:8081
EOF
#修改workers文件
[bigdata@node1 conf]$ cat > workers << 'EOF'
node1
node2
node3
EOF
#修改flink-conf.yaml文件，如下
[bigdata@node1 conf]$ grep -Ev '^#|^$' flink-conf.yaml 
jobmanager.rpc.address: localhost
jobmanager.rpc.port: 6123
jobmanager.bind-host: 0.0.0.0
jobmanager.memory.process.size: 1600m
taskmanager.bind-host: 0.0.0.0
taskmanager.host: node1            #node2节点改成node2，node3节点改成node3
taskmanager.memory.process.size: 1728m
taskmanager.numberOfTaskSlots: 1
parallelism.default: 1
high-availability: zookeeper
high-availability.storageDir: hdfs://mycluster/flink/ha/
high-availability.zookeeper.quorum: node1:2181,node2:2181,node3:2181
high-availability.zookeeper.client.acl: open
state.backend: filesystem
state.checkpoints.dir: hdfs://mycluster/flink/checkpoints
state.savepoints.dir: hdfs://mycluster/flink/savepoints
state.backend.incremental: false
jobmanager.execution.failover-strategy: region
rest.address: localhost
rest.bind-address: 0.0.0.0
web.submit.enable: true
说明
#jobmanager.rpc.address: localhost    #指定JobManager的RPC地址
#jobmanager.rpc.port: 6123：        #指定JobManager的RPC端口号
#jobmanager.bind-host: 0.0.0.0    #JobManager绑定的主机为0.0.0.0，表示可以接受来自任何主机的连接。
#jobmanager.memory.process.size: 1600m    #每个JobManager的可用内存大小
#taskmanager.bind-host: 0.0.0.0    #TaskManager绑定的主机为0.0.0.0，表示可以接受来自任何主机的连接。
#taskmanager.host: localhost    #指定TaskManager的主机名
#taskmanager.memory.process.size: 1728m    #每个TaskManager的可用内存大小
#taskmanager.numberOfTaskSlots: 2    #指定每个TaskManager的任务槽数量
#parallelism.default: 1    #指定默认的并行度，即每个任务的并行执行线程数
#high-availability: zookeeper    #指定高可用性模式，这里设置为 zookeeper。表示Flink将使用Zookeeper来进行高可用性管理。
#high-availability.storageDir: hdfs:///flink/ha/    #指定高可用性存储目录的路径
#high-availability.zookeeper.quorum: node1:2181,node2:2181,node3:2181    #指定Zookeeper集群的地址列表
#high-availability.zookeeper.client.acl: open    #指定Zookeeper客户端的访问控制列表（ACL），默认是 open，如果 zookeeper security 启用了更改成 creator
#state.backend: filesystem    #指定状态后端，即Flink任务的状态数据存储方式，这里设置为 filesystem，表示使用文件系统进行状态存储。
#state.checkpoints.dir: hdfs:///flink/checkpoints    #指定检查点数据的存储路径
#state.savepoints.dir: hdfs:///flink/savepoints    #指定保存点数据的存储路径
#state.backend.incremental: false    #指定是否启用增量检查点。设置为 false 表示禁用增量检查点，而是使用全量检查点。
#jobmanager.execution.failover-strategy: region    #指定作业管理器的故障转移策略，full: 当作业管理器发生故障时，使用全量故障转移策略。全量故障转移会将作业状态和所有任务的状态从故障的作业管理器迁移到另一个作业管理器。这是默认的故障转移策略。；region: 当作业管理器发生故障时，使用区域故障转移策略。区域故障转移会将作业状态和一部分任务的状态从故障的作业管理器迁移到另一个作业管理器，而不是全部迁移；none: 当作业管理器发生故障时，不进行故障转移。这意味着作业将终止，并且需要手动重新启动。
#rest.address: 0.0.0.0    #指定REST接口的地址，表示可以接受来自任何主机的连接。
#rest.bind-address: localhost    #指定REST绑定的地址
#web.submit.enable: true    #指定是否启用Web提交界面
#修改zoo.cfg
[bigdata@node1 conf]$ cp /home/bigdata/zookeeper/conf/zoo.cfg .
#复制hadoop配置到flink目录下
[bigdata@node1 conf]$ cd /home/bigdata/hadoop/etc/hadoop/
[bigdata@node1 hadoop]$ cp core-site.xml hdfs-site.xml /home/bigdata/flink/conf/

将flink目录发送到其他节点

[bigdata@node1 hadoop]$ for i in {node2,node3}
do
scp -r /home/bigdata/flink/ $i:/home/bigdata/
scp ~/.bash_profile $i:~/
done

修改其他节点的flink-conf.yaml

[bigdata@node2 ~]$ grep -Ev '^#|^$' /home/bigdata/flink/conf/flink-conf.yaml
jobmanager.rpc.address: localhost
jobmanager.rpc.port: 6123
jobmanager.bind-host: 0.0.0.0
jobmanager.memory.process.size: 1600m
taskmanager.bind-host: 0.0.0.0
taskmanager.host: node2            ##修改此行
taskmanager.memory.process.size: 1728m
taskmanager.numberOfTaskSlots: 1
parallelism.default: 1
high-availability: zookeeper
high-availability.storageDir: hdfs://mycluster/flink/ha/
high-availability.zookeeper.quorum: node1:2181,node2:2181,node3:2181
high-availability.zookeeper.client.acl: open
state.backend: filesystem
state.checkpoints.dir: hdfs://mycluster/flink/checkpoints
state.savepoints.dir: hdfs://mycluster/flink/savepoints
state.backend.incremental: false
jobmanager.execution.failover-strategy: region
rest.address: localhost
rest.bind-address: 0.0.0.0
web.submit.enable: true
[bigdata@node3 ~]$ grep -Ev '^#|^$' /home/bigdata/flink/conf/flink-conf.yaml 
jobmanager.rpc.address: localhost
jobmanager.rpc.port: 6123
jobmanager.bind-host: 0.0.0.0
jobmanager.memory.process.size: 1600m
taskmanager.bind-host: 0.0.0.0
taskmanager.host: node3            #修改此行
taskmanager.memory.process.size: 1728m
taskmanager.numberOfTaskSlots: 1
parallelism.default: 1
high-availability: zookeeper
high-availability.storageDir: hdfs://mycluster/flink/ha/
high-availability.zookeeper.quorum: node1:2181,node2:2181,node3:2181
high-availability.zookeeper.client.acl: open
state.backend: filesystem
state.checkpoints.dir: hdfs://mycluster/flink/checkpoints
state.savepoints.dir: hdfs://mycluster/flink/savepoints
state.backend.incremental: false
jobmanager.execution.failover-strategy: region
rest.address: localhost
rest.bind-address: 0.0.0.0
web.submit.enable: true

启动flink集群

[bigdata@node1 hadoop]$ cd /home/bigdata/flink/bin/
[bigdata@node1 bin]$ ./start-cluster.sh 
Starting HA cluster with 2 masters.
Starting standalonesession daemon on host node1.
Starting standalonesession daemon on host node2.
Starting taskexecutor daemon on host node1.
Starting taskexecutor daemon on host node2.
Starting taskexecutor daemon on host node3.
#jps查看进程,如果启动成功会有 StandaloneSessionClusterEntrypoint 和 TaskManagerRunner 进程，没有就查看日志报错，参考后面排查步骤
[bigdata@node1 bin]$ jps
5265 DFSZKFailoverController
4835 DataNode
9140 Jps
2133 QuorumPeerMain
4693 NameNode
6901 Master
5079 JournalNode
6167 ResourceManager
7624 HistoryServer
6319 NodeManager
#查看日志报错信息
[bigdata@node1 bin]$ less ../log/flink-root-standalonesession-0-node1.log
Caused by: org.apache.flink.core.fs.UnsupportedFileSystemSchemeException: Could not find a file system implementation for scheme 'hdfs'. The scheme is not directly supported by Flink and no Hadoop file system to support this scheme could be loaded.
#这个错误通常是由于缺少 Hadoop 的依赖引起的。Flink 需要 Hadoop 的相关库文件才能与 HDFS 进行交互。
#确保 Flink 的 lib 目录中包含了所需的 Hadoop 相关的 JAR 文件。这些文件通常位于 Hadoop 的安装目录下的 share/hadoop/common 目录中。将这些文件复制到 Flink 的 lib 目录中
[bigdata@node1 bin]$ cd /home/bigdata/hadoop/share/hadoop/common/
[bigdata@node1 common]$ ls -1
hadoop-common-3.3.5.jar    #Hadoop的通用库文件，包含了与文件系统交互和访问HDFS需要的功能
hadoop-common-3.3.5-tests.jar 
hadoop-kms-3.3.5.jar    #Hadoop KMS的库文件，用于管理和访问加密密钥
hadoop-nfs-3.3.5.jar #Hadoop的NFS（Network File System）库文件，用于访问和操作基于NFS的文件系统
hadoop-registry-3.3.5.jar    #Hadoop的注册表库文件，用于管理和访问注册表服务。
jdiff
lib
sources
webapps
#所有节点放入
[bigdata@node1 common]$ for i in {node1,node2,node3}
do
scp hadoop-common-3.3.5.jar hadoop-kms-3.3.5.jar hadoop-nfs-3.3.5.jar hadoop-registry-3.3.5.jar $i:/home/bigdata/flink/lib/
done
#再次启动
[bigdata@node1 common]$ $FLINK_HOME/bin/start-cluster.sh
[bigdata@node1 common]$ jps        #仍然没有
5265 DFSZKFailoverController
4835 DataNode
2133 QuorumPeerMain
4693 NameNode
6901 Master
5079 JournalNode
6167 ResourceManager
7624 HistoryServer
10139 Jps
6319 NodeManager
#登录flink官网
/zh/downloads/  ctrl+f 搜索hadoop
找到Pre-bundled Hadoop 2.8.3 Source Release (asc, sha512) 点击下载
#完整下载路径如下：
/maven2/org/apache/flink/flink-shaded-hadoop-2-uber/2.8.3-10.0/flink-shaded-hadoop-2-uber-2.8.3-10.0.jar
[bigdata@node1 ~]$ wget /maven2/org/apache/flink/flink-shaded-hadoop-2-uber/2.8.3-10.0/flink-shaded-hadoop-2-uber-2.8.3-10.0.jar
#将jar包放入 /home/bigdata/flink/lib 目录下,所有节点都要放入
[bigdata@node1 ~]$ for i in {node1,node2,node3}
do
scp flink-shaded-hadoop-2-uber-2.8.3-10.0.jar $i:/home/bigdata/flink/lib/
done
#再次启动查看进程
[bigdata@node1 ~]$ $FLINK_HOME/bin/start-cluster.sh
[bigdata@node1 ~]$ jps
5265 DFSZKFailoverController
4835 DataNode
10643 StandaloneSessionClusterEntrypoint        ##
10948 TaskManagerRunner        ##
2133 QuorumPeerMain
4693 NameNode
6901 Master
11093 Jps
5079 JournalNode
6167 ResourceManager
7624 HistoryServer
6319 NodeManager
[bigdata@node2 ~]$ jps
2752 DataNode
7106 TaskManagerRunner    ##
2851 JournalNode
2670 NameNode
3822 Worker
1873 QuorumPeerMain
4433 HistoryServer
6802 StandaloneSessionClusterEntrypoint    ##
3316 NodeManager
3221 ResourceManager
3928 Master
2937 DFSZKFailoverController
7231 Jps
[bigdata@node3 ~]$ jps
2114 DataNode
1860 QuorumPeerMain
2884 Worker
2263 NodeManager
4395 TaskManagerRunner    ##
4350 Jps
#可以看到有StandaloneSessionClusterEntrypoint和TaskManagerRunner进程
#master角色进程: StandaloneSessionClusterEntrypoint； slave角色进程: TaskManagerRunner
#停止集群 ./stop-cluster.sh
#单独启动
./jobmanager.sh start/stop
./taskmanager.sh start/stop

页面访问验证

浏览器访问 http://192.168.1.5:8081/

提交任务测试

#使用官方example 运行测试看看
[bigdata@node3 ~]$ cd /home/bigdata/flink/bin/
[bigdata@node3 bin]$ flink run -m yarn-cluster ../examples/batch/WordCount

这就是代表运行成功了，我们访问yarn查看applicationId

其他常用操作命令

#使用yarn-session.sh命令（yarn-session.sh命令在flink的bin下）
#启动一个Flink YARN session。其中，-n 3表示启动3个TaskManager，-jm 500表示JobManager的内存为500MB，-tm 500表示每个TaskManager的内存为500MB，-d表示在后台运行
[bigdata@node3 bin]$ yarn-session.sh -n 3 -jm 500 -tm 500 -d
...
JobManager Web Interface: http://192.168.1.5:33563

访问日志上的网址可以访问此任务的flink dashboard

#命令行查询命令
[bigdata@node1 ~]$ yarn application -list
Total number of applications (application-types: [], states: [SUBMITTED, ACCEPTED, RUNNING] and tags: []):1
                Application-Id        Application-Name        Application-Type          User         Queue                 State           Final-State           Progress                           Tracking-URL
application_1689949756263_0005    Flink session cluster            Apache Flink          root       default               RUNNING             UNDEFINED               100%              http://192.168.1.11:33563
#查看日志命令 
[bigdata@node1 ~]$ yarn logs -applicationId  application_1689949756263_0005
#结束杀掉任务
[bigdata@node1 ~]$ yarn application -kill  application_1689949756263_0005

至此，flink on yarn 高可用集群部署完成

部署kafka集群

下载上传kafka_2.12-3.4.0.tgz

解压缩并配置环境变量

#解压缩
[bigdata@node1 ~]$ tar -xf kafka_2.12-3.4.0.tgz -C /home/bigdata/
[bigdata@node1 ~]$ mv /home/bigdata/kafka_2.12-3.4.0/ /home/bigdata/kafka
#配置环境变量
[bigdata@node1 ~]$ cat >> .bash_profile << 'EOF'
#Kafka环境变量
export KAFKA_HOME=/home/bigdata/kafka
export PATH=$PATH:$KAFKA_HOME/bin
EOF
[bigdata@node1 ~]$ source .bash_profile

配置kafka

[bigdata@node1 ~]$ cd /home/bigdata/kafka/config/
#主要配置文件为server.properties，vim 编辑修改，最后如下
[bigdata@node1 config]$ grep -Ev '^$|^#' server.properties 
#broker的全局唯一编号，不能重复，只能是数字。每个节点唯一，不能重复
broker.id=5
#修改为当前节点的ip
listeners = PLAINTEXT://node1:9092    
numwork.threads=3
num.io.threads=8
socket.send.buffer.bytes=102400
socket.receive.buffer.bytes=102400
socket.request.max.bytes=104857600
#运行日志存放的路径，不需提前创建，kafka会自动创建
log.dirs=/home/bigdata/kafka/logs
#默认分区数
num.partitions=1
num.recovery.threads.per.data.dir=1
offsets.topic.replication.factor=1
transaction.state.log.replication.factor=1
transaction.state.log.min.isr=1
#日志保留时间
log.retention.hours=168
log.retention.check.interval.ms=300000
#连接zookeeper集群地址
zookeeper.connect=node1:2181,node2:2181,node3:2181
zookeeper.connection.timeout.ms=18000
group.initial.rebalance.delay.ms=0

分发文件到其他节点并配置

[bigdata@node1 config]$ cd
[bigdata@node1 ~]$ for i in {node2,node3}
do
scp -r /home/bigdata/kafka/ $i:/home/bigdata/
scp .bash_profile $i:~/
done
#修改node2和nide3的配置文件，如下
[bigdata@node2 ~]$ grep -Ev '^$|^#' /home/bigdata/kafka/config/server.properties
##修改此处id值
broker.id=6
#修改当前节点名
listeners = PLAINTEXT://node2:9092
numwork.threads=3
num.io.threads=8
socket.send.buffer.bytes=102400
socket.receive.buffer.bytes=102400
socket.request.max.bytes=104857600
log.dirs=/home/bigdata/kafka/logs
num.partitions=1
num.recovery.threads.per.data.dir=1
offsets.topic.replication.factor=1
transaction.state.log.replication.factor=1
transaction.state.log.min.isr=1
log.retention.hours=168
log.retention.check.interval.ms=300000
zookeeper.connect=node1:2181,node2:2181,node3:2181
zookeeper.connection.timeout.ms=18000
group.initial.rebalance.delay.ms=0
[bigdata@node3 ~]$ grep -Ev '^$|^#' /home/bigdata/kafka/config/server.properties
##修改此处id值
broker.id=7
#修改当前节点名
listeners = PLAINTEXT://node3:9092
numwork.threads=3
num.io.threads=8
socket.send.buffer.bytes=102400
socket.receive.buffer.bytes=102400
socket.request.max.bytes=104857600
log.dirs=/home/bigdata/kafka/logs
num.partitions=1
num.recovery.threads.per.data.dir=1
offsets.topic.replication.factor=1
transaction.state.log.replication.factor=1
transaction.state.log.min.isr=1
log.retention.hours=168
log.retention.check.interval.ms=300000
zookeeper.connect=node1:2181,node2:2181,node3:2181
zookeeper.connection.timeout.ms=18000
group.initial.rebalance.delay.ms=0

启动kafka集群

#每个节点都要启动
[bigdata@node1 ~]$ cd /home/bigdata/kafka/bin
[bigdata@node1 bin]$ ./kafka-server-start.sh -daemon ../config/server.properties
[bigdata@node2 ~]$ cd /home/bigdata/kafka/bin
[bigdata@node2 bin]$ ./kafka-server-start.sh -daemon ../config/server.properties
[bigdata@node3 ~]$ cd /home/bigdata/kafka/bin
[bigdata@node3 bin]$ ./kafka-server-start.sh -daemon ../config/server.properties

集群测试以及常用kafka命令

#创建topic，1分区，1副本，topic名字 Mytopic_test
[bigdata@node3 ~]$ kafka-topics.sh --create --topic Mytopic_test --partitions 1 --replication-factor 1 --bootstrap-server node1:9092,node2:9092,node3:9092
WARNING: Due to limitations in metric names, topics with a period ('.') or underscore ('_') could collide. To avoid issues it is best to use either, but not both.
Created topic mytopic_test.
#查看topic列表
[bigdata@node3 ~]$ kafka-topics.sh --bootstrap-server node1:9092,node2:9092,node3:9092 --list
Mytopic_test
#更改topic分区为3
[bigdata@node3 ~]$ kafka-topics.sh --alter --bootstrap-server node1:9092,node2:9092,node3:9092 --topic Mytopic_test --partitions 3
#添加配置，当producer发送了100条消息后，就会强制将缓存中的消息刷新到磁盘上
[bigdata@node3 ~]$ kafka-configs.sh --bootstrap-server node1:9092,node2:9092,node3:9092 --entity-type topics --entity-name Mytopic_test --alter --add-config flush.messages=100
Completed updating config for topic Mytopic_test.
#查看Topic描述
[bigdata@node3 ~]$ kafka-topics.sh --describe --bootstrap-server node1:9092,node2:9092,node3:9092 --topic Mytopic_test
Topic: Mytopic_test    TopicId: L1V4yI1UQy6_ZMkwgMHUmA    PartitionCount: 3    ReplicationFactor: 1    Configs: flush.messages=100
    Topic: Mytopic_test    Partition: 0    Leader: 11    Replicas: 11    Isr: 11
    Topic: Mytopic_test    Partition: 1    Leader: 12    Replicas: 12    Isr: 12
    Topic: Mytopic_test    Partition: 2    Leader: 13    Replicas: 13    Isr: 13
#启动生产者
#在任意Kafka节点上启动Producer生产数据
[bigdata@node3 ~]$ kafka-console-producer.sh --broker-list node1:9092,node2:9092,node3:9092 --topic Mytopic_test
>abcd
#在任意kafka节点上启动消费者
[bigdata@node3 ~]$ kafka-console-consumer.sh --bootstrap-server node1:9092,node2:9092,node3:9092 --topic Mytopic_test
abcd
#消费多主题
#新建topic名为topic_test2
[bigdata@node3 ~]$ kafka-topics.sh --create --topic topic_test2 --partitions 1 --replication-factor 1 --bootstrap-server node1:9092,node2:9092,node3:9092
#同时消费Mytopic_test和topic_test2
[bigdata@node3 ~]$ kafka-console-consumer.sh --bootstrap-server node1:9092,node2:9092,node3:9092  --consumer-property group.id=grouptest --consumer-property consumer.id=old-consumer-cl --whiteli
st "Mytopic_test|topic_test2"
#创建消费组
[bigdata@node3 ~]$ kafka-console-consumer.sh --bootstrap-server node1:9092,node2:9092,node3:9092 --topic Mytopic_test --group mygroup_test
#查看消费组列表
[bigdata@node3 ~]$ kafka-consumer-groups.sh --list --bootstrap-server node1:9092,node2:9092,node3:9092
mygroup_test
grouptest
console-consumer-18469
#查看消费组详细信息，LOG-END-OFFSET下一条将要被加入到日志的消息的位移，CURRENT-OFFSET当前消费的位移，LAG 消息堆积量
[bigdata@node3 ~]$ kafka-consumer-groups.sh --describe --bootstrap-server node1:9092,node2:9092,node3:9092 --group mygroup_test
GROUP           TOPIC           PARTITION  CURRENT-OFFSET  LOG-END-OFFSET  LAG             CONSUMER-ID                                           HOST            CLIENT-ID
mygroup_test    Mytopic_test    0          0               0               0               console-consumer-66df351d-4457-4278-9900-b3d0c95b4e69 /192.168.1.12   console-consumer
mygroup_test    Mytopic_test    1          5               5               0               console-consumer-66df351d-4457-4278-9900-b3d0c95b4e69 /192.168.1.12   console-consumer
mygroup_test    Mytopic_test    2          0               0               0               console-consumer-66df351d-4457-4278-9900-b3d0c95b4e69 /192.168.1.12   console-consumer
#移动消费组偏移到某个位置
#最早处
[bigdata@node3 ~]$ kafka-consumer-groups.sh --bootstrap-server node1:9092,node2:9092,node3:9092 --group mygroup_test --reset-offsets --all-topics --to-earliest --execute
#最新处
[bigdata@node3 ~]$ kafka-consumer-groups.sh --bootstrap-server node1:9092,node2:9092,node3:9092 --group mygroup_test --reset-offsets --all-topics --to-latest --execute
#某个位置
[bigdata@node3 ~]$ kafka-consumer-groups.sh --bootstrap-server node1:9092,node2:9092,node3:9092 --group mygroup_test --reset-offsets --all-topics --to-offset 2000 --execute
#删除topic
[bigdata@node3 ~]$ kafka-topics.sh --delete --topic topic_test2 --bootstrap-server node1:9092,node2:9092,node3:9092
#删除消费组
[bigdata@node3 ~]$ kafka-consumer-groups.sh --bootstrap-server node1:9092,node2:9092,node3:9092 --group mygroup_test --delete

部署HBase集群

HBase是一个开源的分布式、面向列的NoSQL数据库，它是构建在Hadoop分布式文件系统（HDFS）上的。HBase的设计目标是提供高可靠性、高性能的随机读写能力，以适应大规模数据存储和处理的需求。

集群节点规划：
节点名HMasterHRegionServernode1YYnode2YYnode3NY

上传HBase安装包

hbase-2.4.17-bin.tar.gz

解压缩并配置环境变量

#解压软件包
[bigdata@node1 ~]$ tar -xf hbase-2.4.17-bin.tar.gz -C /home/bigdata/
[bigdata@node1 ~]$ mv /home/bigdata/hbase-2.4.17/ /home/bigdata/hbase
#配置环境变量
[bigdata@node1 ~]$ cat >> .bash_profile << 'EOF'
#HBase环境变量
export HBASE_HOME=/home/bigdata/hbase
export PATH=$PATH:$HBASE_HOME/bin
EOF
#让环境变量生效
[bigdata@node1 ~]$ source .bash_profile

配置HBase

[bigdata@node1 ~]$ cd /home/bigdata/hbase/conf/
#修改hbase配置文件
[bigdata@node1 conf]$ vim hbase-env.sh        #去掉#注释并修改
export JAVA_HOME=/usr/local/jdk1.8.0_391
#export HBASE_SSH_OPTS="-p 12122"    #实际生产环境中，一般ssh端口会修改为其他端口，则需要配置此处
export HBASE_PID_DIR=/home/bigdata/hbase/pids    #保存pid文件
export HBASE_MANAGES_ZK=false    #禁用HBase自带的Zookeeper，因为我们是使用独立的Zookeeper

<configuration>
  <!-- 设置HRegionServers共享目录 -->
  <property>
    <name>hbase.rootdir</name>
    <value>hdfs://mycluster/hbase</value>
  </property>
  <property>
    <name>hbase.master.info.port</name>
    <value>60010</value>
  </property>
  <!-- 启用分布式模式 -->
    <property>
    <name>hbase.cluster.distributed</name>
    <value>true</value>
  </property>
  <!-- 指定Zookeeper集群位置 -->
  <property>
    <name>hbase.zookeeper.quorum</name>
    <value>node1:2181,node2:2181,node3:2181</value>
  </property>
  <!-- 指定独立Zookeeper安装路径 -->
  <property>
    <name>hbase.zookeeper.property.dataDir</name>
    <value>/home/bigdata/zookeeper/data</value>
  </property>
  <!-- 指定ZooKeeper集群端口 -->
  <property>
    <name>hbase.zookeeper.property.clientPort</name>
    <value>2181</value>
  </property>
  <property>
    <name>hbase.tmp.dir</name>
    <value>/home/bigdata/hbase/tmp</value>
  </property>
  <!--HBase将按照正常的写入路径进行处理与检查-->
  <property>
    <name>hbase.unsafe.stream.capability.enforce</name>
    <value>false</value>
  </property>
  <property>
    <name>hbase.wal.provider</name>
    <value>filesystem</value>
  </property>
</configuration>

#配置regionserver节点
[bigdata@node1 conf]$ cat > regionservers << EOF
node1
node2
node3
EOF

将hadoop的相关配置文件放到hbase目录下

[bigdata@node1 conf]$ cd /home/bigdata/hadoop/etc/hadoop/
[bigdata@node1 hadoop]$ cp core-site.xml hdfs-site.xml /home/bigdata/hbase/conf/

拷贝hbase相关文件到其他节点

[bigdata@node1 hadoop]$ cd
[bigdata@node1 ~]$ for i in {node2,node3}
do
scp -r /home/bigdata/hbase/ $i:/home/bigdata/
scp ~/.bash_profile $i:~/
done

启动HBase

主节点启动，主节点是namenode为active状态的节点

可通过命令hdfs haadmin -getServiceState nn1 ， hdfs haadmin -getServiceState nn2 查看

[bigdata@node1 ~]$ hdfs haadmin -getServiceState nn1
active
[bigdata@node1 ~]$ hdfs haadmin -getServiceState nn2
standby
#启动hbase，此时的zookeeper和hadoop集群为启动状态
[bigdata@node1 ~]$ start-hbase.sh
#备用主节点需要单独启动，一定记得执行
[bigdata@node2 ~]$ hbase-daemon.sh start master
#启动成功后主节点有HMaster、Regionserver进程，node3上有Regionserver进程
[bigdata@node1 ~]$ jps
4835 DataNode
10948 TaskManagerRunner
15173 HRegionServer
7624 HistoryServer
6319 NodeManager
15632 Jps
5265 DFSZKFailoverController
10643 StandaloneSessionClusterEntrypoint
14964 HMaster
2133 QuorumPeerMain
4693 NameNode
6901 Master
5079 JournalNode
6167 ResourceManager
11837 TaskManagerRunner
14495 Kafka
[bigdata@node2 ~]$ jps
2752 DataNode
7106 TaskManagerRunner
9986 Jps
2851 JournalNode
9738 HMaster
9197 Kafka
2670 NameNode
3822 Worker
1873 QuorumPeerMain
4433 HistoryServer
6802 StandaloneSessionClusterEntrypoint
9458 HRegionServer
3316 NodeManager
3221 ResourceManager
3928 Master
2937 DFSZKFailoverController
7836 TaskManagerRunner
[bigdata@node3 ~]$ jps
2114 DataNode
1860 QuorumPeerMain
2884 Worker
6246 Kafka
2263 NodeManager
7049 HRegionServer
4395 TaskManagerRunner
7295 Jps

浏览器访问HBase

http://192.168.1.5:60010
http://192.168.1.6:60010

可以看到 node1上显示 Master node1 ，在node2上显示Backup Master node2

Current Active Master: node1

高可用测试

kill 掉node1上的 HMaster ,在浏览器中查看备用主节点node2上的HBase是否切换为active
再次启动node1  ， hbase-daemon.sh start master ，访问node1页面显示 node2为active
再次kill 到node2 的 HMaster ，再次查看，又切换了回去，在启动node2查看。hbase-daemon.sh start master
再次查看node2 的页面 显示node1为active，测试成功。

hbase的常用命令

#随便找个节点，进入hbase
[bigdata@node3 ~]$ hbase shell        #进入hbase
hbase:003:0> version        #查看hbase版本
2.4.17, r7fd096f39b4284da9a71da3ce67c48d259ffa79a, Fri Mar 31 18:10:45 UTC 2023
Took 0.0004 seconds   
hbase:004:0> help            #帮助命令，所有的帮助
hbase:005:0> help 'create'    #指定命令的帮助
hbase:006:0> create_namespace 'oldsixl'        #创建命名空间
Took 0.1468 seconds
hbase:007:0> list_namespace    #查看所有命名空间
NAMESPACE
default
hbase
oldsixl
3 row(s)
Took 0.0433 seconds
hbase:011:0> status    #查看集群状态
1 active master, 1 backup masters, 3 servers, 0 dead, 0.6667 average load
Took 0.0833 seconds
hbase:012:0> drop_namespace 'oldsixl'    #删除命名空间，该命名空间必须为空，否则系统不让删除。
Took 0.1446 seconds
hbase:013:0> create_namespace 'oldsixlns'
Took 0.1256 seconds  
hbase:016:0> create 'oldsixlns:test_table','cf'        #创建表test_table，这个表只有一个 列族 为 cf
Created table oldsixlns:test_table
Took 0.6492 seconds                                                                       
=> Hbase::Table - oldsixlns:test_table
hbase:017:0> list    #列出所有表
TABLE                                                                                     
oldsixlns:test_table                                                                     
1 row(s)
Took 0.0044 seconds                                                                       
=> ["oldsixlns:test_table"]
hbase:019:0> put 'oldsixlns:test_table','row1','cf:a','value1'    #表中插入数据
Took 0.1267 seconds                                                                       
hbase:020:0> put 'oldsixlns:test_table','row2','cf:b','value2'
Took 0.5323 seconds                                                                       
hbase:021:0> put 'oldsixlns:test_table','row3','cf:c','value3'
Took 0.0086 seconds        
hbase:022:0> scan 'oldsixlns:test_table'    #查看表中所有数据
ROW                                               COLUMN+CELL                             
 row1                                             column=cf:a, timestamp=2023-07-19T23:30:01.368, value=value1                   
 row2                                             column=cf:b, timestamp=2023-07-19T23:30:12.444, value=value2                   
 row3                                             column=cf:c, timestamp=2023-07-19T23:30:21.700, value=value3                   
3 row(s)
hbase:024:0> get 'oldsixlns:test_table','row1'        #精确查询某行数据
COLUMN                                            CELL                                                                           
 cf:a                                             timestamp=2023-07-19T23:30:01.368, value=value1                               
1 row(s)
Took 0.0217 seconds                                                                                                             
hbase:025:0> scan 'oldsixlns:test_table',{ROWPREFIXFILTER=>'row1'}    #查看roukey前面是row1，可以写成前面的任意n为字符
ROW                                               COLUMN+CELL                                                                   
 row1                                             column=cf:a, timestamp=2023-07-19T23:30:01.368, value=value1                   
1 row(s)
Took 0.0081 seconds 
hbase:026:0> scan 'oldsixlns:test_table',{ROWPREFIXFILTER=>'row',LIMIT=>2}
ROW                                               COLUMN+CELL                                                                   
 row1                                             column=cf:a, timestamp=2023-07-19T23:30:01.368, value=value1                   
 row2                                             column=cf:b, timestamp=2023-07-19T23:30:12.444, value=value2                   
2 row(s)
Took 0.0064 second
hbase:036:0> scan 'oldsixlns:test_table',{FILTER=>"PrefixFilter('row')",LIMIT =>10}    #查看表中包含row的数据
ROW                                               COLUMN+CELL                                                                   
 row1                                             column=cf:a, timestamp=2023-07-19T23:30:01.368, value=value1                   
 row2                                             column=cf:b, timestamp=2023-07-19T23:30:12.444, value=value2                   
 row3                                             column=cf:c, timestamp=2023-07-19T23:30:21.700, value=value3                   
3 row(s)
Took 0.0118 seconds   
hbase:038:0> scan 'oldsixlns:test_table',{TIMERANGE=>[1689779520000,1689783120000],LIMIT=>1}    #获取指定时间的时间戳 date -d '2023-06-08 16:12:00' +%s%3N       ，当前服务器的时间的时间戳:date +%s%3N
ROW                                               COLUMN+CELL                                                                   
 row1                                             column=cf:a, timestamp=2023-07-19T23:30:01.368, value=value1                   
1 row(s)
Took 0.0071 seconds        
hbase:045:0> scan 'oldsixlns:test_table',{FILTER=>"ValueFilter(=,'substring:va') AND ValueFilter(=,'substring:1')",LIMIT=>10}    #查询数据中既有va，又有1的数据
ROW                                               COLUMN+CELL                                                                   
 row1                                             column=cf:a, timestamp=2023-07-19T23:30:01.368, value=value1                   
1 row(s)
Took 0.0075 seconds  
hbase:046:0> describe 'oldsixlns:test_table'    #查看表结构
Table oldsixlns:test_table is ENABLED                                                                                           
oldsixlns:test_table                                                                                                             
COLUMN FAMILIES DESCRIPTION                                                                                                     
{NAME => 'cf', BLOOMFILTER => 'ROW', IN_MEMORY => 'false', VERSIONS => '1', KEEP_DELETED_CELLS => 'FALSE', DATA_BLOCK_ENCODING => 'NONE', COMPRESSION => 'NONE', TTL => 'FOREVER', MIN_VERSIONS =>
 '0', BLOCKCACHE => 'true', BLOCKSIZE => '65536', REPLICATION_SCOPE => '0'}                                                     
1 row(s)
Quota is disabled
Took 0.0392 seconds
hbase:057:0> alter 'namespace:table',{NAME=>'cf',COMPRESSION=>'SNAPPY'}    #开启压缩
hbase:058:0> alter 'oldsixlns:test_table',NAME=>'cf',TTL=>'86400'    #修改ttl，单位秒，数据保存的时间
hbase:059:0> count 'oldsixlns:test_table'    
3 row(s)
hbase:060:0> deleteall 'oldsixlns:test_table','row1'    #删除rowkey为row1的所有数据
Took 0.0075 seconds                                                                                                             
hbase:063:0> delete 'oldsixlns:test_table','row2','cf:b'    #删除row2，cf:b的数据
Took 0.0089 seconds                                                                                
hbase:064:0> scan 'oldsixlns:test_table'    
ROW                                               COLUMN+CELL                             
 row3                                             column=cf:c, timestamp=2023-07-19T23:30:21.700, value=value3                   
1 row(s)
Took 0.0053 seconds         
hbase:070:0> is_disabled 'oldsixlns:test_table'        #查看表是否被禁用
false                                                                                                                           
Took 0.0103 seconds                                                                                                             
=> false
hbase:071:0> truncate 'oldsixlns:test_table'        #清空表数据
Truncating 'oldsixlns:test_table' table (it may take a while):
Disabling table...
Truncating table...
Took 1.4789 seconds 
hbase:076:0> disable 'oldsixlns:test_table'        #禁用表，如果要删除表，必须先禁用表
Took 0.3266 seconds                                                                                                             
hbase:077:0> drop 'oldsixlns:test_table'    #删除表

#在终端导出hbase库的数据到本地，不要进入hbase，直接执行。有特殊字符报错的话，加上\ 转义符就好了
[bigdata@node3 ~]$ echo "scan 'oldsixlns:test_table',{FILTER=>\"ValueFilter(=,'substring:value1')\"}" | hbase shell > test.txt

hbase表结构形式

创建下面的一张表

create_namespace 'MrLOAM'
create 'MrLOAM:employee_info', 'info', 'detail', 'address'
第一行
put 'MrLOAM:employee_info', 'xiaoming', 'info:id', '1'
put 'MrLOAM:employee_info', 'xiaoming', 'info:name', '小明'
put 'MrLOAM:employee_info', 'xiaoming', 'info:age', '25'
put 'MrLOAM:employee_info', 'xiaoming', 'detail:birth', '1997-03-06'
put 'MrLOAM:employee_info', 'xiaoming', 'detail:w_time', '2023-07-01 13:00:00'
put 'MrLOAM:employee_info', 'xiaoming', 'detail:email', 'a@gmail'
put 'MrLOAM:employee_info', 'xiaoming', 'address', '上海'
第二行
put 'MrLOAM:employee_info', 'xiaohong', 'info:id', '2'
put 'MrLOAM:employee_info', 'xiaohong', 'info:name', '小红'
put 'MrLOAM:employee_info', 'xiaohong', 'info:age', '26'
put 'MrLOAM:employee_info', 'xiaohong', 'detail:birth', '1998-06-05'
put 'MrLOAM:employee_info', 'xiaohong', 'detail:w_time', '2023-07-01 13:05:00'
put 'MrLOAM:employee_info', 'xiaohong', 'detail:email', 'c@sina'
put 'MrLOAM:employee_info', 'xiaohong', 'address', '北京'
第二行
put 'MrLOAM:employee_info', 'xiaohei', 'info:id', '3'
put 'MrLOAM:employee_info', 'xiaohei', 'info:name', '小黑'
put 'MrLOAM:employee_info', 'xiaohei', 'info:age', '28'
put 'MrLOAM:employee_info', 'xiaohei', 'detail:birth', '2000-01-01'
put 'MrLOAM:employee_info', 'xiaohei', 'detail:w_time', '2023-07-01 13:10:30'
put 'MrLOAM:employee_info', 'xiaohei', 'detail:email', 'e@qq'
put 'MrLOAM:employee_info', 'xiaohei', 'address', '广州'

查看表数据

部署hive高可用集群

Hive需要使用其他关系型数据作为其元数据存储，如mysql、Oracle、PostgreSQL等。Hive与其他类型的数据库（如Oracle、PostgreSQL等）的集成有限，主要是通过自定义配置和JDBC驱动程序进行实现。

MySQL是Hive的推荐数据库之一，有以下几个优点：

成熟稳定：MySQL是一种成熟、稳定且广泛使用的关系型数据库管理系统。它经过了多年的发展和测试，并且在各种生产环境中得到了广泛应用。这使得MySQL在可靠性和稳定性方面表现优秀。
兼容性：Hive与MySQL的集成非常紧密，它提供了与MySQL数据库的无缝连接和交互。Hive提供了专门的MySQL存储处理程序，可以直接使用MySQL作为其元数据存储。这种紧密的集成使得Hive能够有效地管理和查询大规模的数据。
易用性：MySQL具有简单易用的特点，它提供了直观的命令行和图形界面工具，使得用户可以方便地管理和操作数据库。这使得MySQL成为了许多开发者和数据工程师的首选数据库。
社区支持：MySQL拥有庞大的开源社区支持，这意味着你可以轻松地找到关于MySQL的文档、教程、示例代码以及问题解答。这种社区支持为用户提供了丰富的资源和帮助，使得使用和维护MySQL变得更加容易。

此处将使用MySQL作为hive的元数据存储

在安装 Hive 之前，需要先确定 Hive 所需的 MySQL 版本。一般来说，Hive 2.x 版本需要 MySQL 5.6 或更高版本，而 Hive 3.x 版本需要 MySQL 5.7 或更高版本。

Apache Hive 3.1.3 需要 MySQL 5.7 或更高版本。具体来说，需要使用 MySQL 5.7.17 或更高版本，因为 Hive 3.1.3 使用了 MySQL 5.7.17 中引入的一些功能。如果使用的是 MySQL 8.x 版本，则需要将 Hive 的 JDBC 驱动程序升级到 MySQL 8.x 版本的驱动程序。

上传mysql

mysql-5.7.38-el7-x86_64.tar.gz

安装mysql

卸载系统自带的mariadb

#查看并卸载系统的mariadb软件
[root@node1 ~]# rpm -qa | grep mariadb
mariadb-libs-5.5.68-1.el7.x86_64
#卸载mariadb
[root@node1 ~]# rpm -e --nodeps mariadb-libs-5.5.68-1.el7.x86_64
#查看系统是否有mysql
[root@node1 ~]# rpm -qa | grep mysql
#创建mysql用户并禁止登录
[root@node1 ~]# useradd mysql -s /sbin/nologin

解压mysql安装包并安装

[root@node1 ~]# tar -xf mysql-5.7.35-el7-x86_64.tar.gz -C /usr/local/
[root@node1 ~]# cd /usr/local/
[root@node1 local]# mv mysql-5.7.35-el7-x86_64/ mysql
#创建mysql数据目录以及配置目录
[root@node1 local]# mkdir mysql/{data,conf,logs,binlog}
#添加mysql环境变量
[root@node1 ~]# cat >> .bash_profile << 'EOF'
#MySQL环境变量
export MYSQL_HOME=/usr/local/mysql
export PATH=$PATH:$MYSQL_HOME/bin
EOF
[root@node1 ~]# source .bash_profile

配置mysql

cat > my.cnf << 'EOF'
#客户端配置，包括客户端连接mysql服务器的相关配置
[client]    
port = 3306
socket = /usr/local/mysql/mysqld.sock
default-character-set = utf8mb4
#MySQL命令行客户端的配置
[mysql]
#指定MySQL命令行提示符的格式。
prompt="\u@mysqldb \R:\m:\s [\d]> "    
#禁用自动补全功能
no-auto-rehash
#指定MySQL命令行客户端的默认字符集
default-character-set = utf8mb4
#MySQL服务器的配置
[mysqld]
#指定MySQL服务器运行的用户 （一般设置为mysql，需要提前创建mysql用户）
user = mysql
#指定MySQL服务器监听的端口号
port = 3306
socket = /usr/local/mysql/mysqld.sock
#禁用DNS反向解析
skip-name-resolve
# 设置字符编码
character-set-server = utf8
collation-server = utf8_general_ci
# 设置默认时区
#default-time_zone='+8:00'
#指定MySQL服务器的唯一标识
server-id = 1
# Directory
#安装目录
basedir = /usr/local/mysql
#数据存储目录
datadir = /usr/local/mysql/data
#安全文件目录
secure_file_priv = /usr/local/mysql/data
#PID文件的路径
pid-file = /usr/local/mysql/mysql.pid
#MySQL服务器的最大连接数
max_connections       = 1024
#最大连接错误数
max_connect_errors    = 100
#连接超时时间
wait_timeout          = 100
#最大允许数据包大小
max_allowed_packet    = 128M
#表缓存数量
table_open_cache      = 2048
#连接请求队列长度
back_log              = 600
#指定MySQL服务器的默认存储引擎
default-storage-engine = innodb
#允许二进制日志中包含函数创建语句
log_bin_trust_function_creators = 1
# Log
#关闭通用查询日志
general_log=off
#general_log_file =  /usr/local/mysql/logs/mysql.log
#错误日志的路径
log-error = /usr/local/mysql/logs/error.log
# binlog
#指定二进制日志的路径和格式
log-bin = /usr/local/mysql/binlog/mysql-binlog
binlog_format=mixed
#slowlog慢查询日志
slow_query_log = 1
slow_query_log_file = /usr/local/mysql/logs/slow.log
long_query_time = 2
log_output = FILE
log_queries_not_using_indexes = 0
#global_buffers
innodb_buffer_pool_size = 2G
innodb_log_buffer_size = 16M
innodb_flush_log_at_trx_commit = 2
key_buffer_size = 64M
innodb_log_file_size = 512M
innodb_log_file_size = 2G
innodb_log_files_in_group = 2
innodb_data_file_path = ibdata1:20M:autoextend
sql_mode = STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION
[mysqldump]
#指定mysqldump工具使用快速导出模式
quick
#指定mysqldump工具允许的最大数据包大小为32M
max_allowed_packet = 32M
EOF

初始化MySQL并启动

[root@node1 conf]# ln my.cnf /etc/my.cnf 
#将mysql文件下的文件归属设置为mysql
[root@node1 conf]# chown -R mysql.mysql /usr/local/mysql/
#初始化mysql
[root@node1 conf]# cd ..
[root@node1 mysql]# ./bin/mysqld --initialize --user=mysql --datadir=/usr/local/mysql/data/ --basedir=/usr/local/mysql
#配置mysql快捷启动
[root@node1 mysql]# cp support-files/mysql.server /etc/init.d/mysqld
[root@node1 mysql]# chmod +x /etc/init.d/mysqld
#启动mysql
[root@node1 mysql]# /etc/init.d/mysqld start
Starting MySQL. SUCCESS!

#设置mysql开机自启
[root@node1 mysql]# chkconfig --level 35 mysqld on
[root@node1 mysql]# chkconfig --list mysqld
[root@node1 mysql]# chmod +x /etc/rc.d/init.d/mysqld
[root@node1 mysql]# chkconfig --add mysqld
[root@node1 mysql]# chkconfig --list mysqld
[root@node1 mysql]# service mysqld status
[root@node1 mysql]# reboot
[root@node1 ~]# ss -ntulp | grep mysql
tcp    LISTEN     0      128    [::]:3306               [::]:*                   users:(("mysqld",pid=1712,fd=32))

创建Hive使用的相关用户并授权

#登录mysql
#查看mysql初始化密码
[root@node1 ~]# grep password /usr/local/mysql/logs/error.log
A temporary password is generated for root@localhost: rk#SdSy6&BB1
#修改mysql密码方法1
[root@node1 ~]# mysqladmin -uroot -p'rk#SdSy6&BB1' password 123456
[root@node1 ~]# mysql -uroot -p123456
root@mysqldb 22:50:  [(none)]> set PASSWORD = PASSWORD('123');    #修改密码方法2
root@mysqldb 22:55:  [(none)]> flush privileges;
#添加远程访问权限
root@mysqldb 22:55:  [(none)]> grant all privileges on *.* to 'root'@'%' identified by '123' with grant option;
#创建hive库并授权
root@mysqldb 22:58:  [(none)]> create database hive;
root@mysqldb 22:58:  [(none)]> create user "hive"@"%" identified by "123";
root@mysqldb 22:59:  [(none)]> grant all privileges on hive.* to "hive"@"%";
root@mysqldb 23:00:  [(none)]> flush privileges;

解压hive安装包并配置环境变量

[bigdata@node1 ~]$ tar -xf apache-hive-3.1.3-bin.tar.gz -C /home/bigdata/
[bigdata@node1 ~]$ mv /home/bigdata/apache-hive-3.1.3-bin/  /home/bigdata/hive
#配置环境变量
[bigdata@node1 ~]$ cat >> .bash_profile << 'EOF'
#Hive环境变量
export HIVE_HOME=/home/bigdata/hive
export PATH=$PATH:$HIVE_HOME/bin
EOF
[bigdata@node1 ~]$ source .bash_profile

修改hive配置

[bigdata@node1 ~]$ cd /home/bigdata/hive/conf/
#配置hive日志文件
[bigdata@node1 conf]$ cp hive-log4j2.properties.template hive-log4j2.properties
[bigdata@node1 conf]$ vim hive-log4j2.properties
property.hive.log.dir = /home/bigdata/hive/logs
[bigdata@node1 conf]$ cp hive-env.sh.template hive-env.sh
#用vim修改hive-env.sh，最后修改如下：
[bigdata@node1 conf]$ grep -vE '^$|^#' hive-env.sh
HADOOP_HOME=/home/bigdata/hadoop
export HIVE_CONF_DIR=/home/bigdata/hive/conf
export HIVE_AUX_JARS_PATH=/home/bigdata/hive/lib

配置metastore

metastore是Hive用于管理库表元数据的服务，它存储了Hive中的元数据信息。元数据信息包括表的结构、列、分区等信息，以及表的索引、约束、视图等。有了Metastore服务，Hive的客户端应用程序可以通过连接Metastore服务来获取这些元数据信息，而无需直接访问底层的文件系统。这使得客户端可以基于结构化的库表信息构建计算框架，简化了数据访问和管理。
在hive-metastore节点上操作，即node1和node2上

#创建hdfs相关目录,记得启动zk、hdfs和yarn，上面我重启过系统
[bigdata@node1 conf]$ hdfs dfs -mkdir -p /home/bigdata/data/hive/{warehouse,tmp,logs}

#创建配置文件metastore-site.xml，是Hive的元数据存储配置文件，用于指定Hive元数据存储的位置和相关配置。创建metastore-site.xml文件后，可以在其中配置Hive元数据存储的数据库类型、连接信息、用户名、密码等信息。
 
[bigdata@node1 conf]$ cat > metastore-site.xml << 'EOF'
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
    <!--指定Hive元数据存储在本地 -->
    <property>
      <name>hive.metastore.local</name>
      <value>true</value>
    </property>
    <!--Hive作业的HDFS根目录位置 -->
    <property>
      <name>hive.exec.scratchdir</name>
      <value>/home/bigdata/data/hive/tmp</value>
    </property>
    <!--Hive作业的HDFS根目录创建和写权限 -->
    <property>
      <name>hive.scratch.dir.permission</name>
      <value>775</value>
    </property>
    <!--指定Hive元数据存放在HDFS上的位置 -->
    <property>
      <name>hive.metastore.warehouse.dir</name>
      <value>/home/bigdata/data/hive/warehouse</value>
    </property>
    <!--连接数据库地址，名称 -->
    <property>
      <name>javax.jdo.option.ConnectionURL</name>
      <value>jdbc:mysql://node1:3306/hive?createDatabaseIfNotExist=true</value>
    </property>
    <!--连接数据库驱动 -->
    <property>
      <name>javax.jdo.option.ConnectionDriverName</name>
      <value>com.mysql.jdbc.Driver</value>
    </property>
    <!--连接数据库用户名称 -->
    <property>
      <name>javax.jdo.option.ConnectionUserName</name>
      <value>hive</value>
    </property>
    <!--连接数据库用户密码 -->
    <property>
      <name>javax.jdo.option.ConnectionPassword</name>
      <value>123</value>
    </property>
    <!-- 指定metastore连接地址 -->
    <property>
      <name>hive.metastore.uris</name>
      <value>thrift://node1:9083,thrift://node2:9083</value>
    </property>
</configuration>
EOF

分发文件到其他节点

[bigdata@node1 conf]$ for i in {node2,node3}
do 
scp -r /home/bigdata/hive/ $i:/home/bigdata/
scp ~/.bash_profile $i:~/
done

初始化MYSQL

下载mysql驱动包到Hive的lib目录下

MySQL :: Download MySQL Connector/J (Archived Versions)

 mv mysql-connector-java-5.1.49.jar hive/lib/
 scp lib/mysql-connector-java-5.1.49.jar node2:~/hive/lib/
 scp lib/mysql-connector-java-5.1.49.jar node3:~/hive/lib/

删除hive下的log4j-slf4j-impl-2.17.1.jar，会与hadoop下的slf4j-reload4j-1.7.36.jar 冲突
[bigdata@node1 ~]$ for i in {node1,node2,node3}
do
ssh $i "rm -f /home/bigdata/hive/lib/log4j-slf4j-impl-2.17.1.jar"
done

标签： hadoop zookeeper spark

本文转载自: https://blog.csdn.net/nsa65223/article/details/135381295
版权归原作者 nsa65223 所有，如有侵权，请联系我们删除。