使用flume自定义批量写入hdfs文件压缩格式并且hive外部关联表关联到相应的hdfs路径 kafka+Flume+hdfs+hive

最新推荐文章于 2023-05-19 10:58:10 发布
最新推荐文章于 2023-05-19 10:58:10 发布
阅读量971 收藏 5
点赞数
文章标签： flume hive hdfs 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41768325/article/details/107617435
版权

我们的项目需求是spark任务处理完的数据发送至kafka中然后使用flume将数据根据表名写入hdfs中并且要求写入的文件格式是压缩格式。

flume是有自定义Sink这一说的，所以我们这里需要用到flume指定Sink这一技术，这里我们就需要用到的flume是1.7版本的

<dependency>
    <groupId>org.apache.flume</groupId>
    <artifactId>flume-ng-core</artifactId>
    <version>1.7.0</version>
</dependency>

这个是我的maven依赖

以下是我的flume properties.properties配置

server.sources = kafka_test
server.channels = channel_test
server.sinks = hdfs_test

server.sources.kafka_test.type = org.apache.flume.source.kafka.KafkaSource
server.sources.kafka_test.kafka.topics = flume_test
server.sources.kafka_test.montime = 
server.sources.kafka_test.nodatatime = 0
server.sources.kafka_test.kafka.topics.regex = 
server.sources.kafka_test.kafka.consumer.group.id = test1
server.sources.kafka_test.kafka.bootstrap.servers = kafkaip：端口
server.sources.kafka_test.kafka.security.protocol  = PLAINTEXT
server.sources.kafka_test.batchDurationMillis = 1000
server.sources.kafka_test.batchSize = 1000
server.sources.kafka_test.channels = channel_test

server.channels.channel_test.type = memory
server.channels.channel_test.capacity = 10000
server.channels.channel_test.transactionCapacity = 10000
server.channels.channel_test.channelfullcount = 10
server.channels.channel_test.keep-alive = 3
server.channels.channel_test.byteCapacity = 
server.channels.channel_test.byteCapacityBufferPercentage = 20

server.sinks.hdfs_test.type = com.kdriving.dataprocessor.flume.MySink
server.sinks.hdfs_test.channel = channel_test 

为什么要自定义呢？

因为kafka的一个topic中包含了多样的数据并不只是一种，而且这些数据我们是根据不同的表存储到hdfs不同的目录当中方便以后hive建表的时候关联。

接下来看一下代码：

package com.kdriving.dataprocessor.flume;

import java.io.*;
import java.net.URI;
import java.text.SimpleDateFormat;
import java.util.*;


import com.alibaba.fastjson.JSONObject;
import com.google.common.base.Throwables;
import com.kd.common.application.AppInfo;
import com.kd.common.log.Logger;
import com.kd.common.log.LoggerFactory;

import org.apache.flume.*;
import org.apache.flume.conf.Configurable;
import org.apache.flume.instrumentation.SinkCounter;
import org.apache.flume.sink.AbstractSink;


import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.io.compress.CompressionCodec;
import org.apache.hadoop.io.compress.CompressionOutputStream;
import org.apache.hadoop.io.compress.zlib.BuiltInZlibDeflater;
import org.apache.hadoop.util.ReflectionUtils;
import org.apache.kafka.clients.producer.Producer;


public class MySink extends AbstractSink implements Configurable {
    private static final Logger LOGGER = LoggerFactory.getLogger(MySink.class);
    private static String nameservices = AppInfo.instance.getConf().getProperty("datacenter.base.hdfs.nameservices");
    private static String namenodes = AppInfo.instance.getConf().getProperty("datacenter.base.hdfs.namenodes");
    private static String namenodesAddr = AppInfo.instance.getConf().getProperty("datacenter.base.hdfs.namenodesAddr");
    private String hdfsURI;

    private static final long defaultRollInterval = 30;
    private String username;

    private String dataDir;

    private String dateFormat;

    private URI uri;


    private static Configuration conf = new Configuration();

    private FSDataOutputStream out = null;
    private Properties parameters;
    private Producer<String, String> producer;
    // private Context context;
    private int batchSize = 1000;// 一次事务的event数量，整体提交
 
    private SinkCounter sinkCounter;

    //初始化hdfs
    static {
        String[] namenodesArray = namenodes.split(",");
        String[] namenodesAddrArray = namenodesAddr.split(",");
        conf.set("fs.defaultFS", "hdfs://" + nameservices);

        conf.set("dfs.nameservices", nameservices);

        conf.set("dfs.ha.namenodes." + nameservices, namenodesArray[0] + "," + namenodesArray[1]);

        conf.set("dfs.namenode.rpc-address.hacluster." + namenodesArray[0], namenodesAddrArray[0]);

        conf.set("dfs.namenode.rpc-address.hacluster." + namenodesArray[1], namenodesAddrArray[1]);

        conf.set("dfs.client.failover.proxy.provider." + nameservices, "org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider");

        conf.setBoolean("dfs.support.append", true);
        conf.set("dfs.client.block.write.replace-datanode-on-failure.policy", "DEFAULT");
        conf.setBoolean("dfs.client.block.write.replace-datanode-on-failure.enable", true);
    }

    //数据处理的逻辑都在process方法中实现
    @Override
    public Status process() throws EventDeliveryException {

        LOGGER.info("开始执行mysink");
        // TODO Auto-generated method stub
        Status result = Status.READY;

        Channel channel = getChannel();
        Transaction transaction = null;
        Event event = null;
        String[] tablearrays = new String[]{"RADAR_RADAR_VALID", "RADAR_COMPREHENSIVE_VALID"};

        try {
            //要选择hdfs的压缩格式，可以从hdfs core-site.xml的配置项io.compression.codecs中查看hdfs支持的压缩格式
            String CodecClass = "org.apache.hadoop.io.compress.BZip2Codec";
            Class<?> codecClass = Class.forName(CodecClass);
            CompressionCodec codec = (CompressionCodec) ReflectionUtils.newInstance(codecClass, conf);
            long processedEvent = 0;
            transaction = channel.getTransaction();
            transaction.begin();// 事务开始
            List<String> radarList = new ArrayList<>();
            List<String> COMPREHENSIVEList = new ArrayList<>();
            Boolean b = true;
            Map<String, List<String>> tableMap = new HashMap<>();
            while (b) {
                event = channel.take();// 从channel取出一个事件
                if (event == null) {
                    //LOGGER.info("event为空");
                    result = Status.BACKOFF;
                    break;
                } else {
                    byte[] eventBody = event.getBody();
                    String eventData = new String(eventBody, "UTF-8");
                    //  LOGGER.info("event有数据-》" + eventData);

                }
                sinkCounter.incrementEventDrainAttemptCount();
                // Map<String, String> headers = event.getHeaders();

                byte[] eventBody = event.getBody();
                String eventData = new String(eventBody, "UTF-8");
                JSONObject jsonObject = JSONObject.parseObject(eventData);
                String table = jsonObject.getString("TABLE");

                if (table.equals(tablearrays[0])) {
                    radarList.add(eventData);
                } else if (table.equals(tablearrays[1])) {
                    COMPREHENSIVEList.add(eventData);
                }
                if (radarList.size() > 1000) {
                    b = false;
                } else if (COMPREHENSIVEList.size() > 1000) {
                    b = false;
                }
                processedEvent++;
            }
            tableMap.put(tablearrays[0], radarList);
            tableMap.put(tablearrays[1], COMPREHENSIVEList);
            LOGGER.info("messageList大小" + radarList.size());
            if (processedEvent == 0) {
                LOGGER.info("processedEvent=0");
                sinkCounter.incrementBatchEmptyCount();
                result = Status.BACKOFF;
            } else {
                if (processedEvent < batchSize) {
                    sinkCounter.incrementBatchUnderflowCount();
                } else {
                    sinkCounter.incrementBatchCompleteCount();
                }
                sinkCounter.addToEventDrainAttemptCount(processedEvent);


                for (Map.Entry<String, List<String>> entry : tableMap.entrySet()) {

                    FSDataOutputStream outputStream = creatoutputStream(entry.getKey());

                    CompressionOutputStream cout = codec.createOutputStream(outputStream);
                    for (String body : entry.getValue()) {
                        String clo = "id|row|RSPID|LONGITUDE|CreateTime|TimeMin1|flightId|GroudSpeed|TRACKID|MsgType|REGID|TimeStamp|DataSource|fusion|DepAP|CallSign|TimeMin5|VerticalRate|SOURCE|ArrAP|DataType|Height|Vector|LATITUDE|Altitude|";
                        String[] split = clo.split("\\|");
                        String data = new String(body.getBytes("UTF-8"));
                        JSONObject jsonObject = JSONObject.parseObject(data);
                        jsonObject.put("row", jsonObject.getString("id"));
                        StringBuilder stringBuilder = new StringBuilder();
                        for (String s : split) {
                            String string = jsonObject.getString(s);
                            if (string == null || string.equals("")) {
                                string = "null";
                            }
                            stringBuilder.append(string).append("|");
                        }
                        LOGGER.info("HDFS正在写入新数据->" + stringBuilder);
                        String string = stringBuilder.toString();

                        cout.write(string.getBytes("UTF-8"));
                        cout.write("\r\n".getBytes("UTF-8"));
                        cout.flush();
                    }
                    cout.close();
                    outputStream.close();
                }


            }
            transaction.commit();// batchSize个事件处理完成，一次事务提交
            sinkCounter.addToEventDrainSuccessCount(processedEvent);
            result = Status.READY;
        } catch (Exception e) {
            String errorMsg = "Failed to publish events !";
            LOGGER.error(errorMsg, e);
            e.printStackTrace();
            result = Status.BACKOFF;
            if (transaction != null) {
                try {
                    transaction.rollback();
                    LOGGER.debug("transaction rollback success !");
                } catch (Exception ex) {
                    LOGGER.error(errorMsg, ex);
                    throw Throwables.propagate(ex);
                }
            }
            // throw new EventDeliveryException(errorMsg, e);
        } finally {
            if (transaction != null) {
                transaction.close();
            }
        }
        return result;


    }


    public FSDataOutputStream creatoutputStream(String table) throws Exception {
        String radar_radar_validFile = "";

        String date = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
        Calendar calendar = Calendar.getInstance();
        int year = calendar.get(Calendar.YEAR);
        int moth = calendar.get(Calendar.MONTH) + 1;
        int day = calendar.get(Calendar.DATE);
        String yearPath = "/data/" + table + "/" + year;
        String monthPath = "/data/" + table + "/" + year + "/" + moth;
        String dayPath = "/data/" + table + "/" + year + "/" + moth + "/" + day;
        Path yearfilePath = new Path(yearPath);
        Path monthfilePath = new Path(monthPath);
        Path dayfilePath = new Path(dayPath);
        radar_radar_validFile = "/data/" + table + "/" + year + "/" + moth + "/" + day + "/" + date + "-" + table + ".bz2";

        Path filePath = new Path(radar_radar_validFile);
        FileSystem hdfs = filePath.getFileSystem(conf);
        if (!hdfs.exists(yearfilePath)) {
            hdfs.mkdirs(yearfilePath);
            LOGGER.info(yearfilePath.toString() + "路径不存在已创建成功");
        }
        if (!hdfs.exists(monthfilePath)) {
            hdfs.mkdirs(monthfilePath);
            LOGGER.info(monthfilePath.toString() + "路径不存在已创建成功");
        }
        if (!hdfs.exists(dayfilePath)) {
            hdfs.mkdirs(dayfilePath);
            LOGGER.info(dayfilePath.toString() + "路径不存在已创建成功");
        }
        if (!hdfs.exists(filePath)) {
            hdfs.createNewFile(filePath);
            LOGGER.info(filePath.toString() + "文件不存在已创建成功");
        }


        return hdfs.append(new Path(radar_radar_validFile));


    }

    //该方法用于读取Flume中Sink的配置，在Sink初始化时调用
    @Override
    public void configure(Context context) {

        if (sinkCounter == null) {
            sinkCounter = new SinkCounter(getName());
        }

        // customelog.sinks.sink1.type=death.flume.FlumeSinkDemo
        // customelog.sinks.sink1.channel=channel1
        // customelog.sinks.sink1.hdfsURI=hdfs://hostname:port
        // customelog.sinks.sink1.username=hdfs
        // customelog.sinks.sink1.dataDir=/death/data_sampling
        // customelog.sinks.sink1.dateFormat=YYYY-MM-dd
    }

    //该方法用于Sink启动时调用
    @Override
    public synchronized void start() {

        sinkCounter.start();
        sinkCounter.incrementConnectionCreatedCount();
        super.start();

//        try {
//            uri = new URI(hdfsURI);
//            conf = new Configuration();
//        }catch (Exception e){
//            e.printStackTrace();
//        }
    }

    //该方法用于Sink停止使用调用
    @Override
    public synchronized void stop() {
        sinkCounter.stop();
        sinkCounter.incrementConnectionClosedCount();
        super.stop();
    }
}

 

将项目jar包存放至flume的lib目录下面！！！然后执行properties.properties配置文件，我们使用的是FusionInsight Manager来启动fume任务，

选择我们要执行flume任务的节点

然后上传properties.properties文件，然后点击保存配置

 

然后通过hue检查文件是否存在hdfs上面

文件成功存储到该路径下

然后再使用hive外部表关联至目录下

CREATE EXTERNAL TABLE IF NOT EXISTS `RADAR_RADARAIRLINE_VALID`( `id` STRING ,
`row` STRING ,
`RSPID` STRING ,
`LONGITUDE` STRING ,
`CreateTime` STRING ,
`TimeMin1` STRING ,
`flightId` STRING ,
`GroudSpeed` STRING ,
`TRACKID` STRING ,
`MsgType` STRING ,
`REGID` STRING ,
`TimeStamp` STRING ,
`DataSource` STRING ,
`fusion` STRING ,
`DepAP` STRING ,
`CallSign` STRING ,
`TimeMin5` STRING ,
`VerticalRate` STRING ,
`SOURCE` STRING ,
`ArrAP` STRING ,
`DataType` STRING ,
`Height` STRING ,
`Vector` STRING ,
`LATITUDE` STRING ,
`Altitude` STRING  

)
PARTITIONED BY (`dt` string)
                    ROW FORMAT DELIMITED 
                    FIELDS TERMINATED BY '|'
                   STORED AS INPUTFORMAT
'org.apache.hadoop.mapred.TextInputFormat'
 OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
                     LOCATION 'hdfs://namenodeip:hdfs端口/data/radar_radar_valid/2020/07/23'

关联成功后查询数据

查询成功！！！

当然这个中间有很多波折，，其实所谓的经验就是在一点点的学习中慢慢积累起来的！！！借此博客记录一下这次经典的flume结合hdfs，hive的使用

云谱科技工作室计算机毕设
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Hadoop+Spark+Hive+HBase+Oozie+Kafka+Flume+Flink+ES+Redash等详细安装部署
06-22
在大数据领域，构建一个完整的生态系统是至关重要的，其中包括多个组件，如Hadoop、Spark、Hive、HBase、Oozie、Kafka、Flume、Flink、Elasticsearch和Redash。这些组件协同工作，提供了数据存储、处理、调度、流...
（转）Flume中的HDFS Sink配置参数说明及输出压缩配置
小蚯蚓的博客
03-15 1494
【转载原因：flume的sink压缩配置】 【转载原文：https://blog.csdn.net/helloxiaozhe/article/details/88417091】 关键字：flume、hdfs、sink、配置参数 滚动条件与输出hdfs的文件的压缩配置 Flume中的HDFS Sink应该是非常常用的，其中的配置参数也比较多，在这里记录备忘一下。 channel t...
flume hive sink 用法详解
旺旺的博客
03-22 3930
1.需求: 有这样一个需求。要从kafka采集数据然后写到hdfs上。要直接写为orc格式。直接给orc的表来用。 2.解决问题 1） 我们首先想到用flume的 kafka source 和hdfs sink。但是事实是hdfs不能直接写为orc格式。除非自己再重新封装hdfs sink。 （这样就要开发了）。下面是官网的hdfs sink(1.9版本) 说只允许那几种压缩和Sequ...
【采集项目-（5)将Kafka的数据采集到hdfs】
Tonystark_lz的博客
10-09 1250
【采集项目-（5)将Kafka的数据采集到hdfs】
flink批量写入到hdfs上
wppwpp1的专栏
03-20 2204
import org.apache.flink.streaming.api.functions.source.SourceFunction /** * @Author: wpp * @Date: 2020/3/13 18:28 * */ class MyNoParallelScala extends SourceFunction[String]{ var count=...
flume 写入hdfs 采用lzo格式压缩，出现压缩格式支持错误
AlwaysBestSign_X的博客
06-21 1026
使用Flume消费kafka中数据，sink到hdfs中出现数据压缩格式支持错误； 报错如下： error during configuration java.lang.IllegalArgumentException: Unsupported compression codec Lzop. Please choose from: [None, BZip2Codec, DefaultCodec, DeflateCodec, GzipCodec, Lz4Codec, SnappyCodec] at org.
大数据实习hdfs+flume+kafka+spark+hbase+hive项目.zip
最新发布
03-04
在大数据领域，HDFS、Flume、Kafka、Spark、HBase和Hive是关键的组件，它们共同构建了一个高效、可靠的数据处理和分析体系。下面将分别介绍这些技术及其在实际项目中的应用。 1. HDFS（Hadoop Distributed File ...
利用Flume将MySQL表数据准实时抽取到HDFS、MySQL、Kafka
03-06
标题中的“利用Flume将MySQL表数据准实时抽取到HDFS、MySQL、Kafka”是一项数据集成任务，涉及Apache Flume、MySQL数据库、Hadoop Distributed File System (HDFS) 和Apache Kafka这四个关键技术。Flume是Apache的一...
kafka+flume 实时采集oracle数据到hive中.docx
08-11
然后，使用Flume从Kafka Topic中提取数据，并将其写入到HDFS中。最后，使用Hive从HDFS中读取数据，并将其存储到Hive表中。 使用Kafka和Flume可以实现实时采集Oracle数据到Hive中的需求。Kafka能够实时地从Oracle...
Hadoop+Hive+Spark+Kafka+Zookeeper+Flume+Sqoop+Azkaban+Scala
05-05
分布式文件存储系统：HDFS 分布式计算框架：MapReduce 集群资源管理器：YARN 单机伪集群环境搭建 集群环境搭建 常用 Shell 命令 Java API 的使用 基于 Zookeeper 搭建 Hadoop 高可用集群 二、Hive 简介及核心概念 ...
使用flume将数据导入到hdfs中
Gscsd的博客
04-26 7362
      在前面的博客上我说了flume就是三个最重要的地方，分别是分别是source、channel、sink，source是获取数据，channel是通道，传输数据的，sink是把数据给谁的，这里显而易见的是把数据给hdfs的，所以我们只需要在前面的基础上改sink就可以了在之前的基础上修改a.conf文件中的sink修改完后启动hadoop                查看进程是否开启，...
2022-08-03 Flume
D___H的博客
08-03 156
Flume
Flume
01-08 1036
1.flume是分布式的日志收集系统，把收集来的数据传送到目的地去。 2.flume里面有个核心概念，叫做agent。agent是一个java进程，运行在日志收集节点。 3.agent里面包含3个核心组件：source、channel、sink。 3.1 source组件是专用于收集日志的，可以处理各种类型各种格式的日志数据,包括avro、thrift、exec、jms、spooling d
flume误读压缩文件
Neighbor_L的博客
05-19 211
公司一直用flume读取模块日志，来进行下一步处理，flume出现了两个配置问题：1、flume的traceFile目录放在了srcdir下，也就是flume自己的tracelog放在了要读取的模块日志目录下，所以会重复读取日志2、上述两份日志每天被清理脚本压缩一遍，导致已经被flume读取过的日志，压缩之后又被读取了一次，并且由于已经压缩，flume读取到的是乱码。
【运维干货】带宽压缩之Flume Avro方案实践
个推技术学院
04-10 4712
引言 带宽不够用，靠这个方法我让数据压缩率达到了80%以上 如何在有限的资源下解决性能瓶颈问题是运维永恒的痛点。这期文章，Mr.Tech 邀请了在性能优化方面有着丰富经验的个推高级运维工程师白子画，为大家分享宽带优化之Flume Avro在个推的实践。 在异地日志数据互传的场景下，我们从传输数据着手，借助Avro的特性使数据压缩率达80%以上，解决了个推在实际生产过程中遇到的带宽...
【大数据实验系列】解决日志收集框架Flume使用HDFS的Sink类型，且使用codeC=gzip压缩方式时，Flume日志信息一直卡在Got brand-new Compressor[.gz]的问题
弗兰-随风小欢的博客
04-01 454
解决日志收集框架Flume使用HDFS的Sink类型，且使用codeC=gzip压缩方式时，Flume日志信息一直卡在Got brand-new Compressor[.gz]的问题
Flume安装
timicai的博客
11-30 359
flume安装目录一、安装Flume二、安装nc三、安装telnet测试四、案例 安装包及测试文件 提取码: ktc2 一、安装Flume 1.压缩包拉入opt目录中 2.解压flume到opt tar -zxvf flume-ng-1.6.0-cdh5.14.0.tar.gz 3.重命名flume mv apache-flume-1.6.0-cdh5.14.0-bin/ flume 4.切换到flume的conf cd flume/conf 5.拷贝一份flume-env.sh.template，重
flume的安装及使用
Gscsd的博客
04-26 556
  Flume是什么？      Flume是Cloudera提供的一个高可用的，高可靠的，分布式的海量日志采集、聚合和传输的系统，Flume支持在日志系统中定制各类数据发送方，用于收集数据；同时，Flume提供对数据进行简单处理，并写到各种数据接受方(可定制)的能力。说白了flume就是可以从某个地方收集数据，再经过一个叫channel的通道后，将数据给某个东西，下面有张结构图，流程叫agent...
Flume采集数据到HDFS配置参数详细解析
qq_59127145的博客
11-01 2331
flume到hdfs
flume数据采集_flume采集Kafka数据到hdfshive
05-29
在上面的配置文件中，我们使用Kafka作为Source，将数据写入到HDFS和Hive中。我们使用Memory Channel将数据缓存在内存中，然后将其写入到HDFS和Hive中。在Hive Sink中，我们还定义了一个分区，以便按日期对数据进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

云谱科技工作室计算机毕设

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值