2021-07-25

最新推荐文章于 2023-02-24 11:38:16 发布

你看我在笑呢

最新推荐文章于 2023-02-24 11:38:16 发布

阅读量345

点赞数

本文链接：https://blog.csdn.net/m0_57124899/article/details/119081835

版权

这里只是简单的写了我所学的内容，详细的笔记是在学习的过程中记录在电脑上了。

1 安装jdk
2 日志的输出
3修改集群时间脚本
- 3.1 通过修改系统时间，模拟生成不同日期的数据
- 3.2 脚本内容
- 3.3 在shell中如果传入的参数中有空格如何处理
4同步集群到最新时间
- 4.1脚本内容
5 安装hadoop
- 5.1 编辑core-site.xml文件
- 5.2编辑vim hdfs-site.xml 文件
- 5.3编辑 yarn-site.xml文件
6hadoop集群的启动和停止脚本
- 6.1脚本内容
7为Hadoop集群安装LZO压缩
- 7.1下载LZO的源码，和hadoop平台对应的版本进行编译
8 LZO压缩格式介绍
9 测试HDFS的性能
- 9.1 测试HDFS写性能
- 9.2测试HDFS读性能
- 9.3删除测试生成数据
10 Hadoop的参数调优
11安装Zookeeper和编写启动脚本
- 11.1脚本内容
12安装Flume
13 安装和配置Kafka编写启动脚本
14 KafkaManager的使用
15KafkaMonitor的使用
- 15.1 启动脚本
16KafkaTool的使用
17测试kafka集群
18 kafka集群Broker数量的推算
19 kafkaChannel的讲解
20 拦截器的需求分析
21测试拦截器
22第一层采集通道编写完成
23第一层采集通道启动脚本
- 23.1分发 myagents
- 23.2编写启动脚本
24 KafkaSource的分析和FileChannel的介绍
25FileChannelCheckpoint的解释
26 第二层采集通道的编写
27模拟造数据
28 第二层通道的启动脚本
29 编写一键启动脚本
30数仓的分层
31数据的分层介绍和表命名规范
- 数仓命名规范
32搭建数仓的环境分析
33mysql的安装（密码dska2Ugquh)0）
34另一种适合我自己的安装mysql的方法
35 hive安装
36安装keeplived
37安装Tez

这里只是简单的写了我所学的内容，详细的笔记是在学习的过程中记录在电脑上了。

1 安装jdk

在profile文件中加入

JAVA_HOME=/opt/module/jdk1.8.0_144
PATH= $P A T H :$ JAVA_HOME/bin

export JAVA_HOME PATH

在.bashrc中写入source /etc/profile

2 日志的输出

分发log-collector-0.0.1-SNAPSHOT-jar-with-dependencies.jar
当执行一个命令时，如果此条命令有输出，可以使用 >符号，将输出定向到文件中。此时标准输出就不向屏幕输出了！
Linux中的IO设备

在linux中，有三个常用的IO设备

0：代表标准输入，类似Java代码中的System.in.scan()

接受用户的输入

1:代表标准输出。类似于Java中的System.in.print()

接受程序的标准输出（正常输出）

2:代表错误输出。类似于Java中的System.err.print**()**

接受程序报错时输出的信息

/dev/null:俗称黑洞，如果输出中消息不希望使用，可以定向输出到此设备

命令>文件：执行命令，将命令的标准输出定向到文件中！

命令>文件等价于命令 1> 文件

4.5 让进程在后台执行命令 &

5 编写日志生成脚本

#!/bin/bash
#在hadoop102,hadoop103产生日志
for i in hadoop102 hadoop103
do
ssh $i java -cp /opt/module/log-collector-0.0.1-SNAPSHOT-jar-with-dependencies.jar com.atguigu.appclient.AppMain $1 $2 > /dev/null 2>&1 &
done

3修改集群时间脚本

3.1 通过修改系统时间，模拟生成不同日期的数据

3.2 脚本内容

#/bin/bash
#在hadoop102和hadoop103上同步日期为指定的日期
if(($#==0))
then
	echo 请输入要修改的时间!
	exit;
fi

#修改系统时间
for i in hadoop102 hadoop103
do
	echo ------------同步$i时间--------------
	ssh $i "sudo date -s '$@'"
done

3.3 在shell中如果传入的参数中有空格如何处理

如果参数有空格，需要加上引号，将整个参数连通空格作为整体！

双引号，可以识别$等特殊符号

单引号，无法识别$等特殊符号

单双引号的嵌套：

最外层时单引号，嵌套双引号，无法识别 $等特殊字符，认为最内层的双引号失去了解析$ 的作用！

最外层是双引号， $被嵌套在单引号中，依然是可以解析$

4同步集群到最新时间

4.1脚本内容

#/bin/bash
#在hadoop102和hadoop103上同步日期为指定的日期
if(($#==0))
then
	echo 请输入要修改的时间!
	exit;
fi

#修改系统时间
for i in hadoop102 hadoop103
do
	echo ------------同步$i时间--------------
	ssh $i "sudo date -s '$@'"
done

5 安装hadoop

5.1 编辑core-site.xml文件

<!-- 指定HDFS中NameNode的地址 -->
<property>
<name>fs.defaultFS</name>
     <value>hdfs://hadoop102:9000</value>
</property>

<!-- 指定Hadoop运行时产生文件的存储目录 -->
<property>
          <name>hadoop.tmp.dir</name>
          <value>/opt/module/hadoop-2.7.2/data/tmp</value>
</property>

5.2编辑vim hdfs-site.xml 文件

<!-- 指定Hadoop辅助名称节点主机配置 -->
<property>
         <name>dfs.namenode.secondary.http-address</name>
         <value>hadoop104:50090</vlaue>
</property>

5.3编辑 yarn-site.xml文件

<!-- Site specific YARN configuration properties -->
<!-- reducer获取数据的方式 -->
<property>
           <name>yarn.nodemanager.aux-services</name>
           <value>mapreduce_shuffle</value>
</property>

<!-- 指定YARN的ResourceManager的地址 -->
<property>
<name>yarn.resourcemanager.hostname</name>
<value>hadoop103</value>
</property>

<!-- 日志聚集功能使能 -->
<property>
<name>yarn.log-aggregation-enable</name>
<value>true</value>
</property>
<!-- 日志保留时间设置7天 -->
<property>
<name>yarn.log-aggregation.retain-seconds</name>
<value>604800</value>
</property>

6hadoop集群的启动和停止脚本

6.1脚本内容

#!/bin/bash
#hadoop集群的一键启动脚本
if(($#!=1))
then
	echo '请输入start|stop参数!'
	exit;
fi

#只允许传入start和stop参数
if [ $1 = start ] || [ $1 = stop ]
then
	$1-dfs.sh
	$1-yarn.sh
	ssh hadoop102 mr-jobhistory-daemon.sh $1 historyserver
else
	echo '请输入start|stop参数!'
fi

7为Hadoop集群安装LZO压缩

7.1下载LZO的源码，和hadoop平台对应的版本进行编译

在mapred-site.xml文件中添加

<property>
<name>io.compression.codecs</name>
<value>
org.apache.hadoop.io.compress.GzipCodec,
org.apache.hadoop.io.compress.DefaultCodec,
org.apache.hadoop.io.compress.BZip2Codec,
org.apache.hadoop.io.compress.SnappyCodec,
com.hadoop.compression.lzo.LzoCodec,
com.hadoop.compression.lzo.LzopCodec
</value>
</property>

<property>
    <name>io.compression.codec.lzo.class</name>
    <value>com.hadoop.compression.lzo.LzoCodec</value>
</property>

8 LZO压缩格式介绍

9 测试HDFS的性能

cd /opt/module/hadoop-2.7.2/share/hadoop/common

9.1 测试HDFS写性能

测试内容：向HDFS集群写10个128M的文件

hadoop jar /opt/module/hadoop-2.7.2/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-2.7.2-tests.jar TestDFSIO -write -nrFiles 10 -fileSize 128MB

9.2测试HDFS读性能

测试内容：读取HDFS集群10个128M的文件

hadoop jar /opt/module/hadoop-2.7.2/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-2.7.2-tests.jar TestDFSIO -read -nrFiles 10 -fileSize 128MB

9.3删除测试生成数据

hadoop jar /opt/module/hadoop-2.7.2/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-2.7.2-tests.jar TestDFSIO -clean

10 Hadoop的参数调优

11安装Zookeeper和编写启动脚本

11.1脚本内容

#!/bin/bash
if(($#!=1))
then
	echo 请输入start或stop或status!
	exit;
fi

if [ $1 = start ] || [ $1 = stop ] || [ $1 = status ]
then
	xcall zkServer.sh $1
else
	echo 请输入start或stop或status!
fi

12安装Flume

13 安装和配置Kafka编写启动脚本

#!/bin/bash
java -cp KafkaOffsetMonitor-assembly-0.2.0.jar \
com.quantifind.kafka.offsetapp.OffsetGetterWeb \
--offsetStorage kafka \
--kafkaBrokers hadoop102:9092,hadoop103:9092,hadoop104:9092 \
--kafkaSecurityProtocol PLAINTEXT \
--zk hadoop102:2181,hadoop103:2181,hadoop104:2181 \
--port 8086 \
--refresh 10.seconds \
--retain 2.days \
--dbName offsetapp_kafka &

14 KafkaManager的使用

15KafkaMonitor的使用

15.1 启动脚本

#!/bin/bash
java -cp KafkaOffsetMonitor-assembly-0.2.0.jar \
com.quantifind.kafka.offsetapp.OffsetGetterWeb \
--offsetStorage kafka \
--kafkaBrokers hadoop102:9092,hadoop103:9092,hadoop104:9092 \
--kafkaSecurityProtocol PLAINTEXT \
--zk hadoop102:2181,hadoop103:2181,hadoop104:2181 \
--port 8086 \
--refresh 10.seconds \
--retain 2.days \
--dbName offsetapp_kafka &

16KafkaTool的使用

17测试kafka集群

18 kafka集群Broker数量的推算

Kafka机器数量（经验公式）=2*（峰值生产速度 *副本数/100）+1

先拿到峰值生产速度，再根据设定的副本数，就能预估出需要部署Kafka的数量。

比如我们的峰值生产速度是50M/s。副本数为2。

Kafka机器数量=2* （50* 2/100）+ 1=3台

19 kafkaChannel的讲解

1.第一层采集脚本Source的选择
①Source:
数据源在日志文件中!
读取日志中的数据，可以使用以下Source
ExecSource: 可以执行一个linux命令，例如tail -f 日志文件，
讲读取的到的数据封装为Event！
不用！不安全，可能丢数据！
SpoolingDirSource: 可以读取一个目录中的文本文件！
保证目录中没有重名的文件！
保证目录中的文件都是封闭状态，一旦放入目录中，不能再继续写入！
每个日志封闭后，才能放入到SpoolingDir，不然agent就故障！
TailDirSource: 接近实时第读取指定的文件！断点续传功能！
使用此Source!

	使用TailDirSource

②Channel:
KafkaChannel:
优点：基于kafka的副本功能，提供了高可用性！event被存储在kafka中！
即便agent挂掉或broker挂掉，依然可以让sink从channel中读取数据！

应用场景：
①KafkaChannel和sink和source一起使用，单纯作为channel。
②KafkaChannel+拦截器+Source，只要Source把数据写入到kafka就完成
目前使用的场景！
③KafkaChannel+sink，使用flume将kafka中的数据写入到其他的目的地，例如hdfs!

为例在上述场景工作，KafkaChannel可以配置生产者和消费者的参数！

配置参数：
①在channel层面的参数，例如channel的类型，channel的容量等，需要和之前一样，
在channel层面配置，例如：a1.channel.k1.type
②和kafka集群相关的参数，需要在channel层面配置后，再加上kafka.
例如： a1.channels.k1.kafka.topic ：向哪个主题发送数据
a1.channels.k1.kafka.bootstrap.servers：集群地址
③和Produer和Consumer相关的参数，需要加上produer和consumer的前缀：
例如：a1.channels.k1.kafka.producer.acks=all
a1.channels.k1.kafka.consumer.group.id=atguigu

必须的配置：
type=org.apache.flume.channel.kafka.KafkaChannel
kafka.bootstrap.servers=
可选：
kafka.topic：生成到哪个主题
parseAsFlumeEvent=true(默认)：
如果parseAsFlumeEvent=true，kafkaChannel会把数据以flume中Event的结构作为参考，
把event中的header+body放入ProducerRecord的value中！

	如果parseAsFlumeEvent=false，kafkaChannel会把数据以flume中Event的结构作为参考，
	把event中body放入ProducerRecord的value中！

a1.channels.k1.kafka.producer.acks=0

20 拦截器的需求分析

日志数据有两种类型，一种是事件日志，格式时间戳|{“ap”:xx,“cm”:{},“et”:[{},{}]}
另一种是启动日志，格式：{“en”:“start”}
在1个source对接两个KafkaChannel时，需要使用MulitPlexing Channel Selector，
讲启动日志，分配到启动日志所在的Chanel，讲事件日志分配到事件日志所在的Channel！

MulitPlexing Channel Selector根据event，header中指定key的映射，来分配！

需要自定义拦截器，根据不同的数据类型，在每个Event对象的header中添加key！

功能： ①为每个Event，在header中添加key
	   ②过滤不符合要求的数据(格式有损坏)
			启动日志： {},验证JSON字符串的完整性，是否以{}开头结尾
			事件日志：  时间戳|{}
				时间戳需要合法：
					a)长度合法(13位)
					b)都是数字
				验证JSON字符串的完整性，是否以{}开头结尾
				24 为Event添加Header信息

21测试拦截器

#a1是agent的名称，a1中定义了一个叫r1的source，如果有多个，使用空格间隔
a1.sources = r1
a1.sinks = k1
a1.channels = c1
#组名名.属性名=属性值
a1.sources.r1.type=TAILDIR
a1.sources.r1.filegroups=f1 
#读取/tmp/logs/app-yyyy-mm-dd.log ^代表以xxx开头$代表以什么结尾 .代表匹配任意字符
#+代表匹配任意位置
a1.sources.r1.filegroups.f1=/tmp/logs/^app.+.log$
#JSON文件的保存位置
a1.sources.r1.positionFile=/opt/module/flume/test/log_position.json

#定义拦截器
a1.sources.r1.interceptors = i1
a1.sources.r1.interceptors.i1.type = com.atguigu.dw.flume.MyInterceptor$Builder


#定义sink
a1.sinks.k1.type=logger

#定义chanel
a1.channels.c1.type=memory
a1.channels.c1.capacity=1000

#连接组件 同一个source可以对接多个channel，一个sink只能从一个channel拿数据！
a1.sources.r1.channels=c1
a1.sinks.k1.channel=c1
26 第一层采集通道编写完成
#a1是agent的名称，a1中定义了一个叫r1的source，如果有多个，使用空格间隔
a1.sources = r1
a1.channels = c1 c2

#组名名.属性名=属性值
a1.sources.r1.type=TAILDIR
a1.sources.r1.filegroups=f1
a1.sources.r1.batchSize=1000
#读取/tmp/logs/app-yyyy-mm-dd.log ^代表以xxx开头$代表以什么结尾 .代表匹配任意字符
#+代表匹配任意位置
a1.sources.r1.filegroups.f1=/tmp/logs/^app.+.log$
#JSON文件的保存位置
a1.sources.r1.positionFile=/opt/module/flume/test/log_position.json

#定义拦截器
a1.sources.r1.interceptors = i1
a1.sources.r1.interceptors.i1.type = com.atguigu.dw.flume.MyInterceptor$Builder

#定义ChannelSelector
a1.sources.r1.selector.type = multiplexing
a1.sources.r1.selector.header = topic
a1.sources.r1.selector.mapping.topic_start = c1
a1.sources.r1.selector.mapping.topic_event = c2


#定义chanel
a1.channels.c1.type=org.apache.flume.channel.kafka.KafkaChannel
a1.channels.c1.kafka.bootstrap.servers=hadoop102:9092,hadoop103:9092,hadoop104:9092
a1.channels.c1.kafka.topic=topic_start
a1.channels.c1.parseAsFlumeEvent=false

a1.channels.c2.type=org.apache.flume.channel.kafka.KafkaChannel
a1.channels.c2.kafka.bootstrap.servers=hadoop102:9092,hadoop103:9092,hadoop104:9092
a1.channels.c2.kafka.topic=topic_event
a1.channels.c2.parseAsFlumeEvent=false

#连接组件 同一个source可以对接多个channel，一个sink只能从一个channel拿数据！
a1.sources.r1.channels=c1 c2

22第一层采集通道编写完成

#a1是agent的名称，a1中定义了一个叫r1的source，如果有多个，使用空格间隔
a1.sources = r1
a1.channels = c1 c2

#组名名.属性名=属性值
a1.sources.r1.type=TAILDIR
a1.sources.r1.filegroups=f1
a1.sources.r1.batchSize=1000
#读取/tmp/logs/app-yyyy-mm-dd.log ^代表以xxx开头$代表以什么结尾 .代表匹配任意字符
#+代表匹配任意位置
a1.sources.r1.filegroups.f1=/tmp/logs/^app.+.log$
#JSON文件的保存位置
a1.sources.r1.positionFile=/opt/module/flume/test/log_position.json

#定义拦截器
a1.sources.r1.interceptors = i1
a1.sources.r1.interceptors.i1.type = com.atguigu.dw.flume.MyInterceptor$Builder

#定义ChannelSelector
a1.sources.r1.selector.type = multiplexing
a1.sources.r1.selector.header = topic
a1.sources.r1.selector.mapping.topic_start = c1
a1.sources.r1.selector.mapping.topic_event = c2


#定义chanel
a1.channels.c1.type=org.apache.flume.channel.kafka.KafkaChannel
a1.channels.c1.kafka.bootstrap.servers=hadoop102:9092,hadoop103:9092,hadoop104:9092
a1.channels.c1.kafka.topic=topic_start
a1.channels.c1.parseAsFlumeEvent=false

a1.channels.c2.type=org.apache.flume.channel.kafka.KafkaChannel
a1.channels.c2.kafka.bootstrap.servers=hadoop102:9092,hadoop103:9092,hadoop104:9092
a1.channels.c2.kafka.topic=topic_event
a1.channels.c2.parseAsFlumeEvent=false

#连接组件 同一个source可以对接多个channel，一个sink只能从一个channel拿数据！
a1.sources.r1.channels=c1 c2

23第一层采集通道启动脚本

23.1分发 myagents

/opt/module/flume/

23.2编写启动脚本

#!/bin/bash
#使用start启动脚本，使用stop停止脚本
if(($#!=1))
then
	echo 请输入start或stop!
	exit;
fi
#定义cmd用来保存要执行的命令
cmd=cmd
if [ $1 = start ]
then
	cmd="nohup flume-ng agent -c $FLUME_HOME/conf/ -n a1 -f $FLUME_HOME/myagents/f1.conf -Dflume.root.logger=DEBUG,console > /home/atguigu/f1.log 2>&1 &"

	elif [ $1 = stop ]
		then 
			cmd="ps -ef  | grep f1.conf | grep -v grep | awk  '{print \$2}' | xargs kill -9"
	else
		echo 请输入start或stop!
fi

#在hadoop102和hadoop103开启采集
for i in hadoop102 hadoop103
do
	ssh $i $cmd
done

24 KafkaSource的分析和FileChannel的介绍

一、第二层采集通道的设计分析

1.目的
讲已经存储在kafka集群中的数据，使用flume上传到HDFS!

架构设计
课件上推荐的：
数据源在kafka，因此需要使用一个可以对接kafka的source，即kafkaSource
为了安全起见，选择filechannel
目的地在hdfs，使用hdfssink

自己尝试：
kafkaChannel+hdfssink

组件分析
①kafkaSource：kafkaSource就是kafka的一个消费者线程，可以从指定的主题中读取数据！
如果希望提供消费的速率，可以配置多个kafkaSource，这些source组成同一个组！

kafkaSource在工作时，会检查event的header中有没有timestamp属性，如果没有，
kafkaSource会自动为event添加timestamp=当前kafkaSource所在机器的时间！

kafkaSource启动一个消费者，消费者在消费时，默认从分区的最后一个位置消费！

必须的配置：
type=org.apache.flume.source.kafka.KafkaSource
kafka.bootstrap.servers=hadoop102:9092,hadoop103:9092,hadoop104:9092
kafka.topics=消费的主题
kafka.topics.regex=使用正则表达式匹配主题

可选的配置：
kafka.consumer.group.id=消费者所在的组id
batchSize=一次put多少数据，小于10000
batchDurationMillis=一次put可以最多使用多少时间

和kafkaConsumer相关的属性：kafka.consumer=consumer的属性名
例如：kafka.consumer.auto.offset.reset

②fileChannel: channel中的event是存储在文件中！比memorychannel可靠，但是效率略低！
必须的配置：
type=file
checkpointDir=checkpoint线程(负责检查文件中哪些event已经被sink消费了，将这些event的文件删除)保存数据的目录！
useDualCheckpoints=false 是否启动双检查点，如果启动后，会再启动一个备用的checkpoint线程！
如果改为true，还需要设置backupCheckpointDir(备用的checkpoint线程的工作目录)
dataDirs=在哪些目录下保存event，默认为~/.flume/file-channel/data，可以是逗号分割的多个目录！

③hdfssink: hdfssink将event写入到HDFS！目前只支持生成两种类型的文件： text | sequenceFile,这两种文件都可以使用压缩！
写入到HDFS的文件可以自动滚动（关闭当前正在写的文件，创建一个新文件）。基于时间、events的数量、数据大小进行周期性的滚动！
支持基于时间和采集数据的机器进行分桶和分区操作！
HDFS数据所上传的目录或文件名可以包含一个格式化的转义序列，这个路径或文件名会在上传event时，被自动替换，替换为完整的路径名！
使用此Sink要求本机已经安装了hadoop，或持有hadoop的jar包！
配置：
必须配置：
type – The component type name, needs to be hdfs
hdfs.path – HDFS directory path (eg hdfs://namenode/flume/webdata/)

参考：
a1.sinks.k1.type = hdfs
#一旦路径中含有基于时间的转义序列，要求event的header中必须有timestamp=时间戳，如果没有需要将useLocalTimeStamp = true
a1.sinks.k1.hdfs.path = hdfs://hadoop101:9000/flume/%Y%m%d/%H/%M
#上传文件的前缀
a1.sinks.k1.hdfs.filePrefix = logs-

#以下三个和目录的滚动相关，目录一旦设置了时间转义序列，基于时间戳滚动
#是否将时间戳向下舍
a1.sinks.k1.hdfs.round = true
#多少时间单位创建一个新的文件夹
a1.sinks.k1.hdfs.roundValue = 1
#重新定义时间单位
a1.sinks.k1.hdfs.roundUnit = minute

#是否使用本地时间戳
a1.sinks.k1.hdfs.useLocalTimeStamp = true
#积攒多少个Event才flush到HDFS一次
a1.sinks.k1.hdfs.batchSize = 100

#以下三个和文件的滚动相关，以下三个参数是或的关系！以下三个参数如果值为0都代表禁用！
#60秒滚动生成一个新的文件
a1.sinks.k1.hdfs.rollInterval = 10
#设置每个文件到128M时滚动
a1.sinks.k1.hdfs.rollSize = 134217700
#每写多少个event滚动一次
a1.sinks.k1.hdfs.rollCount = 0
#以不压缩的文本形式保存数据
a1.sinks.k1.hdfs.fileType=DataStream

25FileChannelCheckpoint的解释

26 第二层采集通道的编写

在 opt/module/flume/myagents/f2.conf中写入

#配置文件编写
a1.sources = r1 r2
a1.sinks = k1 k2
a1.channels = c1 c2

#配置source
a1.sources.r1.type=org.apache.flume.source.kafka.KafkaSource
a1.sources.r1.kafka.bootstrap.servers=hadoop102:9092,hadoop103:9092,hadoop104:9092
a1.sources.r1.kafka.topics=topic_start
a1.sources.r1.kafka.consumer.auto.offset.reset=earliest
a1.sources.r1.kafka.consumer.group.id=CG_Start

a1.sources.r2.type=org.apache.flume.source.kafka.KafkaSource
a1.sources.r2.kafka.bootstrap.servers=hadoop102:9092,hadoop103:9092,hadoop104:9092
a1.sources.r2.kafka.topics=topic_event
a1.sources.r2.kafka.consumer.auto.offset.reset=earliest
a1.sources.r2.kafka.consumer.group.id=CG_Event
#配置channel
a1.channels.c1.type=file
a1.channels.c1.checkpointDir=/opt/module/flume/c1/checkpoint
#启动备用checkpoint
a1.channels.c1.useDualCheckpoints=true
a1.channels.c1.backupCheckpointDir=/opt/module/flume/c1/backupcheckpoint
#event存储的目录
a1.channels.c1.dataDirs=/opt/module/flume/c1/datas


a1.channels.c2.type=file
a1.channels.c2.checkpointDir=/opt/module/flume/c2/checkpoint
a1.channels.c2.useDualCheckpoints=true
a1.channels.c2.backupCheckpointDir=/opt/module/flume/c2/backupcheckpoint
a1.channels.c2.dataDirs=/opt/module/flume/c2/datas


#sink
a1.sinks.k1.type = hdfs
#一旦路径中含有基于时间的转义序列，要求event的header中必须有timestamp=时间戳，如果没有需要将useLocalTimeStamp = true
a1.sinks.k1.hdfs.path = hdfs://hadoop102:9000/origin_data/gmall/log/topic_start/%Y-%m-%d
a1.sinks.k1.hdfs.filePrefix = logstart-

a1.sinks.k1.hdfs.batchSize = 1000

#文件的滚动
#60秒滚动生成一个新的文件
a1.sinks.k1.hdfs.rollInterval = 30
#设置每个文件到128M时滚动
a1.sinks.k1.hdfs.rollSize = 134217700
#禁用基于event数量的文件滚动策略
a1.sinks.k1.hdfs.rollCount = 0
#指定文件使用LZO压缩格式
a1.sinks.k1.hdfs.fileType = CompressedStream 
a1.sinks.k1.hdfs.codeC = lzop
#a1.sinks.k1.hdfs.round = true
#a1.sinks.k1.hdfs.roundValue = 10
#a1.sinks.k1.hdfs.roundUnit = second



a1.sinks.k2.type = hdfs
a1.sinks.k2.hdfs.path = hdfs://hadoop102:9000/origin_data/gmall/log/topic_event/%Y-%m-%d
a1.sinks.k2.hdfs.filePrefix = logevent-
a1.sinks.k2.hdfs.batchSize = 1000
a1.sinks.k2.hdfs.rollInterval = 30
a1.sinks.k2.hdfs.rollSize = 134217700
a1.sinks.k2.hdfs.rollCount = 0
a1.sinks.k2.hdfs.fileType = CompressedStream 
a1.sinks.k2.hdfs.codeC = lzop
#a1.sinks.k2.hdfs.round = true
#a1.sinks.k2.hdfs.roundValue = 10
#a1.sinks.k2.hdfs.roundUnit = second

#连接组件
a1.sources.r1.channels=c1
a1.sources.r2.channels=c2
a1.sinks.k1.channel=c1
a1.sinks.k2.channel=c2

zai opt/module/flume/myagents/test2.conf中写入

#配置文件编写
a1.sources = r1 r2
a1.sinks = k1 k2
a1.channels = c1 c2

#配置source
a1.sources.r1.type=org.apache.flume.source.kafka.KafkaSource
a1.sources.r1.kafka.bootstrap.servers=hadoop102:9092,hadoop103:9092,hadoop104:9092
a1.sources.r1.kafka.topics=topic_start
a1.sources.r1.kafka.consumer.auto.offset.reset=earliest
a1.sources.r1.kafka.consumer.group.id=CG_Start

a1.sources.r2.type=org.apache.flume.source.kafka.KafkaSource
a1.sources.r2.kafka.bootstrap.servers=hadoop102:9092,hadoop103:9092,hadoop104:9092
a1.sources.r2.kafka.topics=topic_event
a1.sources.r2.kafka.consumer.auto.offset.reset=earliest
a1.sources.r2.kafka.consumer.group.id=CG_Event
#配置channel
a1.channels.c1.type=file
a1.channels.c1.checkpointDir=/opt/module/flume/c1/checkpoint
#启动备用checkpoint
a1.channels.c1.useDualCheckpoints=true
a1.channels.c1.backupCheckpointDir=/opt/module/flume/c1/backupcheckpoint
#event存储的目录
a1.channels.c1.dataDirs=/opt/module/flume/c1/datas


a1.channels.c2.type=file
a1.channels.c2.checkpointDir=/opt/module/flume/c2/checkpoint
a1.channels.c2.useDualCheckpoints=true
a1.channels.c2.backupCheckpointDir=/opt/module/flume/c2/backupcheckpoint
a1.channels.c2.dataDirs=/opt/module/flume/c2/datas


#定义sink
a1.sinks.k1.type=logger
a1.sinks.k2.type=logger

#连接组件
a1.sources.r1.channels=c1
a1.sources.r2.channels=c2
a1.sinks.k1.channel=c1
a1.sinks.k2.channel=c2

27模拟造数据

数据的日期取决于kafkaSource所运行机器的时间！

	①先修改dt,让dt脚本也可以同步104的时间
	如果要造 2019-1-1，2019-1-20,2019-2-11,2019-2-22的数据
	此时
	②从以上时间中选取最小的时间2019-1-1，执行dt 2019-1-1，讲所有的集群时间同步为
			2019-1-1，启动集群(hdfs,kafka)
	③造日志
				lg ------>/tmp/logs/app-2019-1-1.log
	④启动f1,f2

2019-2-22 启动了kafka集群，此时集群会有一个时间戳2019-2-22
此时修改时间为2019-1-22，如果没有重启kafka集群，此时，生产者在f1运行，
f1的时间为2019-1-22，而kafka集群的时间依然是2019-2-22,此时生成数据，就会生成超时！

1 dt 2020-02-15 同步时间

2 lg 20 1000 生产数据

28 第二层通道的启动脚本

在 cd bin/f2中写入

#!/bin/bash
#使用start启动脚本，使用stop停止脚本
if(($#!=1))
then
        echo 请输入start或stop!
        exit;
fi
if [ $1 = start ]
then
        ssh hadoop104 "nohup flume-ng agent -c $FLUME_HOME/conf/ -n a1 -f $FLUME_HOME/myagents/f2.conf -Dflume.root.logger=INFO,console > /root/bin/f2.log 2>&1 &"

        elif [ $1 = stop ]
                then
                        ssh hadoopp104 "ps -ef  | grep f2.conf | grep -v grep | awk  '{print \$2}' | xargs kill -9"
        else
                echo 请输入start或stop!
fi

29 编写一键启动脚本

在 cd bin/onekeyboot中写入

#!/bin/bash
#输入start和stop参数，一键启动或关闭hadoop,zk,kafka集群，启动f1,f2采集通道
if(($#!=1))
then 
	echo 请输入start或stop!
	exit;
fi

#编写函数，这个函数的功能为返回集群中启动成功的broker的数量
function countKafkaBrokders()
{
	count=0
	for((i=102;i<=104;i++))
	do
		result=$(ssh hadoop$i "jps | grep Kafka | wc -l")
		count=$[$result+$count]
	done

	#函数可以定义返回值，如果不定义，返回函数最后一条命令的执行状态(返回0，代表成功，非0，即为异常)
	return $count
	

}

#启动,注意启动时，各个组件的依赖关系，例如zk必须先于kafka启动，后于kafka关闭
if [ $1 = start ]
then
	zk start
	hd start
	kf start
	#保证kafka集群已经启动时，才能启动f1,f2,判断当前kafka集群启动了多少 broker实例
	while [ 1 ]
	do
		countKafkaBrokders
		#如果返回值不为3，有可能是机器还尚未执行broker的启动命令，因此继续判断
        	if(($?==3))
		  then
			break
		fi
		sleep 2s
	done

 
	f1 start
	f2 start
	#查看启动了哪些进程
	xcall jps

	elif [ $1 = stop ]
	then
		f1 stop
		f2 stop
		kf stop
		#在kafka没有停止完成之前，不能停止zk集群
		while [ 1 ]
	        do
                	countKafkaBrokders
               		 #如果返回值不为0,kafka集群没有停止完成
              		  if(($?==0))
                  	then
                       		 break
               		 fi
               		 sleep 2s
        	done

		zk stop
		hd stop
		#查看还剩了哪些进程
        	xcall jps
	else
		echo 请输入start或stop!
fi

30数仓的分层

31数据的分层介绍和表命名规范

数仓命名规范

ODS层命名为 ods

DWD层命名为 dwd

DWS层命名为 dws

ADS层命名为ads

临时表数据库命名为 xxx_tmp

备份数据数据库命名为 xxx_bak

32搭建数仓的环境分析

①安装hive
②安装HA（高可用的）的mysql
③配置hive的元数据存储在mysql中
④配置hive的执行引擎为tez

33mysql的安装（密码dska2Ugquh)0）

解压（在opt/soft中）unzip
1.检查本机是否已经安装了mysql的一些软件包，防止冲突
rpm -qa | grep mysql
rpm -qa | grep MySQL

卸载残留的软件包：
sudo rpm -e --nodeps mysql-libs-5.1.73-7.el6.x86_64

2.安装5.6
sudo rpm -ivh MySQL-client-5.6.24-1.el6.x86_64.rpm
sudo rpm -ivh MySQL-server-5.6.24-1.el6.x86_64.rpm

3.配置root用户的密码
查看生成的随机密码： sudo cat /root/.mysql_secret
使用随机密码登录修改新的密码：
启动服务： sudo service mysql start
使用随机密码登录，后修改密码： set password=password(‘123456’);

4.配置root用户可以再任意机器登录的帐号
①查看本机的所有帐号
select host,user,password from mysql.user;

②删除不是locahost的root用户
delete from mysql.user where host <> ‘localhost’;

③将host=localhost修改为%

update mysql.user set host=’%’ where user=‘root’;
④刷新用户
flush privileges;

⑤测试root是否可以从localhost主机名登录
mysql -uroot -p123456

⑥测试root是否可以从hadoop103(从外部地址)主机名登录
mysql -h hadoop103 -uroot -p123456

⑦查看当前mysql服务器收到了哪些客户端连接请求
sudo mysqladmin processlist -uroot -p123456

5.mysql自定义配置文件的存放位置
/etc/my.cnf /etc/mysql/my.cnf /usr/etc/my.cnf ~/.my.cnf

四、配置互为主从的MySQL
1.到/usr/share/mysql下找mysql服务端配置的模版
sudo cp my-default.cnf /etc/my.cnf

2.编辑my.cnf
在[mysqld]下配置：

server_id = 103
log-bin=mysql-bin
binlog_format=mixed
relay_log=mysql-relay

另外一台，配置也一样，只需要修改servei_id

3.重启mysql服务
sudo service mysql restart

4.在主机上使用root@localhost登录,授权从机可以使用哪个用户登录

GRANT replication slave ON . TO ‘slave’@’%’ IDENTIFIED BY ‘123456’;

5.查看主机binlog文件的最新位置
show master status;

6.在从机上执行以下语句
change master to master_user=‘slave’, master_password=‘123456’,master_host=‘192.168.6.103’,master_log_file=‘mysql-bin.000001’,master_log_pos=311;

7.在从机上开启同步线程
start slave

8.查看同步线程的状态
show slave status \G

change master to master_user=‘slave’, master_password=‘123456’,master_host=‘192.168.6.102’,master_log_file=‘mysql-bin.000001’,master_log_pos=311;

34另一种适合我自己的安装mysql的方法

详情点这里：https://www.cnblogs.com/wangshen31/p/9556804.html

35 hive安装

1.配置
保证环境变量中有JAVA_HOME,HADOOP_HOME,HIVE_HOME即可

2.配置hive的元数据存储在mysql中
①拷贝Mysql的驱动到 $HIVE_HOME/lib中
②编辑hive-site.xml文件，配置元数据的存储位置

<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
<property>
	<name>hive.cli.print.header</name>
	<value>true</value>
</property>

<property>
	<name>hive.cli.print.current.db</name>
	<value>true</value>
</property>

        <property>
          <name>javax.jdo.option.ConnectionURL</name>
          <value>jdbc:mysql://192.168.6.100:3306/metastore?createDatabaseIfNotExist=true</value>
          <description>JDBC connect string for a JDBC metastore</description>
        </property>

        <property>
          <name>javax.jdo.option.ConnectionDriverName</name>
          <value>com.mysql.jdbc.Driver</value>
          <description>Driver class name for a JDBC metastore</description>
        </property>

        <property>
          <name>javax.jdo.option.ConnectionUserName</name>
          <value>root</value>
          <description>username to use against metastore database</description>
        </property>

        <property>
          <name>javax.jdo.option.ConnectionPassword</name>
          <value>dska2Ugquh)0</value>
          <description>password to use against metastore database</description>
        </property>
</configuration>

36安装keeplived

无法安装跳过

37安装Tez

<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
<property>
	<name>tez.lib.uris</name>
    <value>${fs.defaultFS}/tez/apache-tez-0.9.1-bin.tar.gz</value>
</property>
<property>
     <name>tez.use.cluster.hadoop-libs</name>
     <value>true</value>
</property>
<property>
     <name>tez.history.logging.service.class</name>        <value>org.apache.tez.dag.history.logging.ats.ATSHistoryLoggingService</value>
</property>
</configuration>

你看我在笑呢

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
2021-07-25

这里只是简单的写了我所学的内容，详细的笔记是在学习的过程中记录在电脑上了。1 安装jdk2 日志的输出3修改集群时间脚本3.1 通过修改系统时间，模拟生成不同日期的数据3.2 脚本内容3.3 在shell中如果传入的参数中有空格如何处理4同步集群到最新时间4.1脚本内容5 安装hadoop5.1 编辑core-site.xml文件5.2编辑vim hdfs-site.xml 文件5.3编辑 yarn-site.xml文件6hadoop集群的启动和停止脚本6.1脚本内容7为Hadoop集群安装LZO压缩7.1
复制链接

扫一扫