实战-数据仓库构建（三）

问题导读：

1. 数仓数据采集模块集群规划是怎么样的？
2. 数仓日志生成模块的配置是怎么样的？
3. 数仓数据采集模块Kafka如何进行优化？

一、数据采集模块

【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

[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】代码参数说明

扫描二维码关注公众号，回复： 11711803 查看本文章

/ 参数一：控制发送每条的延时时间，默认是 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

实战-数据仓库构建（三）

猜你喜欢