Lanson

V1

2022/08/09阅读:27主题:兰青

湖仓一体电商项目(三):3万字带你从头开始搭建12个大数据项目基础组件

接下带大家一一搭建项目基础组件

一、搭建Zookeeper

这里搭建zookeeper版本为3.4.13,搭建zookeeper对应的角色分布如下:

节点IP 节点名称 Zookeeper
192.168.179.4 node1
192.168.179.5 node2
192.168.179.6 node3
192.168.179.7 node4
192.168.179.8 node5

具体搭建步骤如下:

1、上传zookeeper并解压,配置环境变量

在node1,node2,node3,node4,node5各个节点都创建/software目录,方便后期安装技术组件使用。

mkdir /software

将zookeeper安装包上传到node3节点/software目录下并解压:

[root@node3 software]# tar -zxvf ./zookeeper-3.4.13.tar.gz 

在node3节点配置环境变量:

#进入vim /etc/profile,在最后加入:
export ZOOKEEPER_HOME=/software/zookeeper
export PATH=$PATH:$ZOOKEEPER_HOME/bin

#使配置生效
source /etc/profile

2、在node3节点配置zookeeper

进入“/software/zookeeper-3.4.13/conf”修改zoo_sample.cfg为zoo.cfg

[root@node3 conf]# mv zoo_sample.cfg  zoo.cfg

配置zoo.cfg中内容如下:

tickTime=2000 initLimit=10 syncLimit=5 dataDir=/opt/data/zookeeper clientPort=2181 server.1=node3:2888:3888 server.2=node4:2888:3888 server.3=node5:2888:3888

3、将配置好的zookeeper发送到node4,node5节点

[root@node3 software]# scp -r ./zookeeper-3.4.13 node4:/software/
[root@node3 software]# scp -r ./zookeeper-3.4.13 node5:/software/

4、各个节点上创建数据目录,并配置zookeeper环境变量

在node3,node4,node5各个节点上创建zoo.cfg中指定的数据目录“/opt/data/zookeeper”。

mkdir -p /opt/data/zookeeper

在node4,node5节点配置zookeeper环境变量

#进入vim /etc/profile,在最后加入:
export ZOOKEEPER_HOME=/software/zookeeper
export PATH=$PATH:$ZOOKEEPER_HOME/bin

#使配置生效
source /etc/profile

5、各个节点创建节点ID

在node3,node4,node5各个节点路径“/opt/data/zookeeper”中添加myid文件分别写入1,2,3:

#在node3的/opt/data/zookeeper中创建myid文件写入1 #在node4的/opt/data/zookeeper中创建myid文件写入2 #在node5的/opt/data/zookeeper中创建myid文件写入3

6、各个节点启动zookeeper,并检查进程状态

#各个节点启动zookeeper命令
zkServer.sh start

#检查各个节点zookeeper进程状态
zkServer.sh status

二、搭建HDFS

这里搭建HDFS版本为3.1.4,搭建HDFS对应的角色在各个节点分布如下:

节点IP 节点名称 NN DN ZKFC JN RM NM
192.168.179.4 node1
192.168.179.5 node2
192.168.179.6 node3
192.168.179.7 node4
192.168.179.8 node5

搭建具体步骤如下:

1、各个节点安装HDFS HA自动切换必须的依赖

yum -y install psmisc

2、上传下载好的Hadoop安装包到node1节点上,并解压

[root@node1 software]# tar -zxvf ./hadoop-3.1.4.tar.gz

3、在node1节点上配置Hadoop的环境变量

[root@node1 software]# vim /etc/profile
export HADOOP_HOME=/software/hadoop-3.1.4/
export PATH=$PATH:$HADOOP_HOME/bin:$HADOOP_HOME/sbin:

#使配置生效
source /etc/profile

4、配置$HADOOP_HOME/etc/hadoop下的hadoop-env.sh文件

#导入JAVA_HOME export JAVA_HOME=/usr/java/jdk1.8.0_181-amd64/

5、配置$HADOOP_HOME/etc/hadoop下的hdfs-site.xml文件

<configuration>
    <property>
        <!--这里配置逻辑名称,可以随意写 -->
        <name>dfs.nameservices</name>
        <value>mycluster</value>
    </property>

    <property>
        <!-- 禁用权限 -->
        <name>dfs.permissions.enabled</name>
        <value>false</value>
    </property>

    <property>
        <!-- 配置namenode 的名称,多个用逗号分割  -->
        <name>dfs.ha.namenodes.mycluster</name>
        <value>nn1,nn2</value>
    </property>

    <property>
        <!-- dfs.namenode.rpc-address.[nameservice ID].[name node ID] namenode 所在服务器名称和RPC监听端口号  -->
        <name>dfs.namenode.rpc-address.mycluster.nn1</name>
        <value>node1:8020</value>
    </property>

    <property>
        <!-- dfs.namenode.rpc-address.[nameservice ID].[name node ID] namenode 所在服务器名称和RPC监听端口号  -->
        <name>dfs.namenode.rpc-address.mycluster.nn2</name>
        <value>node2:8020</value>
    </property>

    <property>
        <!-- dfs.namenode.http-address.[nameservice ID].[name node ID] namenode 监听的HTTP协议端口 -->
        <name>dfs.namenode.http-address.mycluster.nn1</name>
        <value>node1:50070</value>
    </property>

    <property>
        <!-- dfs.namenode.http-address.[nameservice ID].[name node ID] namenode 监听的HTTP协议端口 -->
        <name>dfs.namenode.http-address.mycluster.nn2</name>
        <value>node2:50070</value>
    </property>


    <property>
        <!-- namenode 共享的编辑目录, journalnode 所在服务器名称和监听的端口 -->
        <name>dfs.namenode.shared.edits.dir</name>
        <value>qjournal://node3:8485;node4:8485;node5:8485/mycluster</value>
    </property>


    <property>
        <!-- namenode高可用代理类 -->
        <name>dfs.client.failover.proxy.provider.mycluster</name>
        <value>org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider</value>
    </property>


    <property>
        <!-- 使用ssh 免密码自动登录 -->
        <name>dfs.ha.fencing.methods</name>
        <value>sshfence</value>
    </property>


    <property>
        <name>dfs.ha.fencing.ssh.private-key-files</name>
        <value>/root/.ssh/id_rsa</value>
    </property>


    <property>
        <!-- journalnode 存储数据的地方 -->
        <name>dfs.journalnode.edits.dir</name>
        <value>/opt/data/journal/node/local/data</value>
    </property>


    <property>
        <!-- 配置namenode自动切换 -->
        <name>dfs.ha.automatic-failover.enabled</name>
        <value>true</value>
    </property>


</configuration>

6、配置$HADOOP_HOME/ect/hadoop/core-site.xml

<configuration>
    <property>
        <!-- 为Hadoop 客户端配置默认的高可用路径  -->
        <name>fs.defaultFS</name>
        <value>hdfs://mycluster</value>
    </property>

    <property>
        <!-- Hadoop 数据存放的路径,namenode,datanode 数据存放路径都依赖本路径,不要使用 file:/ 开头,使用绝对路径即可
            namenode 默认存放路径 :file://${hadoop.tmp.dir}/dfs/name
            datanode 默认存放路径 :file://${hadoop.tmp.dir}/dfs/data
        -->

        <name>hadoop.tmp.dir</name>
        <value>/opt/data/hadoop/</value>
    </property>


    <property>
        <!-- 指定zookeeper所在的节点 -->
        <name>ha.zookeeper.quorum</name>
        <value>node3:2181,node4:2181,node5:2181</value>
    </property>


</configuration>

7、配置$HADOOP_HOME/etc/hadoop/yarn-site.xml

<configuration>
    <property>
        <name>yarn.nodemanager.aux-services</name>
        <value>mapreduce_shuffle</value>
    </property>

    <property>
        <name>yarn.nodemanager.env-whitelist</name>
        <value>JAVA_HOME,HADOOP_COMMON_HOME,HADOOP_HDFS_HOME,HADOOP_CONF_DIR,CLASSPATH_PREPEND_DISTCACHE,HADOOP_YARN_HOME,HADOOP_MAPRED_HOME</value>
    </property>


    <property>
        <!-- 配置yarn为高可用 -->
        <name>yarn.resourcemanager.ha.enabled</name>
        <value>true</value>
    </property>

    <property>
        <!-- 集群的唯一标识 -->
        <name>yarn.resourcemanager.cluster-id</name>
        <value>mycluster</value>
    </property>

    <property>
        <!--  ResourceManager ID -->
        <name>yarn.resourcemanager.ha.rm-ids</name>
        <value>rm1,rm2</value>
    </property>

    <property>
        <!-- 指定ResourceManager 所在的节点 -->
        <name>yarn.resourcemanager.hostname.rm1</name>
        <value>node1</value>
    </property>

    <property>
        <!-- 指定ResourceManager 所在的节点 -->
        <name>yarn.resourcemanager.hostname.rm2</name>
        <value>node2</value>
    </property>

    <property>
        <!-- 指定ResourceManager Http监听的节点 -->
        <name>yarn.resourcemanager.webapp.address.rm1</name>
        <value>node1:8088</value>
    </property>

    <property>
        <!-- 指定ResourceManager Http监听的节点 -->
        <name>yarn.resourcemanager.webapp.address.rm2</name>
        <value>node2:8088</value>
    </property>

    <property>
        <!-- 指定zookeeper所在的节点 -->
        <name>yarn.resourcemanager.zk-address</name>
        <value>node3:2181,node4:2181,node5:2181</value>
</property>

<property>
       <!-- 关闭虚拟内存检查 -->
    <name>yarn.nodemanager.vmem-check-enabled</name>
    <value>false</value>
</property>

 <!-- 启用节点的内容和CPU自动检测,最小内存为1G -->
    <!--<property>
        <name>yarn.nodemanager.resource.detect-hardware-capabilities</name>
        <value>true</value>
    </property>
-->
</configuration>

8、配置$HADOOP_HOME/etc/hadoop/mapred-site.xml

<configuration>
    <property>
        <name>mapreduce.framework.name</name>
        <value>yarn</value>
    </property>

</configuration>

9、配置$HADOOP_HOME/etc/hadoop/workers文件

[root@node1 ~]# vim /software/hadoop-3.1.4/etc/hadoop/workers
node3
node4
node5

10、配置$HADOOP_HOME/sbin/start-dfs.sh 和stop-dfs.sh两个文件中顶部添加以下参数,防止启动错误

HDFS_DATANODE_USER=root HDFS_DATANODE_SECURE_USER=hdfs HDFS_NAMENODE_USER=root HDFS_JOURNALNODE_USER=root HDFS_ZKFC_USER=root

11、配置$HADOOP_HOME/sbin/start-yarn.sh和stop-yarn.sh两个文件顶部添加以下参数,防止启动错误

YARN_RESOURCEMANAGER_USER=root YARN_NODEMANAGER_USER=root

12、将配置好的Hadoop安装包发送到其他4个节点

[root@node1 ~]# scp -r /software/hadoop-3.1.4 node2:/software/
[root@node1 ~]# scp -r /software/hadoop-3.1.4 node3:/software/
[root@node1 ~]# scp -r /software/hadoop-3.1.4 node4:/software/
[root@node1 ~]# scp -r /software/hadoop-3.1.4 node5:/software/

13、在node2、node3、node4、node5节点上配置HADOOP_HOME

#分别在node2、node3、node4、node5节点上配置HADOOP_HOME
vim /etc/profile
export HADOOP_HOME=/software/hadoop-3.1.4/
export PATH=$PATH:$HADOOP_HOME/bin:$HADOOP_HOME/sbin:

#最后记得Source
source /etc/profile

14、启动HDFS和Yarn

#在node3,node4,node5节点上启动zookeeper
zkServer.sh start

#在node1上格式化zookeeper
[root@node1 ~]# hdfs zkfc -formatZK

#在每台journalnode中启动所有的journalnode,这里就是node3,node4,node5节点上启动
hdfs --daemon start journalnode

#在node1中格式化namenode
[root@node1 ~]# hdfs namenode -format

#在node1中启动namenode,以便同步其他namenode
[root@node1 ~]# hdfs --daemon start namenode

#高可用模式配置namenode,使用下列命令来同步namenode(在需要同步的namenode中执行,这里就是在node2上执行):
[root@node2 software]# hdfs namenode -bootstrapStandby

#node1上启动HDFS,启动Yarn
[root@node1 sbin]# start-dfs.sh
[root@node1 sbin]# start-yarn.sh

注意以上也可以使用start-all.sh命令启动Hadoop集群。

15、访问WebUI

访问HDFS : http://node1:50070

访问Yarn WebUI :http://node1:8088

16、停止集群

#停止集群

[root@node1 ~]# stop-dfs.sh

[root@node1 ~]# stop-yarn.sh

注意:以上也可以使用 stop-all.sh 停止集群。

三、​​​​​​​搭建Hive

这里搭建Hive的版本为3.1.2,搭建Hive的节点划分如下:

节点IP 节点名称 Hive服务器 Hive客户端 MySQL
192.168.179.4 node1
192.168.179.5 node2 ★(已搭建)
192.168.179.6 node3

搭建具体步骤如下:

1、将下载好的Hive安装包上传到node1节点上,并修改名称

[root@node1 ~]# cd /software/
[root@node1 software]# tar -zxvf ./apache-hive-3.1.2-bin.tar.gz
[root@node1 software]# mv apache-hive-3.1.2-bin hive-3.1.2

2、将解压好的Hive安装包发送到node3节点上

[root@node1 ~]# scp -r /software/hive-3.1.2/ node3:/software/

3、配置node1、node3两台节点的Hive环境变量

vim /etc/profile
export HIVE_HOME=/software/hive-3.1.2/
export PATH=$PATH:$HIVE_HOME/bin

#source  生效
source /etc/profile

4、在node1节点$HIVE_HOME/conf下创建hive-site.xml并配置

<configuration>
 <property>
  <name>hive.metastore.warehouse.dir</name>
  <value>/user/hive/warehouse</value>
 </property>

 <property>
  <name>javax.jdo.option.ConnectionURL</name>
  <value>jdbc:mysql://node2:3306/hive?createDatabaseIfNotExist=true&amp;useSSL=false</value>
 </property>

 <property>
  <name>javax.jdo.option.ConnectionDriverName</name>
  <value>com.mysql.jdbc.Driver</value>
 </property>

 <property>
  <name>javax.jdo.option.ConnectionUserName</name>
  <value>root</value>
 </property>

 <property>
  <name>javax.jdo.option.ConnectionPassword</name>
  <value>123456</value>
 </property>

</configuration>

5、在node3节点$HIVE_HOME/conf/中创建hive-site.xml并配置

<configuration>
 <property>
  <name>hive.metastore.warehouse.dir</name>
  <value>/user/hive/warehouse</value>
 </property>

 <property>
  <name>hive.metastore.local</name>
  <value>false</value>
 </property>

 <property>
  <name>hive.metastore.uris</name>
  <value>thrift://node1:9083</value>
 </property>

</configuration>

6、node1、node3节点删除$HIVE_HOME/lib下“guava”包,使用Hadoop下的包替换

#删除Hive lib目录下“guava-19.0.jar ”包
[root@node1 ~]# rm -rf /software/hive-3.1.2/lib/guava-19.0.jar 
[root@node3 ~]# rm -rf /software/hive-3.1.2/lib/guava-19.0.jar 

#将Hadoop lib下的“guava”包拷贝到Hive lib目录下
[root@node1 ~]# cp /software/hadoop-3.1.4/share/hadoop/common/lib/guava-27.0-jre.jar /software/hive-3.1.2/lib/

[root@node3 ~]# cp /software/hadoop-3.1.4/share/hadoop/common/lib/guava-27.0-jre.jar /software/hive-3.1.2/lib/

7、将“mysql-connector-java-5.1.47.jar”驱动包上传到node1节点的$HIVE_HOME/lib目录下

上传后,需要将mysql驱动包传入$HIVE_HOME/lib/目录下,这里node1,node3节点都需要传入。

8、在node1节点中初始化Hive

#初始化hive,hive2.x版本后都需要初始化
[root@node1 ~]# schematool -dbType mysql -initSchema

9、在服务端和客户端操作Hive

#在node1中登录Hive ,创建表test
[root@node1 conf]# hive
hive> create table test (id int,name string,age int ) row format delimited fields terminated by '\t';

#向表test中插入数据
hive> insert into test values(1,"zs",18);

#在node1启动Hive metastore
[root@node1 hadoop]# hive --service metastore &

#在node3上登录Hive客户端查看表数据
[root@node3 lib]# hive
hive> select * from test;
OK
1 zs 18

四、Hive与Iceberg整合

Iceberg就是一种表格式,支持使用Hive对Iceberg进行读写操作,但是对Hive的版本有要求,如下:

操作 Hive 2.x Hive 3.1.2
CREATE EXTERNAL TABLE
CREATE TABLE
DROP TABLE
SELECT
INSERT INTO

这里基于Hive3.1.2版本进行Hive集成Iceberg。

1、开启Hive支持Iceberg

1.1、下载iceberg-hive-runtime.jar

想要使用Hive支持查询Iceberg表,首先需要下载“iceberg-hive-runtime.jar”,Hive通过该Jar可以加载Hive或者更新Iceberg表元数据信息。

下载地址:https://iceberg.apache.org/#releases/

将以上jar包下载后,上传到Hive服务端和客户端对应的$HIVE\_HOME/lib目录下。另外在向Hive中Iceberg格式表插入数据时需要到“libfb303-0.9.3.jar”包,将此包也上传到Hive服务端和客户端对应的$HIVE_HOME/lib目录下。

1.2、配置hive-site.xml

在Hive客户端$HIVE_HOME/conf/hive-site.xml中追加如下配置:

<property>
    <name>iceberg.engine.hive.enabled</name>
    <value>true</value>
</property>

2、​​​​​​​​​​​​​​Hive中操作Iceberg格式表

从Hive引擎的角度来看,在运行环境中有Catalog概念(catalog主要描述了数据集的位置信息,就是元数据),Hive与Iceberg整合时,Iceberg支持多种不同的Catalog类型,例如:Hive、Hadoop、第三方厂商的AWS Glue和自定义Catalog。在实际应用场景中,Hive可能使用上述任意Catalog,甚至跨不同Catalog类型join数据,为此Hive提供了org.apache.iceberg.mr.hive.HiveIcebergStorageHandler(位于包iceberg-hive-runtime.jar)来支持读写Iceberg表,并通过在Hive中设置“iceberg.catalog.<catalog_name>.type”属性来决定加载Iceberg表的方式,该属性可以配置:hive、hadoop,其中“<catalog_name>”是自己随便定义的名称,主要是在hive中创建Iceberg格式表时配置iceberg.catalog属性使用。

在Hive中创建Iceberg格式表时,根据创建Iceberg格式表时是否指定iceberg.catalog属性值,有以下三种方式决定Iceberg格式表如何加载(数据存储在什么位置)。

2.1、如果没有设置iceberg.catalog属性,默认使用HiveCatalog来加载

这种方式就是说如果在Hive中创建Iceberg格式表时,不指定iceberg.catalog属性,那么数据存储在对应的hive warehouse路径下。

在Hive客户端node3节点进入Hive,操作如下:

在Hive中创建iceberg格式表

create table test_iceberg_tbl1(
id int ,
name string,
age int) 
partitioned by (dt string) 
stored by 'org.apache.iceberg.mr.hive.HiveIcebergStorageHandler';

在Hive中加载如下两个包,在向Hive中插入数据时执行MR程序时需要使用到

hive> add jar /software/hive-3.1.2/lib/iceberg-hive-runtime-0.12.1.jar;
hive> add jar /software/hive-3.1.2/lib/libfb303-0.9.3.jar;

向表中插入数据

hive> insert into test_iceberg_tbl1 values (1,"zs",18,"20211212");

查询表中的数据

hive> select * from test_iceberg_tbl1;
OK
1 zs 18 20211212

在Hive默认的warehouse目录下可以看到创建的表目录:

2.2、如果设置了iceberg.catalog对应的catalog名字,就用对应类型的catalog加载

这种情况就是说在Hive中创建Iceberg格式表时,如果指定了iceberg.catalog属性值,那么数据存储在指定的catalog名称对应配置的目录下。

在Hive客户端node3节点进入Hive,操作如下:

注册一个HiveCatalog叫another_hive

hive> set iceberg.catalog.another_hive.type=hive;

在Hive中创建iceberg格式表

create table test_iceberg_tbl2(
id int,
name string,
age int
)
partitioned by (dt string)
stored by 'org.apache.iceberg.mr.hive.HiveIcebergStorageHandler'
tblproperties ('iceberg.catalog'='another_hive');

在Hive中加载如下两个包,在向Hive中插入数据时执行MR程序时需要使用到

hive> add jar /software/hive-3.1.2/lib/iceberg-hive-runtime-0.12.1.jar;
hive> add jar /software/hive-3.1.2/lib/libfb303-0.9.3.jar;

插入数据,并查询

hive> insert into test_iceberg_tbl2 values (2,"ls",20,"20211212");
hive> select * from test_iceberg_tbl2;
OK
2 ls 20 20211212

以上方式指定“iceberg.catalog.another_hive.type=hive”后,实际上就是使用的hive的catalog,这种方式与第一种方式不设置效果一样,创建后的表存储在hive默认的warehouse目录下。也可以在建表时指定location 写上路径,将数据存储在自定义对应路径上。

除了可以将catalog类型指定成hive之外,还可以指定成hadoop,在Hive中创建对应的iceberg格式表时需要指定location来指定iceberg数据存储的具体位置,这个位置是具有一定格式规范的自定义路径。在Hive客户端node3节点进入Hive,操作如下:

注册一个HadoopCatalog叫hadoop

hive> set iceberg.catalog.hadoop.type=hadoop;

使用HadoopCatalog时,必须设置“iceberg.catalog.<catalog_name>.warehouse”指定warehouse路径

hive> set iceberg.catalog.hadoop.warehouse=hdfs://mycluster/iceberg_data;

在Hive中创建iceberg格式表,这里创建成外表

create external table test_iceberg_tbl3(
id int,
name string,
age int
)
partitioned by (dt string)
stored by 'org.apache.iceberg.mr.hive.HiveIcebergStorageHandler'
location 'hdfs://mycluster/iceberg_data/default/test_iceberg_tbl3'
tblproperties ('iceberg.catalog'='hadoop');

注意:以上location指定的路径必须是“iceberg.catalog.hadoop.warehouse”指定路径的子路径,格式必须是\${iceberg.catalog.hadoop.warehouse}/${当前建表使用的hive库}/${创建的当前iceberg表名}

在Hive中加载如下两个包,在向Hive中插入数据时执行MR程序时需要使用到

hive> add jar /software/hive-3.1.2/lib/iceberg-hive-runtime-0.12.1.jar;
hive> add jar /software/hive-3.1.2/lib/libfb303-0.9.3.jar;

插入数据,并查询

hive> insert into test_iceberg_tbl3 values (3,"ww",20,"20211213");
hive> select * from test_iceberg_tbl3;
OK
3 ww 20 20211213

在指定的“iceberg.catalog.hadoop.warehouse”路径下可以看到创建的表目录:

2.3、如果iceberg.catalog属性设置为“location_based_table”,可以从指定的根路径下加载Iceberg 表

这种情况就是说如果HDFS中已经存在iceberg格式表,我们可以通过在Hive中创建Icerberg格式表指定对应的location路径映射数据。

在Hive客户端中操作如下:

CREATE TABLE test_iceberg_tbl4  (
  id int, 
  name string,
  age int,
  dt string
)STORED BY 'org.apache.iceberg.mr.hive.HiveIcebergStorageHandler' 
LOCATION 'hdfs://mycluster/spark/person' 
TBLPROPERTIES ('iceberg.catalog'='location_based_table');

注意:指定的location路径下必须是iceberg格式表数据,并且需要有元数据目录才可以。不能将其他数据映射到Hive iceberg格式表。

由于Hive建表语句分区语法“Partitioned by”的限制,如果使用Hive创建Iceberg格式表,目前只能按照Hive语法来写,底层转换成Iceberg标识分区,这种情况下不能使用Iceberge的分区转换,例如:days(timestamp),如果想要使用Iceberg格式表的分区转换标识分区,需要使用Spark或者Flink引擎创建表。

五、​​​​​​​搭建HBase

这里选择HBase版本为2.2.6,搭建HBase各个角色分布如下:

节点IP 节点名称 HBase服务
192.168.179.6 node3 RegionServer
192.168.179.7 node4 HMaster,RegionServer
192.168.179.8 node5 RegionServer

具体搭建步骤如下:

1、将下载好的安装包发送到node4节点上,并解压,配置环境变量

#将下载好的HBase安装包上传至node4节点/software下,并解压
[root@node4 software]# tar -zxvf ./hbase-2.2.6-bin.tar.gz

当前节点配置HBase环境变量

#配置HBase环境变量
[root@node4 software]# vim /etc/profile
export HBASE_HOME=/software/hbase-2.2.6/
export PATH=$PATH:$HBASE_HOME/bin

#使环境变量生效
[root@node4 software]# source /etc/profile

2、配置$HBASE_HOME/conf/hbase-env.sh

#配置HBase JDK export JAVA_HOME=/usr/java/jdk1.8.0_181-amd64/

#配置 HBase不使用自带的zookeeper export HBASE_MANAGES_ZK=false

3、配置$HBASE_HOME/conf/hbase-site.xml

<configuration>
  <property>
        <name>hbase.rootdir</name>
        <value>hdfs://mycluster/hbase</value>
  </property>

  <property>
        <name>hbase.cluster.distributed</name>
        <value>true</value>
  </property>

  <property>
        <name>hbase.zookeeper.quorum</name>
        <value>node3,node4,node5</value>
  </property>

  <property>
        <name>hbase.unsafe.stream.capability.enforce</name>
        <value>false</value>
  </property>

</configuration>

4、配置$HBASE_HOME/conf/regionservers,配置RegionServer节点

node3 node4 node5

5、配置backup-masters文件

手动创建$HBASE_HOME/conf/backup-masters文件,指定备用的HMaster,需要手动创建文件,这里写入node5,在HBase任意节点都可以启动HMaster,都可以成为备用Master ,可以使用命令:hbase-daemon.sh start master启动。

#创建 $HBASE_HOME/conf/backup-masters 文件,写入node5
[root@node4 conf]# vim backup-masters
node5

6、复制hdfs-site.xml到$HBASE_HOME/conf/下

[root@node4 conf]# scp /software/hadoop-3.1.4/etc/hadoop/hdfs-site.xml /software/hbase-2.2.6/conf/

7、将HBase安装包发送到node3,node5节点上,并在node3,node5节点上配置HBase环境变量

[root@node4 software]# cd /software
[root@node4 software]# scp -r ./hbase-2.2.6 node3:/software/
[root@node4 software]# scp -r ./hbase-2.2.6 node5:/software/

# 注意:在node3、node5上配置HBase环境变量。
vim /etc/profile
export HBASE_HOME=/software/hbase-2.2.6/
export PATH=$PATH:$HBASE_HOME/bin

#使环境变量生效
source /etc/profile

8、重启Zookeeper、重启HDFS及启动HBase集群

#注意:一定要重启Zookeeper,重启HDFS,在node4节点上启动HBase集群
[root@node4 software]# start-hbase.sh 

访问WebUI,http://node4:16010。 停止集群:在任意一台节点上stop-hbase.sh

9、测试HBase集群

在Hbase中创建表test,指定'cf1','cf2'两个列族,并向表test中插入几条数据:

#进入hbase
[root@node4 ~]# hbase shell

#创建表test
create 'test','cf1','cf2'

#查看创建的表
list

#向表test中插入数据
put 'test','row1','cf1:id','1'
put 'test','row1','cf1:name','zhangsan'
put 'test','row1','cf1:age',18

#查询表test中rowkey为row1的数据
get 'test','row1'

六、搭建Phoenix

这里搭建Phoenix版本为5.0.0,Phoenix采用单机安装方式即可,这里将Phoenix安装到node4节点上。

节点IP 节点名称 Phoenix服务
192.168.179.7 node4 Phoenix Client

Phoenix下载及安装步骤如下:

1、下载Phoenix

Phoenix对应的HBase有版本之分,可以从官网:http://phoenix.apache.org/download.html来下载,要对应自己安装的HBase版本下载。我们这里安装的HBase版本为2.2.6,这里下载Phoenix5.0.0版本。下载地址如下:

http://archive.apache.org/dist/phoenix/apache-phoenix-5.0.0-HBase-2.0/bin/

注意:不要下载phoenix5.1.2版本,与Hbase2.2.6不兼容

2、上传解压

[root@node4 ~]# cd /software/
[root@node4 software]# tar -zxvf ./apache-phoenix-5.0.0-HBase-2.0-bin.tar.gz

3、拷贝Phoenix整合HBase需要的jar包

将前面解压好安装包下的phoenix开头的包发送到每个HBase节点下的lib目录下。

[root@node4 ~]# cd /software/apache-phoenix-5.0.0-HBase-2.0-bin

#直接复制到node4节点对应的HBase目录下
[root@node4 apache-phoenix-5.0.0-HBase-2.0-bin]# cp ./phoenix-*.jar /software/hbase-2.2.6/lib/

#发送到node3,node5两台HBase节点
[root@node4 apache-phoenix-5.0.0-HBase-2.0-bin]# scp ./phoenix-*.jar node3:/software/hbase-2.2.6/lib/

[root@node4 apache-phoenix-5.0.0-HBase-2.0-bin]# scp ./phoenix-*.jar node5:/software/hbase-2.2.6/lib/

4、复制core-site.xml、hdfs-site.xml、hbase-site.xml到Phoenix

将HDFS中的core-site.xml、hdfs-site.xml、hbase-site.xml复制到Phoenix bin目录下。

[root@node4 ~]# cp /software/hadoop-3.1.4/etc/hadoop/core-site.xml /software/apache-phoenix-5.0.0-HBase-2.0-bin/bin

[root@node4 ~]# cp /software/hadoop-3.1.4/etc/hadoop/hdfs-site.xml /software/apache-phoenix-5.0.0-HBase-2.0-bin/bin

#输入yes,覆盖Phoenix目录下的hbase-site.xml
[root@node4 ~]# cp /software/hbase-2.2.6/conf/hbase-site.xml /software/apache-phoenix-5.0.0-HBase-2.0-bin/bin/

5、启动HDFS,Hbase集群,启动Phoenix

[root@node1 ~]# start-all.sh

[root@node4 ~]# start-hbase.sh (如果已经启动Hbase,一定要重启HBase)

#启动Phoenix
[root@node4 ~]# cd /software/apache-phoenix-5.0.0-HBase-2.0-bin/bin/

#启动时可以不指定后面的zookeeper,默认连接当前节点的zookeeper,多个zookeeper节点逗号隔开,最后一个写端口2181

[root@node4 bin]# ./sqlline.py node3,node4,node5:2181

#退出Phoenix,使用!quit或者!exit
0: jdbc:phoenix:node3,node4,node5:2181> !quit
Closing: org.apache.phoenix.jdbc.PhoenixConnection

6、测试Phoenix

#查看Phoenix表
0: jdbc:phoenix:node3,node4,node5:2181> !tables

#Phoenix中创建表 test,指定映射到HBase的列族为f1
0: jdbc:phoenix:node3,node4,node5:2181> create table test(id varchar primary key ,f1.name varchar,f1.age integer);

#向表 test中插入数据
upsert into test values ('1','zs',18);

#查询插入的数据
0: jdbc:phoenix:node3,node4,node5:2181> select * from test;
+-----+-------+------+
| ID  | NAME  | AGE  |
+-----+-------+------+
1   | zs    | 18   |
+-----+-------+------+

#在HBase中查看对应的数据,hbase中将非String类型的value数据全部转为了16进制
hbase(main):013:0> scan 'TEST'

注意:在Phoenix中创建的表,插入数据时,在HBase中查看发现对应的数据都进行了16进制编码,这里默认Phoenix中对数据进行的编码,我们在Phoenix中建表时可以指定“column_encoded_bytes=0”参数,不让 Phoenix对column family进行编码。例如以下建表语句,在Phoenix中插入数据后,在HBase中可以查看到正常格式数据:

create table mytable ("id" varchar primary key ,"cf1"."name" varchar,"cf1"."age" varchar) column_encoded_bytes=0;

upsert into mytable values ('1','zs','18');

以上再次在HBase中查看,显示数据正常

七、搭建Kafka

这里选择Kafka版本为0.11.0.3,对应的搭建节点如下:

节点IP 节点名称 Kafka服务
192.168.179.4 node1 kafka broker
192.168.179.5 node2 kafka broker
192.168.179.6 node3 kafka broker

搭建详细步骤如下:

1、上传解压

[root@node1 software]# tar -zxvf ./kafka_2.11-0.11.0.3.tgz

2、配置Kafka

在node3节点上配置Kafka,进入/software/kafka_2.11-0.11.0.3/config/中修改server.properties,修改内容如下:

broker.id=0     #注意:这里要唯一的Integer类型
port=9092      #kafka写入数据的端口
log.dirs=/kafka-logs    #真实数据存储的位置
zookeeper.connect=node3:2181,node4:2181,node5:2181  #zookeeper集群

3、将以上配置发送到node2,node3节点上

[root@node1 software]# scp -r /software/kafka_2.11-0.11.0.3 node2:/software/

[root@node1 software]# scp -r /software/kafka_2.11-0.11.0.3 node3:/software/

4、修改node2,node3节点上的server.properties文件

node2、node3节点修改$KAFKA_HOME/config/server.properties文件中的broker.id,node2中修改为1,node3节点修改为2。

5、创建Kafka启动脚本

在node1,node2,node3节点/software/kafka_2.11-0.11.0.3路径中编写Kafka启动脚本“startKafka.sh”,内容如下:

nohup bin/kafka-server-start.sh config/server.properties > kafkalog.txt 2>&1 &

node1,node2,node3节点配置完成后修改“startKafka.sh”脚本执行权限:

chmod +x ./startKafka.sh

6、启动Kafka集群

在node1,node2,node3三台节点上分别执行/software/kafka/startKafka.sh脚本,启动Kafka:

[root@node1 kafka_2.11-0.11.0.3]# ./startKafka.sh 
[root@node2 kafka_2.11-0.11.0.3]# ./startKafka.sh 
[root@node3 kafka_2.11-0.11.0.3]# ./startKafka.sh

7、Kafka 命令测试

#创建topic 
./kafka-topics.sh --zookeeper node3:2181,node4:2181,node5:2181 --create --topic testtopic  --partitions 3 --replication-factor 3

#console控制台向topic 中生产数据
./kafka-console-producer.sh --broker-list node1:9092,node2:9092,node3:9092 --topic testtopic

#console控制台消费topic中的数据
./kafka-console-consumer.sh --bootstrap-server node1:9092,node2:9092,node3:9092  --topic testtopic

八、搭建Redis

这里选择Redis版本为2.8.18版本,Redis安装在node4节点上,节点分布如下:

节点IP 节点名称 Redis服务
192.168.179.7 node4 client

具体搭建步骤如下:

1、将redis安装包上传到node4节点,并解压

[root@node4 ~]# cd /software/
[root@node4 software]# tar -zxvf ./redis-2.8.18.tar.gz

2、node4安装需要的C插件

[root@node4 ~]# yum -y install gcc tcl

3、编译Redis

进入/software/redis-2.8.18目录中,编译redis。

4、创建安装目录安装Redis

#创建安装目录
[root@node4 ~]# mkdir -p /software/redis

#进入redis编译目录,安装redis
[root@node4 ~]# cd /software/redis-2.8.18
[root@node4 redis-2.8.18]# make PREFIX=/software/redis install

注意:现在就可以使用redis了,进入/software/redis/bin下,就可以执行redis命令。

5、将Redis加入环境变量,加入系统服务,设置开机启动

#将redis-server链接到/usr/local/bin/目录下,后期加入系统服务时避免报错
[root@node4 ~]# ln -sf /software/redis-2.8.18/src/redis-server /usr/local/bin/

#执行如下命令,配置redis Server,一直回车即可
[root@node4 ~]# cd /software/redis-2.8.18/utils/
[root@node4 utils]# ./install_server.sh

#执行完以上安装,在/etc/init.d下会修改redis_6379名称并加入系统服务
[root@node4 utils]# cd /etc/init.d/
[root@node4 init.d]# mv redis_6379 redisd
[root@node4 init.d]# chkconfig --add redisd

#检查加入系统状态,3,4,5为开,就是开机自动启动
[root@node4 init.d]# chkconfig --list

6、配置Redis环境变量

# 在node4节点上编辑profile文件,vim /etc/profile
export REDIS_HOME=/software/redis
export PATH=$PATH:$REDIS_HOME/bin

#使环境变量生效
source /etc/profile

7、启动|停止 Redis服务

后期每次开机启动都会自动启动Redis,也可以使用以下命令手动启动|停止redis

#启动redis
[root@node4 init.d]# service redisd start

#停止redis
[root@node4 init.d]# redis-cli shutdown

8、测试redis

#进入redis客户端
[root@node4 ~]# redis-cli

#切换1号库,并插入key
127.0.0.1:6379> select 1
127.0.0.1:6379[1]> hset rediskey zhagnsan 100

#查看所有key并获取key值
127.0.0.1:6379[1]> keys *
127.0.0.1:6379[1]> hgetall rediskey

#删除指定key
127.0.0.1:6379[1]> del 'rediskey'

九、​​​​​​​​​​​​​​搭建Flink

这里选择Flink的版本为1.11.6,原因是1.11.6与Iceberg的整合比较稳定。

Flink搭建节点分布如下:

节点IP 节点名称 Flink服务
192.168.179.4 node1 JobManager,TaskManager
192.168.179.5 node2 TaskManager
192.168.179.6 node3 TaskManager
192.168.179.7 node4 client

具体搭建步骤如下:

1、上传压缩包解压

将Flink的安装包上传到node1节点/software下并解压:

[root@node1 software]# tar -zxvf ./flink-1.11.6-bin-scala_2.11.tgz

2、修改配置文件

在node1节点上进入到Flink conf 目录下,配置flink-conf.yaml文件,内容如下:

#进入flink-conf.yaml目录
[root@node1 conf]# cd /software/flink-1.11.6/conf/

#vim编辑flink-conf.yaml文件,配置修改内容如下
jobmanager.rpc.address: node1
taskmanager.numberOfTaskSlots: 3

其中:taskmanager.numberOfTaskSlot参数默认值为1,修改成3。表示数每一个TaskManager上有3个Slot。

3、配置TaskManager节点

在node1节点上配置$FLINK_HOME/conf/workers文件,内容如下:

node1 node2 node3

4、分发安装包到node2,node3,node4节点

[root@node1 software]# scp -r ./flink-1.11.6 node2:/software/
[root@node1 software]# scp -r ./flink-1.11.6 node3:/software/

#注意,这里发送到node4,node4只是客户端
[root@node1 software]# scp -r ./flink-1.11.6 node4:/software/

5、启动Flink集群

#在node1节点中,启动Flink集群
[root@node1 ~]#  cd /software/flink-1.11.6/bin/
[root@node1 bin]# ./start-cluster.sh

6、访问flink Webui

http://node1:8081,进入页面如下:

7、准备“flink-shaded-hadoop-2-uber-2.8.3-10.0.jar”包

在基于Yarn提交Flink任务时需要将Hadoop依赖包“flink-shaded-hadoop-2-uber-2.8.3-10.0.jar”放入flink各个节点的lib目录中(包括客户端)。

十、​​​​​​​​​​​​​​搭建Flume

这里搭建Flume的版本为1.9.0版本,Flume搭建使用单机模式,节点分配如下:

节点IP 节点名称 Flume服务
192.168.179.8 node5 flume

Flume的搭建配置步骤如下:

1、首先将Flume上传到Mynode5节点/software/路径下,并解压,命令如下:

[root@ node5 software]# tar -zxvf ./apache-flume-1.9.0-bin.tar.gz

2、其次配置Flume的环境变量,配置命令如下:

#修改 /etc/profile文件,在最后追加写入如下内容,配置环境变量:
[root@node5 software]# vim /etc/profile
export FLUME_HOME=/software/apache-flume-1.9.0-bin
export PATH=$FLUME_HOME/bin:$PATH

#保存以上配置文件并使用source命令使配置文件生效
[root@node5 software]# source /etc/profile

经过以上两个步骤,Flume的搭建已经完成,至此,Flume的搭建完成,我们可以使用Flume进行数据采集。

十一、​​​​​​​​​​​​​​搭建maxwell

这里搭建Maxwell的版本为1.28.2版本,节点分配如下:

节点IP 节点名称 Maxwell

服务
192.168.179.6 Node3 maxwell

1、​​​​​​​开启MySQL binlog日志

此项目主要使用Maxwell来监控业务库MySQL中的数据到Kafka,Maxwell原理是通过同步MySQL binlog日志数据达到同步MySQL数据的目的。Maxwell不支持高可用搭建,但是支持断点还原,可以在执行失败时重新启动继续上次位置读取数据,此外安装Maxwell前需要开启MySQL binlog日志,步骤如下:

1.1、登录mysql查看MySQL是否开启binlog日志

[root@node2 ~]# mysql -u root -p123456
mysql> show variables like 'log_%';

1.2、 开启MySQL binlog日志

在/etc/my.cnf文件中[mysqld]下写入以下内容:

[mysqld]

随机指定一个不能和其他集群中机器重名的字符串,配置 MySQL replaction 需要定义

server-id=123

#配置binlog日志目录,配置后会自动开启binlog日志,并写入该目录 log-bin=/var/lib/mysql/mysql-bin

选择 ROW 模式

binlog-format=ROW

1.3、重启mysql 服务,重新查看binlog日志情况

[root@node2 ~]# service mysqld restart
[root@node2 ~]# mysql -u root -p123456
mysql> show variables like 'log_%';

2、​​​​​​​​​​​​​​安装Maxwell

这里maxwell安装版本选择1.28.2,选择node3节点安装,安装maxwell步骤如下:

2.1、将下载好的安装包上传到node3并解压

[root@node3 ~]# cd /software/
[root@node3 software]# tar -zxvf ./maxwell-1.28.2.tar.gz 

2.2、在MySQL中创建Maxwell的用户及赋权

Maxwell同步mysql数据到Kafka中需要将读取的binlog位置文件及位置信息等数据存入MySQL,所以这里创建maxwell数据库,及给maxwell用户赋权访问其他所有数据库。

mysql> CREATE database maxwell;
mysql> CREATE USER 'maxwell'@'%' IDENTIFIED BY 'maxwell';
mysql> GRANT ALL ON maxwell.* TO 'maxwell'@'%';
mysql> GRANT SELECT, REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'maxwell'@'%';
mysql> flush privileges;

2.3、修改配置“config.properties”文件

node3节点进入“/software/maxwell-1.28.2”,修改“config.properties.example”为“config.properties”并配置:

producer=kafka
kafka.bootstrap.servers=node1:9092,node2:9092,node3:9092
kafka_topic=test-topic
#设置根据表将binlog写入Kafka不同分区,还可指定:[database, table, primary_key, transaction_id, thread_id, column]
producer_partition_by=table

#mysql 节点
host=node2
#连接mysql用户名和密码
user=maxwell
password=maxwell

#指定maxwell 当前连接mysql的实例id,这里用于全量同步表数据使用
client_id=maxwell_first

注意:以上参数也可以在后期启动maxwell时指定参数方式来设置。

2.4、启动zookeeper及Kafka,创建对应test-topic

[root@node1 bin]# ./kafka-topics.sh --zookeeper node3:2181,node4:2181,node5:2181 --create --topic test-topic --partitions 3 --replication-factor 3

2.5、在Kafka中监控test-topic

[root@node2 bin]# cd /software/kafka_2.11-0.11/
[root@node2 bin]# ./kafka-console-consumer.sh --bootstrap-server node1:9092,node2:9092,node3:9092 --topic test-topic

2.6、启动Maxwell

[root@node3 ~]# cd /software/maxwell-1.28.2/bin
[root@node3 bin]# maxwell --config ../config.properties.

注意以上启动也可以编写脚本:

#startMaxwell.sh 脚本内容:
/software/maxwell-1.28.2/bin/maxwell --config /software/maxwell-1.28.2/config.properties > ./log.txt 2>&1 &

修改执行权限:

chmod +x ./start_maxwell.sh 

注意:这里我们可以通过Maxwell将MySQL业务库中所有binlog变化数据监控到Kafka test-topic中,在此项目中我们将MySQL binlog数据监控到Kafka中然后通过Flink读取对应topic数据进行处理。

2.7、在mysql中创建库testdb,并创建表person插入数据

mysql> create database testdb;
mysql> use testdb;
mysql> create table person(id int,name varchar(255),age int);
mysql> insert into person values (1,'zs',18);
mysql>  insert into person values (2,'ls',19);
mysql>  insert into person values (3,'ww',20);

可以看到在监控的kafka test-topic中有对应的数据被同步到topic中:

2.8、全量同步mysql数据到kafka

这里以MySQL 表testdb.person为例将全量数据导入到Kafka中,可以通过配置Maxwell,使用Maxwell bootstrap功能全量将已经存在MySQL testdb.person表中的数据导入到Kafka,操作步骤如下:

#启动Maxwell
[root@node3 ~]# cd /software/maxwell-1.28.2/bin
[root@node3 bin]# maxwell --config ../config.properties

#启动maxwell-bootstrap全量同步数据
[root@node3 ~]# cd /software/maxwell-1.28.2/bin
[root@node3 bin]# ./maxwell-bootstrap --database testdb --table person --host node2 --user maxwell --password maxwell  --client_id  maxwell_first --where "id>0"

执行之后可以看到对应的Kafka test-topic中将表testdb.person中的数据全部导入一遍

十二、​​​​​​​搭建clickhouse

这里clickhouse的版本选择21.9.4.35,clickhouse选择分布式安装,clickhouse节点分布如下:

节点IP 节点名称 clickhouse服务
192.168.179.4 node1 clickhouse
192.168.179.5 node2 clickhouse
192.168.179.6 node3 clickhouse

clickhouse详细安装步骤如下:

1、选择三台clickhouse节点,在每台节点上安装clickhouse需要的安装包

这里选择node1、node2,node3三台节点,上传安装包,分别在每台节点上执行如下命令安装clickhouse:

rpm -ivh ./clickhosue-common-static-21.9.4.35-2.x86_64.rpm
#注意在安装以下rpm包时,让输入密码,可以直接回车跳过
rpm -ivh ./clickhouse-server-21.9.4.35-2.noarch.rpm
rpm -ivh ./clickhouse-client-21.9.4.35-2.noarch.rpm

2、安装zookeeper集群并启动

搭建clickhouse集群时,需要使用Zookeeper去实现集群副本之间的同步,所以这里需要zookeeper集群,zookeeper集群安装后可忽略此步骤。

3、配置外网可访问

在每台clickhouse节点中配置/etc/clickhouse-server/config.xml文件第164行<listen_host>,把以下对应配置注释去掉,如下:

<listen_host>::1</listen_host>
#注意每台节点监听的host名称配置当前节点host,需要强制保存wq!
<listen_host>node1</
listen_host>

4、在每台节点创建metrika.xml文件,写入以下内容

在node1、node2、node3节点上/etc/clickhouse-server/config.d路径下下配置metrika.xml文件,默认clickhouse会在/etc路径下查找metrika.xml文件,但是必须要求metrika.xml上级目录拥有者权限为clickhouse ,所以这里我们将metrika.xml创建在/etc/clickhouse-server/config.d路径下,config.d目录的拥有者权限为clickhouse。

在metrika.xml中我们配置后期使用的clickhouse集群中创建分布式表时使用3个分片,每个分片有1个副本,配置如下:

vim /etc/clickhouse-server/config.d/metrika.xml

<yandex>
    <remote_servers>
        <clickhouse_cluster_3shards_1replicas>
            <shard>
                <internal_replication>true</internal_replication>
                <replica>
                    <host>node1</host>
                    <port>9000</port>
                </replica>
            </shard>
            <shard>
                <internal_replication>true</internal_replication>
                <replica>
                    <host>node2</host>
                    <port>9000</port>
                </replica>
            </shard>
            <shard>
                <internal_replication>true</internal_replication>
                <replica>
                    <host>node3</host>
                    <port>9000</port>
                </replica>
            </shard>
        </clickhouse_cluster_3shards_1replicas>
    </remote_servers>

     
    <zookeeper>
        <node index="1">
            <host>node3</host>
            <port>2181</port>
        </node>
        <node index="2">
            <host>node4</host>
            <port>2181</port>
        </node>
        <node index="3">
            <host>node5</host>
            <port>2181</port>
        </node>
    </zookeeper>

    <macros>
        <shard>01</shard> 
        <replica>node1</replica>
    </macros>

    <networks>
        <ip>::/0</ip>
    </networks>

    <clickhouse_compression>
        <case>
            <min_part_size>10000000000</min_part_size>
            <min_part_size_ratio>0.01</min_part_size_ratio>
            <method>lz4</method>
        </case>
    </clickhouse_compression>

</yandex>

对以上配置文件中配置项的解释如下:

  • remote_servers:

clickhouse集群配置标签,固定写法。注意:这里与之前版本不同,之前要求必须以clickhouse开头,新版本不再需要。

  • clickhouse_cluster_3shards_1replicas:

配置clickhouse的集群名称,可自由定义名称,注意集群名称中不能包含点号。这里代表集群中有3个分片,每个分片有1个副本。

分片是指包含部分数据的服务器,要读取所有的数据,必须访问所有的分片。

副本是指存储分片备份数据的服务器,要读取所有的数据,访问任意副本上的数据即可。

  • shard:

分片,一个clickhouse集群可以分多个分片,每个分片可以存储数据,这里分片可以理解为clickhouse机器中的每个节点,1个分片只能对应1服务节点。这里可以配置一个或者任意多个分片,在每个分片中可以配置一个或任意多个副本,不同分片可配置不同数量的副本。如果只是配置一个分片,这种情况下查询操作应该称为远程查询,而不是分布式查询。

  • replica:

每个分片的副本,默认每个分片配置了一个副本。也可以配置多个,副本的数量上限是由clickhouse节点的数量决定的。如果配置了副本,读取操作可以从每个分片里选择一个可用的副本。如果副本不可用,会依次选择下个副本进行连接。该机制利于系统的可用性。

  • internal_replication:

默认为false,写数据操作会将数据写入所有的副本,设置为true,写操作只会选择一个正常的副本写入数据,数据的同步在后台自动进行。

  • zookeeper:

配置的zookeeper集群,注意:与之前版本不同,之前版本是“zookeeper-servers”。

  • macros:

区分每台clickhouse节点的宏配置,macros中标签 代表当前节点的分片号,标签 代表当前节点的副本号,这两个名称可以随意取,后期在创建副本表时可以动态读取这两个宏变量。注意:每台clickhouse节点需要配置不同名称。

  • networks:

这里配置ip为“::/0”代表任意IP可以访问,包含IPv4和IPv6。

注意:允许外网访问还需配置/etc/clickhouse-server/config.xml 参照第三步骤。

  • clickhouse_compression:

MergeTree引擎表的数据压缩设置,min_part_size:代表数据部分最小大小。min_part_size_ratio:数据部分大小与表大小的比率。method:数据压缩格式。

注意:需要在每台clickhouse节点上配置metrika.xml文件,并且修改每个节点的 macros配置名称。

#node2节点修改metrika.xml中的宏变量如下:
    <macros>
        <shard>02</replica> 
        <replica>node2</replica>
    </macros>

#node3节点修改metrika.xml中的宏变量如下:
    <macros>
        <shard>03</
replica> 
        <replica>node3</replica>
    </macros>

5、在每台节点上启动/查看/重启/停止clickhouse服务

首先启动zookeeper集群,然后分别在node1、node2、node3节点上启动clickhouse服务,这里每台节点和单节点启动一样。启动之后,clickhouse集群配置完成。

#每台节点启动Clickchouse服务
service clickhouse-server start

#每台节点查看clickhouse服务状态
service clickhouse-server status

#每台节点重启clickhouse服务
service clickhouse-server restart

#每台节点关闭Clikchouse服务
service clickhouse-server stop

6、检查集群配置是否完成

在node1、node2、node3任意一台节点进入clickhouse客户端,查询集群配置:

#选择三台clickhouse任意一台节点,进入客户端
clickhouse-client 
#查询集群信息,看到下图所示即代表集群配置成功。
node1 :) select * from system.clusters;

查询集群信息,也可以使用如下命令

node1 :) select cluster,host_name from system.clusters;

7、测试clickhouse

#在clickhouse node1节点创建mergeTree表 mt
create table mt(id UInt8,name String,age UInt8) engine = MergeTree() order by (id);

#向表 mt 中插入数据
insert into table mt values(1,'zs',18),(2,'ls',19),(3,'ww',20);

#查询表mt中的数据
select * from mt;

分类:

后端

标签:

大数据

作者介绍

Lanson
V1

CSDN大数据领域博客专家