(图片来源于网络,侵删)
一、数据采集模块
【1】Linux环境搭建
Linux配置请看这篇博客👉Linux基本配置
【2】Hadoop环境搭建
1)基础环境创建
[node01]
cd ~
mkdir bin
cd bin
vim xsync
=======================脚本如下========================
#!/bin/bash
#1 获取输入参数个数,如果没有参数,直接退出
pcount=$#
if((pcount==0)); then
echo no args;
exit;
fi
#2 获取文件名称
p1=$1
fname=`basename $p1`
echo fname=$fname
#3 获取上级目录到绝对路径
pdir=`cd -P $(dirname $p1); pwd`
echo pdir=$pdir
#4 获取当前用户名称
user=`whoami`
#5 循环
for((host=101; host<104; host++)); do
echo ------------------- hadoop$host --------------
rsync -rvl $pdir/$fname $user@hadoop$host:$pdir
done
=======================脚本如上========================
chmod 770 xsync
sudo rm -rf /opt/*
sudo mkdir /opt/modules
sudo mkdir /opt/software
sudo mkdir -p /opt/tmp/logs
sudo chown zsy:zsy -R /opt
xsync /opt/*
[node02/node03]
sudo chown zsy:zsy -R /opt
2)JDK安装
注意: 安装之前,请先删除系统自带的JDK,查看博客👉【Linux】Linux卸载自带的OpenJDK
[node01]
tar -zxf /opt/software/jdk-8u144-linux-x64.tar.gz -C /opt/modules
sudo vim /etc/profile.d/java.sh
export JAVA_HOME=/opt/modules/jdk1.8.0_144
export PATH=$PATH:$JAVA_HOME/bin
source /etc/profile
xsync /opt/modules/jdk1.8.0_144
sudo scp /etc/profile.d/java.sh node02:/etc/profile
sudo scp /etc/profile.d/java.sh node03:/etc/profile
[node02/node03]
source /etc/profile
注意:
可以看到,我在上面添加的JDK环境变量是在/etc/profile.d
目录下创建了一个以.sh
结尾的文件,那么为什么可以这么做呢?
我们首先说一下环境变量的配置方式有哪些👇
1)修改/etc/profile文件:用来设置系统环境参数,比如$PATH,这里面的环境变量是对系统内所有用户
生效。使用bash命令,需要source /etc/profile
一下
2)修改~/.bashrc
文件:针对某一个特定的用户,环境变量的设置只对该用户自己有效
,使用bash命令,只要以该用户身份运行命令行就会读取该文件,该文件会去加载/etc/bashrc
文件,该文件会遍历/etc/profile.d
文件下的以.sh
文件结尾的文件,将其中的环境变量添加到/etc/bashrc
文件中,所以我们把配置的环境变量添加到/etc/profile.d
目录下
3)说明:
登录式Shell:采用用户名登录,会自动加载/etc/profile
非登录式Sehll:采用ssh登录,不会自动加载/etc/profile
,会自动加载~/.backrc
3)Zookeeper安装
具体安装方式请点击博客👉【Zookeeper】Zookeeper入门解析
4)Hadoop安装
具体安装方式请点击博客👉【Hadoop】HadoopHA高可用完全分布式搭建
5)Flume安装
具体安装方式请点击博客👉 【Flume】Flume入门解析(一)
说明:
【1】Source
1)Taildir Source 和 Exec Source 如何选择?
Taildir Source 相比Exec Sgurce、Spooling Directory Source的优势TailDir Source:断点续传、多目录。Flumel.6以前需要自己自定义Source 记录每次读取文件位置,实现断点续传
Exec Source 可以实时搜集数据,但是在Flume不运行或者Shell命令出错的情况下,数据将会丢失
Spooling Directory Source监控目录,不支持断点续传
2)batchSize 大小如何设置?
Event1K左右时,500-1000合适(默认为100)
【2】Channel
采用Kafka Channel,省去了Sink,提高了效率
注意在Flume1.7以前,Kafka Channel很少有人使用,因为发现parseAsFlumeEvent
这个配置起不了作用。也就是无论parseAsFlumeEvent 配置为true还是false,都会转为FlumeEvent。这样的话,造成的结果是,会始终都把Flume的headers中的信息混合着内容一起写入Kafka的消息中,这显然不是我所需要的,我只是需要把内容写入即可
【3】架构图
【4】编辑Flume采集日志数据发送到Kafka配置文件(记得同步配置)
# 说明1:我们使用 TAILDIR Source 监控多目录,自动实现断点续传,版本需要在1.7+
# 说明2:我们使用 Kafka Channel,不使用Kafka Sink,提高效率
a1.sources=r1
a1.channels=c1 c2
# configure source
a1.sources.r1.type = TAILDIR
# 断点续传持久化目录
a1.sources.r1.positionFile = /opt/modules/flume/log_position/log_position.json
# 设置需要监控的多个目录,我们只需要一个,所以只添加一个 f1
a1.sources.r1.filegroups = f1
# 设置 f1 对应的监控目录
a1.sources.r1.filegroups.f1 = /opt/tmp/logs/app.+
a1.sources.r1.fileHeader = true
a1.sources.r1.channels = c1 c2
# interceptor 添加拦截器
a1.sources.r1.interceptors = i1 i2
# 自定义拦截器
a1.sources.r1.interceptors.i1.type = com.zsy.flume.interceptor.LogETLInterceptor$Builder # ETL拦截器
a1.sources.r1.interceptors.i2.type = com.zsy.flume.interceptor.LogTypeInterceptor$Builder #日志类型拦截器
# 根据header头信息,将source数据发送到不同的 Channel
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
# configure channel
a1.channels.c1.type = org.apache.flume.channel.kafka.KafkaChannel
a1.channels.c1.kafka.bootstrap.servers = node01:9092,node02:9092,node03:9092
a1.channels.c1.kafka.topic = topic_start # 日志类型是start,数据发往 channel1
a1.channels.c1.parseAsFlumeEvent = false
a1.channels.c1.kafka.consumer.group.id = flume-consumer
a1.channels.c2.type = org.apache.flume.channel.kafka.KafkaChannel
a1.channels.c2.kafka.bootstrap.servers = node01:9092,node02:9092,node03:9092
a1.channels.c2.kafka.topic = topic_event # 日志类型是event,数据发往 channel2
a1.channels.c2.parseAsFlumeEvent = false
a1.channels.c2.kafka.consumer.group.id = flume-consumer
【5】自定义拦截器
创建Maven项目,添加如下依赖:
<dependencies>
<dependency>
<groupId>org.apache.flume</groupId>
<artifactId>flume-ng-core</artifactId>
<version>1.7.0</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.3.2</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<configuration>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
</configuration>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
自定义拦截器步骤:
① 定义一个类,实现Flume的Interceptor接口
② 重写4个方法
- 初始化
- 单Event处理
- 多Event处理
- 关闭资源
③ 创建静态内部类,返回当前类对象
④ 打包上传
代码如下👇
1)com.zsy.flume.interceptor.LogETLInterceptor
package com.zsy.flume.interceptor;
import org.apache.flume.Context;
import org.apache.flume.Event;
import org.apache.flume.interceptor.Interceptor;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
public class LogETLInterceptor implements Interceptor {
@Override
public void initialize() {
}
@Override
public Event intercept(Event event) {
// 清洗数据 ETL
// 1.获取日志
byte[] body = event.getBody();
String log = new String(body, Charset.forName("UTF-8"));
// 2.区分类型处理
if (log.contains("start")) {
// 验证启动日志逻辑
if (LogUtils.validateStart(log)) {
return event;
}
} else {
// 验证事件日志逻辑
if (LogUtils.validateEvent(log)) {
return event;
}
}
return null;
}
@Override
public List<Event> intercept(List<Event> events) {
ArrayList<Event> interceptors = new ArrayList<>();
// 多event处理
for (Event event : events) {
Event intercept = intercept(event);
if (intercept != null) {
interceptors.add(intercept);
}
}
return interceptors;
}
@Override
public void close() {
}
public static class Builder implements Interceptor.Builder {
@Override
public Interceptor build() {
return new LogETLInterceptor();
}
@Override
public void configure(Context context) {
}
}
}
2)com.zsy.flume.interceptor.LogTypeInterceptor
package com.zsy.flume.interceptor;
import org.apache.flume.Context;
import org.apache.flume.Event;
import org.apache.flume.interceptor.Interceptor;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public class LogTypeInterceptor implements Interceptor {
@Override
public void initialize() {
}
@Override
public Event intercept(Event event) {
// 区分类型 start event
// header body
byte[] body = event.getBody();
String log = new String(body, Charset.forName("UTF-8"));
// 获取头信息
Map<String, String> headers = event.getHeaders();
// 业务逻辑判断
if(log.contains("start")){
headers.put("topic","topic_start");
}else{
headers.put("topic","topic_event");
}
return event;
}
@Override
public List<Event> intercept(List<Event> events) {
ArrayList<Event> interceptors = new ArrayList<>();
for (Event event : events) {
Event intercept = intercept(event);
interceptors.add(intercept);
}
return interceptors;
}
@Override
public void close() {
}
public static class Builder implements Interceptor.Builder{
@Override
public Interceptor build() {
return new LogTypeInterceptor();
}
@Override
public void configure(Context context) {
}
}
}
3)工具类
package com.zsy.flume.interceptor;
import org.apache.commons.lang.math.NumberUtils;
public class LogUtils {
// 验证启动日志逻辑
public static boolean validateStart(String log) {
if (log == null) {
return false;
}
// 判断数据是否是 { 开头 ,是否是 } 结尾
if (!log.trim().startsWith("{") || !log.trim().endsWith("}")) {
return false;
}
return true;
}
// 验证事件日志逻辑
public static boolean validateEvent(String log) {
// 判断数据是否是 { 开头 ,是否是 } 结尾
// 服务器事件 | 日志内容
if (log == null) {
return false;
}
// 切割
String[] logContents = log.split("\\|");
if(logContents.length != 2){
return false;
}
// 校验服务器时间(长度必须是13位,必须全部是数字)
if(logContents[0].length() != 13 || !logContents[0].matches("[0-9]{13}")){
// if(logContents[0].length() != 13 || !NumberUtils.isDigits(logContents[0])){
return false;
}
// 校验日志格式
if (!logContents[1].trim().startsWith("{") || !logContents[1].trim().endsWith("}")) {
return false;
}
return true;
}
}
4)打包将不带依赖的jar包上传到 Flume的 lib 目录下即可,flume启动会自动加载 lib下的所有jar包
【6】Flume启动/停止脚本
#! /bin/bash
case $1 in
"start"){
for i in node01 node02
do
echo " --------启动 $i 采集 flume-------"
ssh $i "nohup /opt/modules/flume/bin/flume-ng agent --conf-file /opt/modules/flume/conf/file-flume-kafka.conf --name a1 -Dflume.root.logger=INFO,LOGFILE >/dev/null 2>&1 &"
done
};;
"stop"){
for i in node01 node02
do
echo " --------停止 $i 采集 flume-------"
ssh $i "ps -ef | grep file-flume-kafka | grep -v grep |awk '{print \$2}' | xargs kill"
done
};;
esac
说明1:nohub该命令表示在退出账户/关闭终端后继续运行相应的进程,意味不挂起,不挂断地运行命令
说明2:awk默认分隔符为空格
说明3:xargs 表示取出前面命令运行地结果,作为后面命令地输入参数
6)Kafka安装
具体安装方式请点击博客👉【Kafka】Kafka入门解析(一)
7)日志生成
前提:将我们之前写好的日志数据生成代码打包放到服务器上
日志启动
【1】代码参数说明
// 参数一:控制发送每条的延时时间,默认是 0
Long delay = args.length > 0 ? Long.parseLong(args[0]) : 0L;
// 参数二:循环遍历次数
int loop_len = args.length > 1 ? Integer.parseInt(args[1]) : 1000;
【2】 将 生 成 的 jar 包 log-collector-1.0-SNAPSHOT-jar-with-dependencies.jar
拷 贝 到
node01 服务器 /opt
目录下,并同步到 node02
【3】在 node01 上执行 jar 程序
方式1:
java -classpath log-collector-1.0-SNAPSHOT-jar-with-dependencies.jar com.zsy.appclient.AppMain > /dev/null 2>&1
说明:
如果打包时没有指定主函数,则使用 -classpath,并在 jar 包后面指定主函数全类名
方式2:
java -jar log-collector-1.0-SNAPSHOT-jar-with-dependencies.jar > /dev/null 2>&1
说明:
如果打包时指定了主函数,则可以使用 -jar ,此时不用指定主函数的全类名
说明:/dev/null
代表 linux 的空设备文件,所有往这个文件里面写入的内容都会丢失,俗称“黑洞”
- 标准输入 0:从键盘获得输入 /proc/self/fd/0
- 标准输出 1:输出到屏幕(即控制台) /proc/self/fd/1
- 错误输出 2:输出到屏幕(即控制台) /proc/self/fd/2
【4】查看日志数据,在我们指定好的目录/opt/tmp/logs
目录下查看数据
【5】脚本
我们为了方便使用,就通过脚本来实现数据的生成!
日志数据生成脚本如下👇
#! /bin/bash
for i in node01 node02
do
echo "========== $i 生成日志数据中... =========="
ssh $i "java -jar /opt/log-collector-1.0-SNAPSHOT-jar-with-dependencies.jar $1 $2 >/dev/null 2>&1 &"
done
时间同步脚本(临时脚本,只是后续为了时间同步而需要的)如下👇
#!/bin/bash
for i in node01 node02 node03
do
echo "========== $i =========="
ssh -t $i "sudo date -s $1"
done
参数说明:
我们可以发现上面的参数中我们使用了 -t ,是因为我们使用了 sudo ,所以需要使用 -t 参数来形成虚拟终端,不需要深究,只要使用 sudo,在ssh后面添加 -t 接口
8)Flume消费Kafka数据存储在HDFS
【1】我们在前面配置了node01、node02采集日志数据传输到Kafka,现在我们需要在node03消费Kafka数据存储到HDFS上
架构图如下👇
Flume配置如下👇
## 组件
a1.sources=r1 r2
a1.channels=c1 c2
a1.sinks=k1 k2
## source1
a1.sources.r1.type = org.apache.flume.source.kafka.KafkaSource
a1.sources.r1.batchSize = 5000
a1.sources.r1.batchDurationMillis = 2000
a1.sources.r1.kafka.bootstrap.servers = node01:9092,node02:9092,node03:9092
a1.sources.r1.kafka.topics = topic_start
## source2
a1.sources.r2.type = org.apache.flume.source.kafka.KafkaSource
a1.sources.r2.batchSize = 5000
a1.sources.r2.batchDurationMillis = 2000
a1.sources.r2.kafka.bootstrap.servers = node01:9092,node02:9092,node03:9092
a1.sources.r2.kafka.topics = topic_event
## channel1
a1.channels.c1.type = file
a1.channels.c1.checkpointDir = /opt/modules/flume/checkpoint/behavior1
a1.channels.c1.dataDirs = /opt/modules/flume/data/behavior1/
a1.channels.c1.maxFileSize = 2146435071
a1.channels.c1.capacity = 1000000
a1.channels.c1.keep-alive = 6
## channel2
a1.channels.c2.type = file
a1.channels.c2.checkpointDir = /opt/modules/flume/checkpoint/behavior2
a1.channels.c2.dataDirs = /opt/modules/flume/data/behavior2/
a1.channels.c2.maxFileSize = 2146435071
a1.channels.c2.capacity = 1000000
a1.channels.c2.keep-alive = 6
## sink1
a1.sinks.k1.type = hdfs
a1.sinks.k1.hdfs.path = /origin_data/gmall/log/topic_start/%Y-%m-%d
a1.sinks.k1.hdfs.filePrefix = logstart-
##sink2
a1.sinks.k2.type = hdfs
a1.sinks.k2.hdfs.path = /origin_data/gmall/log/topic_event/%Y-%m-%d
a1.sinks.k2.hdfs.filePrefix = logevent-
## 不要产生大量小文件
a1.sinks.k1.hdfs.rollInterval = 3600
a1.sinks.k1.hdfs.rollSize = 134217728
a1.sinks.k1.hdfs.rollCount = 0
a1.sinks.k2.hdfs.rollInterval = 10
a1.sinks.k2.hdfs.rollSize = 134217728
a1.sinks.k2.hdfs.rollCount = 0
## 控制输出文件是原生文件。
a1.sinks.k1.hdfs.fileType = CompressedStream
a1.sinks.k2.hdfs.fileType = CompressedStream
a1.sinks.k1.hdfs.codeC = lzop
a1.sinks.k2.hdfs.codeC = lzop
## 拼装
a1.sources.r1.channels = c1
a1.sinks.k1.channel= c1
a1.sources.r2.channels = c2
a1.sinks.k2.channel= c2
【2】FileChannel 和 MemoryChannel 区别
- MemoryChannel 传输数据速度更快,但因为数据保存在 JVM 的堆内存中,Agent 进程
挂掉会导致数据丢失,适用于对数据质量要求不高的需求 - FileChannel 传输速度相对于 Memory 慢,但数据安全保障高,Agent 进程挂掉也可以从
失败中恢复数据
【3】FileChannel 优化
通过配置 dataDirs 指向多个路径,每个路径对应不同的硬盘,增大 Flume 吞吐量
官方说明如下:
Comma separated list of directories for storing log files. Using
multiple directories on separate disks can improve file channel
peformance
checkpointDir
和 backupCheckpointDir
也尽量配置在不同硬盘
对应的目录中,保证
checkpoint 坏掉后,可以快速使用 backupCheckpointDir 恢复数据
【4】Sink:HDFS Sink
- (1)HDFS 存入大量小文件,有什么影响?
- 元数据层面:每个小文件都有一份元数据,其中包括文件路径,文件名,所有者,所属
组,权限,创建时间等,这些信息都保存在 Namenode 内存中。所以小文件过多,会占用
Namenode 服务器大量内存,影响 Namenode 性能和使用寿命 - 计算层面:默认情况下 MR 会对每个小文件启用一个 Map 任务计算,非常影响计算性
能。同时也影响磁盘寻址时间
- 元数据层面:每个小文件都有一份元数据,其中包括文件路径,文件名,所有者,所属
- (2)HDFS 小文件处理
官方默认的这三个参数配置写入 HDFS 后会产生小文件,hdfs.rollInterval、hdfs.rollSize、
hdfs.rollCount
基于以上hdfs.rollInterval=3600
,hdfs.rollSize=134217728
,hdfs.rollCount =0
几个参数综
合作用,效果如下:- (1)文件在达到 128M 时会滚动生成新文件
- (2)文件创建超 3600 秒时会滚动生成新文件
9)数据生产!!!
终于,在前面铺垫了那么多之后,我们终于可以生产数据,并把数据存储到HDFS上了,现在我们来整理整体流程!!!
流程如下👇
1)启动Zookeeper
2)启动Hadoop集群
3)启动Kafka
4)启动Flume
5)生产数据
此时我们可以去HDFS上查看数据了👇
Flume 内存优化
1)问题描述:如果启动消费 Flume 抛出如下异常
ERROR hdfs.HDFSEventSink: process failed
java.lang.OutOfMemoryError: GC overhead limit exceeded
2)解决方案步骤:
- (1)在 node01 服务器的
/opt/modules/flume/conf/flume-env.sh
文件中增加如下配置
export JAVA_OPTS="-Xms100m -Xmx2000m -Dcom.sun.management.jmxremote"
- (2)同步配置到其他服务器
3)Flume 内存参数设置及优化
- JVM heap 一般设置为 4G 或更高,部署在单独的服务器上(4 核 8 线程 16G 内存)
- -Xmx 与-Xms 最好设置一致,减少内存抖动带来的性能影响,如果设置不一致容易导致频繁 fullgc
- -Xms 表示 JVM Heap(堆内存)最小尺寸,初始分配;-Xmx 表示 JVM Heap(堆内存)最大允许的尺寸,按需分配。如果不设置一致,容易在初始化时,由于内存不够,频繁触发 fullgc
数据采集通道启动/停止脚本
1)vim cluster.sh
#!/bin/bash
case $1 in
"start"){
echo " -------- 启动 集群 -------"
#启动 Zookeeper 集群
zk.sh start
sleep 1s;
echo " -------- 启动 hadoop 集群 -------"
/opt/modules/hadoop/sbin/start-dfs.sh
ssh node02 "/opt/modules/hadoop/sbin/start-yarn.sh"
sleep 7s;
#启动 Flume 采集集群
f1.sh start1
#启动 Kafka 采集集群
kk.sh start
sleep 7s;
#启动 Flume 消费集群
f2.sh start
};;
"stop"){
echo " -------- 停止 集群 -------"
#停止 Flume 消费集群
f2.sh stop
#停止 Kafka 采集集群
kk.sh stop
sleep 7s;
#停止 Flume 采集集群
f1.sh stop
echo " -------- 停止 hadoop 集群 -------"
ssh node02 "/opt/modules/hadoop/sbin/stop-yarn.sh"
/opt/modules/hadoop/sbin/stop-dfs.sh
sleep 7s;
#停止 Zookeeper 集群
zk.sh stop
};;
esac
结束语
至此,我们数据生产并清洗传输到HDFS结束了
后续,我们需要开始搭建Hive,进行建模了,敬请期待下一篇博客!