Flume+HBase采集和存储日志数据、多source多channel和多sink的复杂案例

最新推荐文章于 2021-02-24 00:27:36 发布
最新推荐文章于 2021-02-24 00:27:36 发布
阅读量1.2k 收藏 4
点赞数
分类专栏： Flume
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22473611/article/details/88101426
版权

利用Flume 汇入数据到HBase：Flume-hbase-sink 使用方法详解

 https://blog.csdn.net/mnasd/article/details/81878944

一、HBasesinks的三种序列化模式使用说明

1.1 HBasesink--SimpleHbaseEventSerializer

如下是展示如何使用 HBasesink--SimpleHbaseEventSerializer：

agenttest.channels = memoryChannel-1
agenttest.sinks = hbaseSink-1
agenttest.sinks.hbaseSink-1.type = org.apache.flume.sink.hbase.HBaseSink
agenttest.sinks.hbaseSink-1.table = test_hbase_table  //HBase表名
agenttest.sinks.hbaseSink-1.columnFamily = familycolumn-1  //HBase表的列族名称
agenttest.sinks.hbaseSink-1.serializer= org.apache.flume.sink.hbase.SimpleHbaseEventSerializer
agenttest.sinks.hbaseSink-1.serializer.payloadColumn = columnname  //HBase表的列族下的某个列名称
agenttest.sinks.hbaseSink-1.channels = memoryChannel-1

注：当指定存入到HBase表的某个列族的指定列column时，不能写成：

agenttest.sinks.hbaseSink-1.columnName = columnname
或者：
agenttest.sinks.hbaseSink-1.column = columnname

这些都是网上的错误写法！另外两个序列化模式也是不能这样使用。

1.2 HBasesink--RegexHbaseEventSerializer

如下是展示如何使用 HBasesink--RegexHbaseEventSerializer（使用正则匹配切割event，然后存入HBase表的多个列）：

agenttest.channels = memoryChannel-2
agenttest.sinks = hbaseSink-2
agenttest.sinks.hbaseSink-2.type = org.apache.flume.sink.hbase.HBaseSink
agenttest.sinks.hbaseSink-2.table = test_hbase_table
agenttest.sinks.hbaseSink-2.columnFamily = familycolumn-2
agenttest.sinks.hbaseSink-2.serializer= org.apache.flume.sink.hbase.RegexHbaseEventSerializer
// 比如我要对nginx日志做分割，然后按列存储HBase，正则匹配分成的列为: ([xxx] [yyy] [zzz] [nnn] ...) 这种格式, 所以用下面的正则：
agent.sinks.hbaseSink-2.serializer.regex = \\[(.*?)\\]\\ \\[(.*?)\\]\\ \\[(.*?)\\]\\ \\[(.*?)\\]
// 指定上面正则匹配到的数据对应的hbase的familycolumn-2 列族下的4个cloumn列名
agent.sinks.hbaseSink-2.serializer.colNames = column-1,column-2,column-3,column-4
#agent.sinks.hbaseSink-2.serializer.payloadColumn = test
agenttest.sinks.hbaseSink-2.channels = memoryChannel-2

1.3 AsyncHBaseSink--SimpleAsyncHbaseEventSerializer

如下是展示如何使用 AsyncHBaseSink--SimpleAsyncHbaseEventSerializer： 

agenttest.channels = memoryChannel-3
agenttest.sinks = hbaseSink-3
agenttest.sinks.hbaseSink-3.type = org.apache.flume.sink.hbase.AsyncHBaseSink
agenttest.sinks.hbaseSink-3.table = test_hbase_table
agenttest.sinks.hbaseSink-3.columnFamily = familycolumn-3
agenttest.sinks.hbaseSink-3.serializer = org.apache.flume.sink.hbase.SimpleAsyncHbaseEventSerializer
agenttest.sinks.hbaseSink-3.serializer.payloadColumn = columnname  //HBase表的列族下的某个列名称
agenttest.sinks.hbaseSink-3.channels = memoryChannel-3

二、具体案例示例---利用flume+HBase构建大数据采集汇总系统

2.1 利用SimpleHbaseEventSerializer序列化模式

我们首先在HBase里面建立一个表mikeal-hbase-table，拥有familyclom1和familyclom2两个列族：

hbase(main):102:0> create 'mikeal-hbase-table','familyclom1','familyclom2'
0 row(s) in 1.2490 seconds
=> Hbase::Table - mikeal-hbase-table

然后写一个flume的配置文件test-flume-into-hbase.conf：

# 从文件读取实时消息，不做处理直接存储到Hbase
agent.sources = logfile-source
agent.channels = file-channel
agent.sinks = hbase-sink

# logfile-source配置
agent.sources.logfile-source.type = exec
agent.sources.logfile-source.command = tail -f /data/flume-hbase-test/mkhbasetable/data/nginx.log
agent.sources.logfile-source.checkperiodic = 50
# 组合source和channel
agent.sources.logfile-source.channels = file-channel

# channel配置，使用本地file
agent.channels.file-channel.type = file
agent.channels.file-channel.checkpointDir = /data/flume-hbase-test/checkpoint
agent.channels.file-channel.dataDirs = /data/flume-hbase-test/data

# sink 配置为HBaseSink 和 SimpleHbaseEventSerializer
agent.sinks.hbase-sink.type = org.apache.flume.sink.hbase.HBaseSink
#HBase表名
agent.sinks.hbase-sink.table = mikeal-hbase-table
#HBase表的列族名称
agent.sinks.hbase-sink.columnFamily  = familyclom1
agent.sinks.hbase-sink.serializer = org.apache.flume.sink.hbase.SimpleHbaseEventSerializer
#HBase表的列族下的某个列名称
agent.sinks.hbase-sink.serializer.payloadColumn = cloumn-1
# 组合sink和channel
agent.sinks.hbase-sink.channel = file-channel

从配置文件可以看出，我们选择本地的/data/flume-hbase-test/mkhbasetable/data/nginx.log日志目录作为实时数据采集源，选择本地文件目录/data/flume-hbase-test/data作为channel，选择HBase为sink（也就是数据流向写入HBase）。

注意：提交 flume-ng 任务的用户，比如flume用户，必须要有/data/flume-hbase-test/mkhbasetable/data/nginx.log 和/data/flume-hbase-test/data 目录与文件的读写权限；也必须要有HBase的读写权限。

启动Flume：

bin/flume-ng agent --name agent --conf /etc/flume/conf/agent/ --conf-file /etc/flume/conf/agent/test-flume-into-hbase.conf -Dflume.root.logger=DEBUG,console

在另外一个shell客户端，输入：

echo "nging-1" >> /data/flume-hbase-test/mkhbasetable/data/nginx.log;
echo "nging-2" >> /data/flume-hbase-test/mkhbasetable/data/nginx.log;

再查看mikeal-hbase-table表：

数据已经作为value插入到表里面。

2.2 利用SimpleAsyncHbaseEventSerializer序列化模式

为了示例清晰，先把mikeal-hbase-table表数据清空：

truncate 'mikeal-hbase-table'    //truncate 和 delete 只删除数据不删除表的结构,
//drop 语句将删除表的结构被依赖的约束(constrain)、触发器(trigger)、索引(index)

然后写一个flume的配置文件test-flume-into-hbase-2.conf：

# 从文件读取实时消息，不做处理直接存储到Hbase
agent.sources = logfile-source
agent.channels = file-channel
agent.sinks = hbase-sink# logfile-source配置
agent.sources.logfile-source.type = exec
agent.sources.logfile-source.command = tail -f /data/flume-hbase-test/mkhbasetable/data/nginx.log
agent.sources.logfile-source.checkperiodic = 50

# channel配置，使用本地file
agent.channels.file-channel.type = file
agent.channels.file-channel.checkpointDir = /data/flume-hbase-test/checkpoint
agent.channels.file-channel.dataDirs = /data/flume-hbase-test/data

# sink 配置为 Hbase
agent.sinks.hbase-sink.type = org.apache.flume.sink.hbase.AsyncHBaseSink
agent.sinks.hbase-sink.table = mikeal-hbase-table
agent.sinks.hbase-sink.columnFamily  = familyclom1
agent.sinks.hbase-sink.serializer = org.apache.flume.sink.hbase.SimpleAsyncHbaseEventSerializer
agent.sinks.hbase-sink.serializer.payloadColumn = cloumn-1

# 组合source、sink和channel
agent.sources.logfile-source.channels = file-channel
agent.sinks.hbase-sink.channel = file-channel

启动Flume：

bin/flume-ng agent --name agent --conf /etc/flume/conf/agent/ --conf-file /etc/flume/conf/agent/test-flume-into-hbase-2.conf -Dflume.root.logger=DEBUG,console

在另外一个shell客户端，输入：

echo "nging-1" >> /data/flume-hbase-test/mkhbasetable/data/nginx.log;
echo "nging-two" >> /data/flume-hbase-test/mkhbasetable/data/nginx.log;
echo "nging-three" >> /data/flume-hbase-test/mkhbasetable/data/nginx.log;

再查看mikeal-hbase-table表：

 

2.3 利用RegexHbaseEventSerializer序列化模式

RegexHbaseEventSerializer可以使用正则匹配切割event，然后存入HBase表的多个列。因此，本文简单展示如何使用RegexHbaseEventSerializer对event进行切割然后存存入HBase的多个列。

为了示例清晰，先把mikeal-hbase-table表数据清空：

truncate 'mikeal-hbase-table'

然后写一个flume的配置文件test-flume-into-hbase-3.conf：

# 从文件读取实时消息，不做处理直接存储到Hbase
agent.sources = logfile-source
agent.channels = file-channel
agent.sinks = hbase-sink

# logfile-source配置
agent.sources.logfile-source.type = exec
agent.sources.logfile-source.command = tail -f /data/flume-hbase-test/mkhbasetable/data/nginx.log
agent.sources.logfile-source.checkperiodic = 50

# channel配置，使用本地file
agent.channels.file-channel.type = file
agent.channels.file-channel.checkpointDir = /data/flume-hbase-test/checkpoint
agent.channels.file-channel.dataDirs = /data/flume-hbase-test/data

# sink 配置为 Hbase
agent.sinks.hbase-sink.type = org.apache.flume.sink.hbase.HBaseSink
agent.sinks.hbase-sink.table = mikeal-hbase-table
agent.sinks.hbase-sink.columnFamily  = familyclom1
agent.sinks.hbase-sink.serializer = org.apache.flume.sink.hbase.RegexHbaseEventSerializer
# 比如我要对nginx日志做分割，然后按列存储HBase，正则匹配分成的列为: ([xxx] [yyy] [zzz] [nnn] ...) 这种格式, 所以用下面的正则:
agent.sinks.hbase-sink.serializer.regex = \\[(.*?)\\]\\ \\[(.*?)\\]\\ \\[(.*?)\\]
agent.sinks.hbase-sink.serializer.colNames = time,url,number

# 组合source、sink和channel
agent.sources.logfile-source.channels = file-channel
agent.sinks.hbase-sink.channel = file-channel

启动Flume：

bin/flume-ng agent --name agent --conf /etc/flume/conf/agent/ --conf-file /etc/flume/conf/agent/test-flume-into-hbase-3.conf -Dflume.root.logger=DEBUG,console

在另外一个shell客户端，输入：

echo "[2016-12-22-19:59:59] [http://www.qq.com] [10]" >> /data/flume-hbase-test/mkhbasetable/data/nginx.log;
echo "[2016-12-22 20:00:12] [http://qzone.qq.com] [19]" >> /data/flume-hbase-test/mkhbasetable/data/nginx.log;

再查看mikeal-hbase-table表：

 

可以看到数据已经按照规则：正则匹配分成的列为: ([xxx] [yyy] [zzz] [nnn] ...) ，进行切割，并且顺利地存入到mikeal-hbase-table表的time,url,number的三个column列。

三、多source，多channel和多sink的复杂案例

本文接下来展示一个比较复杂的flume导入数据到HBase的实际案例：多souce、多channel和多sink的场景。为了示例清晰，先把mikeal-hbase-table表数据清空：

truncate 'mikeal-hbase-table'

然后写一个flume的配置文件test-flume-into-hbase-multi-position.conf：

# 从文件读取实时消息，不做处理直接存储到Hbase
agent.sources = logfile-source-1 logfile-source-2
agent.channels = file-channel-1 file-channel-2
agent.sinks = hbase-sink-1 hbase-sink-2

# logfile-source配置
agent.sources.logfile-source-1.type = exec
agent.sources.logfile-source-1.command = tail -f /data/flume-hbase-test/mkhbasetable/data/nginx.log
agent.sources.logfile-source-1.checkperiodic = 50

agent.sources.logfile-source-2.type = exec
agent.sources.logfile-source-2.command = tail -f /data/flume-hbase-test/mkhbasetable/data/tomcat.log
agent.sources.logfile-source-2.checkperiodic = 50

# channel配置，使用本地file
agent.channels.file-channel-1.type = file
agent.channels.file-channel-1.checkpointDir = /data/flume-hbase-test/checkpoint
agent.channels.file-channel-1.dataDirs = /data/flume-hbase-test/data

agent.channels.file-channel-2.type = file
agent.channels.file-channel-2.checkpointDir = /data/flume-hbase-test/checkpoint2
agent.channels.file-channel-2.dataDirs = /data/flume-hbase-test/data2

# sink 配置为 Hbase
agent.sinks.hbase-sink-1.type = org.apache.flume.sink.hbase.HBaseSink
agent.sinks.hbase-sink-1.table = mikeal-hbase-table
agent.sinks.hbase-sink-1.columnFamily  = familyclom1
agent.sinks.hbase-sink-1.serializer = org.apache.flume.sink.hbase.RegexHbaseEventSerializer
# 比如我要对nginx日志做分割，然后按列存储HBase，正则匹配分成的列为: ([xxx] [yyy] [zzz] [nnn] ...) 这种格式, 所以用下面的正则:
agent.sinks.hbase-sink-1.serializer.regex = \\[(.*?)\\]\\ \\[(.*?)\\]\\ \\[(.*?)\\]
agent.sinks.hbase-sink-1.serializer.colNames = time,url,number

agent.sinks.hbase-sink-2.type = org.apache.flume.sink.hbase.HBaseSink
agent.sinks.hbase-sink-2.table = mikeal-hbase-table
agent.sinks.hbase-sink-2.columnFamily  = familyclom2
agent.sinks.hbase-sink-2.serializer = org.apache.flume.sink.hbase.RegexHbaseEventSerializer
agent.sinks.hbase-sink-2.serializer.regex = \\[(.*?)\\]\\ \\[(.*?)\\]\\ \\[(.*?)\\]
agent.sinks.hbase-sink-2.serializer.colNames = time,IP,number

# 组合source、sink和channel
agent.sources.logfile-source-1.channels = file-channel-1
agent.sinks.hbase-sink-1.channel = file-channel-1

agent.sources.logfile-source-2.channels = file-channel-2
agent.sinks.hbase-sink-2.channel = file-channel-2

启动Flume：

bin/flume-ng agent --name agent --conf /etc/flume/conf/agent/ --conf-file /etc/flume/conf/agent/test-flume-into-hbase-multi-position.conf -Dflume.root.logger=DEBUG,console

在另外一个shell客户端，输入：

echo "[2016-12-22 20:04:12] [http://music.user.qq.com] [16]" >> nginx.log;
echo "[2016-12-22 20:04:13] [123.41.90.135] [22]" >> tomcat.log;
echo "[2016-12-22 20:05:19] [http://xuetang.vip.qq.com] [24]" >> nginx.log;
echo "[2016-12-22 20:05:21] [134.92.146.109] [25]" >> tomcat.log;

再查看mikeal-hbase-table表：可以看到数据已经按照规则：正则匹配分成的列为: ([xxx] [yyy] [zzz] [nnn] ...) ，进行切割，并且顺利地存入到mikeal-hbase-table表，并且按照familyclom1 和 familyclom2 两个列族分配存到三个cloumn列里面。

 

在本方案中，我们要将数据存储到HBase中，所以使用flume中提供的hbase sink，同时，为了清洗转换日志数据，我们实现自己的AsyncHbaseEventSerializer。https://www.cnblogs.com/gaopeng527/p/5010985.html

public class AsyncHbaseLTEEventSerializer implements AsyncHbaseEventSerializer {
    //表名
    private byte[] table;
    //列族
    private byte[] colFam;
    //当前事件
    private Event currentEvent;
    //列名
    private byte[][] columnNames;
    //用于向HBase批量存储数据
    private final List<PutRequest> puts = new ArrayList<PutRequest>();
    private final List<AtomicIncrementRequest> incs = new ArrayList<AtomicIncrementRequest>();
    //当前行键
    private byte[] currentRowKey;
    private final byte[] eventCountCol = "eventCount".getBytes();
    
    @Override
    public void configure(Context context) {
        //从配置文件中获取列名
        String cols = new String(context.getString("columns"));
        String[] names = cols.split(",");
        columnNames = new byte[names.length][];
        int i = 0;
        for(String name:names){
            columnNames[i++] = name.getBytes();
        } 
    }

    @Override
    public void configure(ComponentConfiguration conf) {
        // TODO Auto-generated method stub 
    }

    @Override
    public void cleanUp() {
        // TODO Auto-generated method stub
        table = null;
        colFam = null;
        currentEvent = null;
        columnNames = null;
        currentRowKey = null;
        
    }

    @Override
    public List<PutRequest> getActions() {
        // 分割事件体获取各列的值
        String eventStr = new String(currentEvent.getBody());
        String[] cols = logTokenize(eventStr);
        puts.clear();
        //数据中的时间
        String time=cols[1];
        int n1 = 13-time.length();
        StringBuilder sb = new StringBuilder(time);
        for(int i=0;i<n1;i++){
            sb.insert(0, '0');
        }
        try {
            //使用自带的行键生成器生成行键
            currentRowKey = SimpleRowKeyGenerator.getUUIDKey(cols[0]+"-"+sb.toString());
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
//        currentRowKey = (cols[0]+"-"+System.currentTimeMillis()).getBytes(); 
        int n = cols.length;
        // 添加每列数据
        for(int i=0;i<n;i++){
            PutRequest putReq = new PutRequest(table, currentRowKey,colFam,columnNames[i],cols[i].getBytes());
            puts.add(putReq);
        }        
        return puts;
    }

    @Override
    public List<AtomicIncrementRequest> getIncrements() {
        // 增加接收到的事件数量
        incs.clear();
        incs.add(new AtomicIncrementRequest(table, "totalEvents".getBytes(), colFam, eventCountCol));
        return incs;
    }

    @Override
    //初始化表名和列名
    public void initialize(byte[] table, byte[] cf) {
        
        this.table = table;
        this.colFam = cf; 
    }

    @Override
    public void setEvent(Event event) {
        // TODO Auto-generated method stub
        this.currentEvent = event;
    }
    
    //从日志中获取列值信息
    public String[] logTokenize(String eventStr) {

//      String logEntryPattern = "^([\\d.]+) (\\S+) (\\S+) \\[([\\w:/]+\\s[+\\-]\\d{4})\\] \"(.+?)\" (\\d{3}) (\\d+|-) \"([^\"]+)\" \"([^\"]+)\"";
//        Pattern p = Pattern.compile(logEntryPattern);
//        Matcher matcher = p.matcher(eventStr); 

/*        if (!matcher.matches()){
            System.err.println("Bad log entry (or problem with RE?):");
            System.err.println(eventStr);
            return null;
        }
*/
        
/*        String[] columns = new String[matcher.groupCount()];       
        for (int i = 0; i < matcher.groupCount(); i++){
            columns[i] = matcher.group(i+1);
        }*/
        
        String[] s = eventStr.split("[:,]");
        int n = s.length;
        String[] columns = new String[n/2];
        for(int i=0;2*i+1<n;i++){
            columns[i] = s[2*i+1];
        } 
        return columns; 
    }  
}

2. 将上面的程序打包，放入flume的lib文件夹中

3. 配置Flume，实现采集和存储

配置文件flume-hbase.properties如下：

############################################
#  flume-src-agent config
###########################################

#agent section
agent.sources = s
agent.channels = c
agent.sinks = r

#source section
#agent.sources.s.type = exec
#agent.sources.s.command = tail -f -n+1 /usr/local/test.log

agent.sources.s.type = spooldir
agent.sources.s.spoolDir = /usr/local/flume-hbase
agent.sources.s.fileHeader = true
agent.sources.s.batchSize = 100
agent.sources.s.channels = c


# Each sink's type must be defined
agent.sinks.r.type = asynchbase
agent.sinks.r.table = car_table
agent.sinks.r.columnFamily = lte
agent.sinks.r.batchSize = 100
agent.sinks.r.serializer = com.ncc.dlut.AsyncHbaseLTEEventSerializer
agent.sinks.r.serializer.columns = cid,time,pci,st,ed,ta,lng,lat

#Specify the channel the sink should use
agent.sinks.r.channel = c

# Each channel's type is defined.
agent.channels.c.type = memory
agent.channels.c.capacity = 1000

 https://blog.csdn.net/yaoyasong/article/details/39400829

1.      首先开启Tomcat中的日志记录功能，并选择combined格式。

修改TOMCAT_PATH/conf/server.xml，增加日志记录：

<Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"

               prefix="localhost_access_log." suffix=".txt" renameOnRotate="true"

               pattern="combined" />

这样，tomcat就会在logs目录下每天生成localhost_access_log文件并实时记录用户的访问情况。
 

public class AsyncHbaseLogEventSerializer implements AsyncHbaseEventSerializer{
      private byte[] table;
      private byte[] colFam;
      private Event currentEvent;
      private byte[][] columnNames;
      private final List<PutRequest> puts = new ArrayList<PutRequest>();
      private final List<AtomicIncrementRequest> incs = new ArrayList<AtomicIncrementRequest>();
      private byte[] currentRowKey;
      private final byte[] eventCountCol = "eventCount".getBytes();
      public void initialize(byte[] table, byte[] cf) {
               this.table = table;
               this.colFam = cf;
      }
      public void configure(Context context) {
               String cols = new String(context.getString("columns"));
               String[] names = cols.split(",");
               columnNames = new byte[names.length][];              
               int i = 0;
               for (String name : names) {
                         columnNames[i++] = name.getBytes();
               }
      }
      public void configure(ComponentConfiguration conf) {
      }
      public List<PutRequest> getActions() {
               // Split the event body and get the values for the columns
               String eventStr = new String(currentEvent.getBody());
               String[] cols = logTokenize(eventStr);
               puts.clear();
               String req = cols[4];
               String reqPath = req.split(" ")[1];
               int pos = reqPath.indexOf("?");
        if (pos > 0) {
              reqPath = reqPath.substring(0,pos);
        }       
        if(reqPath.length() > 1 && reqPath.trim().endsWith("/")){
              reqPath = reqPath.substring(0,reqPath.length()-1);
        }       
        String req_ts_str = cols[3];
        Long currTime = System.currentTimeMillis();
        String currTimeStr = null;
        if (req_ts_str != null && !req_ts_str.equals("")){
                         SimpleDateFormat df = new SimpleDateFormat("dd/MMM/yyyy:HH:mm:ss",Locale.US);
                         SimpleDateFormat df2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                         try {
                                  currTimeStr = df2.format(df.parse(req_ts_str));
                                  currTime = df.parse(req_ts_str).getTime();
                         } catch (ParseException e) {
                                  System.out.println("parse req time error,using system.current time.");
                         }
               }
        long revTs = Long.MAX_VALUE - currTime;
        currentRowKey = (Long.toString(revTs) + reqPath).getBytes();
        System.out.println("currentRowKey: " + new String(currentRowKey));       
               for (int i = 0; i < cols.length; i++){
                         PutRequest putReq = new PutRequest(table, currentRowKey, colFam, columnNames[i], cols[i].getBytes());
                         puts.add(putReq);
               }
               //增加列
               PutRequest reqPathPutReq = new PutRequest(table, currentRowKey, colFam, "req_path".getBytes(), reqPath.getBytes());
               puts.add(reqPathPutReq);              
               PutRequest reqTsPutReq = new PutRequest(table, currentRowKey, colFam, "req_ts".getBytes(), Bytes.toBytes(currTimeStr));
               puts.add(reqTsPutReq);              
               String channelType = ChannelUtil.getType(cols[8]);
               PutRequest channelPutReq = new PutRequest(table, currentRowKey, colFam, "req_chan".getBytes(), Bytes.toBytes(channelType));
               puts.add(channelPutReq);              
               return puts;
      } 
      public String[] logTokenize(String eventStr) {
               String logEntryPattern = "^([\\d.]+) (\\S+) (\\S+) \\[([\\w:/]+\\s[+\\-]\\d{4})\\] \"(.+?)\" (\\d{3}) (\\d+|-) \"([^\"]+)\" \"([^\"]+)\"";
        Pattern p = Pattern.compile(logEntryPattern);
        Matcher matcher = p.matcher(eventStr); 
        if (!matcher.matches())
        {
            System.err.println("Bad log entry (or problem with RE?):");
            System.err.println(eventStr);
            return null;
        }
        String[] columns = new String[matcher.groupCount()];       
        for (int i = 0; i < matcher.groupCount(); i++)
        {
            columns[i] = matcher.group(i+1);
        }
        return columns;
      } 
      public List<AtomicIncrementRequest> getIncrements() {
               incs.clear();
               incs.add(new AtomicIncrementRequest(table, "totalEvents".getBytes(), colFam, eventCountCol));
               return incs;
      }
      public void setEvent(Event event) {
               this.currentEvent = event;
      }
      public void cleanUp() {
               table = null;
               colFam = null;
               currentEvent = null;
               columnNames = null;
               currentRowKey = null;
      }

 

四月天03
关注
专栏目录
大数据技术应用(一) 应用Flume+HBase采集和存储日志数据
08-11
NULL 博文链接：https://kavy.iteye.com/blog/2228079
应用Flume+HBase采集和存储日志数据
weixin_33875839的博客
12-01 231
1. 在本方案中，我们要将数据存储到HBase中，所以使用flume中提供的hbase sink，同时，为了清洗转换日志数据，我们实现自己的AsyncHbaseEventSerializer。 package com.ncc.dlut; import java.io.UnsupportedEncodingException; import java.util.ArrayList; im...
java flume hbase_应用Flume+HBase采集和存储日志数据
weixin_42451611的博客
02-24 137
packagecom.ncc.dlut;importjava.io.UnsupportedEncodingException;importjava.util.ArrayList;importjava.util.List;importorg.apache.flume.Context;importorg.apache.flume.Event;importorg.apache.flume.conf.Co...
flume --收集日志到hbase中
suojie的博客
01-21 333
a1.sources = s1 a1.channels = c1 a1.sinks = k1 #tcp协议 a1.sources.s1.type = syslogtcp a1.sources.s1.port = 5140 a1.sources.s1.host = wangfutai a1.sources.s1.channels = c1 #channel a1.channels.c1.typ...
flume-ng 日志收集到hbase
wuguangxue255的专栏
09-15 1229
flume-ng  收集日志 1：设计架构图如下。 根据日志模块的量级，以及解析复杂性，决定是否设置loadbalance，实现负载均衡和failover 2：client-agent 设计 （1）使用tail -F 实时收集固定文件名的日志  （2）对于文件名会变化的日志文件使用log4jappender直接转为avro 3：server端设计 使用sinkgroup设置多个处
Flume+hbase 日志数据采集与存储
cn_yaojin
02-15 704
原文的地址：https://www.cnblogs.com/re-myself/p/5180249.html 了解过flume的人，差不多都看过这张或则类似的图片，本文即实现上图部分内容。（由于条件有限，目前是单机上实现） flume-agent配置文件 #flume agent conf source_agent.sources = server source_agen...
Hadoop+Spark+Hive+HBase+Oozie+Kafka+Flume+Flink+ES+Redash等详细安装部署
06-22
配置Flume涉及定义source、sink和channel，以实现数据流动。 Flink是另一种高性能的流处理框架，它在低延迟和状态管理方面有出色表现。Flink可以与Kafka集成，实现实时数据处理。 Elasticsearch是一个实时的分布式...
Flume+Kafka+HBase实例
01-11
Flume通过配置多个source、channel和sink，可以灵活地构建数据传输管道，确保数据的稳定流动。 Kafka是Apache的另一个开源项目，它是一个高吞吐量的分布式消息系统，常被用作实时数据流平台。在电信客服项目中，...
16：Flume+HBase+Kafka集成开发.rar
最新发布
03-08
在大数据处理领域，Flume、Kafka和HBase是三个重要的组件，它们分别扮演着数据收集、消息中间件和分布式存储的角色。本章节我们将深入探讨这三个工具如何集成以实现高效的数据流动与处理。 Flume是Apache的一个开源...
flume-ng整合hbase
11-16
Flume可以和许多的系统进行整合，包括了Hadoop、Spark、Kafka、Hbase等等；当然，强悍的Flume也是可以和Mysql进行整合，将分析好的日志存储到Mysql（当然，你也可以存放到pg、oracle等等关系型数据库）。
大数据篇：flume+kafka+spark stream+hbase做日志收集
热门推荐
yycc
06-30 1万+
flume+kafka+spark stream+hbase做日志收集 前言 flume+kafka+spark stream 是目前比较常用的一套大数据消息日志收集管理框架，至于最后是入到Hive或者者Hbase需看不同业务场景，下面以HBase为场景简述下整个配置与搭建流程以及这些框架如此搭配的优点。 flume+kafka+spark stream+hbase做日志收集...
flume mysql hbase_Flume+hbase 日志数据采集与存储
weixin_30089411的博客
02-15 153
了解过flume的人，差不多都看过这张或则类似的图片，本文即实现上图部分内容。(由于条件有限，目前是单机上实现)flume-agent配置文件#flume agent confsource_agent.sources=serversource_agent.sinks=avroSinksource_agent.channels=memoryChannelsource_agent.sources.se...
flume mysql hbase_【flume】5.采集日志进入hbase
weixin_29649047的博客
02-15 144
设置我们的flume配置信息# Licensed to the Apache Software Foundation (ASF) under one# or more contributor license agreements. See the NOTICE file# distributed withthis work foradditional information# regarding...
flume+hbase+kafka集成部署
梦想天空
09-10 1122
目录 一、架构图 二、flume的安装和配置 1. 下载安装 2. 配置 2.1 日志收集节点配置 2.2 日志聚集节点配置 2.3 Flume的二次开发 三、模拟程序开发 四、服务启动测试 1. 服务启动 1.1 zookeeper 1.2 HDFS 1.3 Hbase 1.4 kafka 2. 测试 Flume是一个高可用的，高可靠的，分布式的海量日志采集、聚合...
Flume-ng+Hbase实现日志的收集和存储
Mr.Lin的博客
07-31 5278
1.前提条件 Hadoop+HBase+Zookeeper+Flume-ng 2.解析日志程序 ①AccessLog.java package com.tcloud.flume; public class AccessLog { private String clientIp;     private String clientIndentity;     priv
flume 多个source sinks channel 配置记录
chenzhenguo
11-28 1049
a1.sources = r1 r2 a1.sinks = k1 k2 a1.channels = c1 c2 ##### source a1.sources.r1.type =spooldir a1.sources.r1.spoolDir=/urldata/t_url/ ##a1.sources.r1.fileSuffix = .COMPLETED ##设置删除 a1.s...
Hadoop hive sqoop zookeeper hbase生产环境日志统计应用案例（故障篇）
weixin_34115824的博客
11-04 236
6、问题及解决方案1. 问题描述：WARN util.NativeCodeLoader: Unable to load native-hadoop library foryour platform… using builtin-java classes where applicable问题原因：默认lib为32位,不支持64位。解决办法：重新编译64位库 - 请注意在jdk1...
Flume+Kafka+Hbase集成配置
05-14
Flume、Kafka和HBase都是大数据领域常用的组件，它们可以很好地协同工作来实现数据的实时采集、传输和存储。下面是它们的集成配置。 1. 安装Flume Flume是Apache基金会下的分布式、可靠、高可用的海量日志采集、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

四月天03

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

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

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

打赏作者

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

抵扣说明：

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

余额充值