大数据 --- Flume

概述

      Flume 是 Cloudera 提供的一个高可用的，高可靠的，分布式的海量日志采集、聚合和传输的软件。

      Flume 的核心是把数据从数据源 (source) 收集过来，再将收集到的数据送到 指定的目的地 (sink) 。为了保证输送的过程一定成功，在送到目的地 (sink) 之前， 会先缓存数据 (channel) ,待数据真正到达目的地 (sink) 后，flume 在删除自己缓 存的数据。

      Flume 支持定制各类数据发送方，用于收集各类型数据；同时，Flume 支持 定制各种数据接受方，用于最终存储数据。一般的采集需求，通过对 flume 的简 单配置即可实现。针对特殊场景也具备良好的自定义扩展能力。因此，flume 可 以适用于大部分的日常数据采集场景。

      当前 Flume 有两个版本。Flume 0.9X 版本的统称 Flume OG（original generation），Flume1.X 版本的统称 Flume NG（next generation）。由于 Flume NG 经过核心组件、核心配置以及代码架构重构，与 Flume OG 有很大不同，使用时请注意区分。改动的另一原因是将 Flume 纳入 apache 旗下，Cloudera Flume 改名为 Apache Flume。

官网:http://flume.apache.org/

运行机制

      Flume 系统中核心的角色是 agent，agent 本身是一个 Java 进程，一般运行在日志收集节点。

      每一个 agent 相当于一个数据传递员，内部有三个组件： Source、Channel、Sink

      Source：采集源，用于跟数据源对接，以获取数据,包括avro、thrift、exec、jms、spooling directory、netcat、syslog、http、legacy

      备注：

       Avro:apache 的一个子项目

       Thrift:Facebook开源的一个RPC框架

      Sink：下沉地，采集数据的传送目的，用于往下一级 agent 传递数据或者往 最终存储系统传递数据Sink组件目的地包括hdfs、logger、avro、thrift、ipc、file、null、HBase、solr、自定义。

      Channel：agent 内部的数据传输通道，用于从 source 将数据传递到 sink。

      在整个数据的传输的过程中，流动的是 event，它是 Flume 内部数据传输的 最基本单元。event 将传输的数据进行封装。如果是文本文件，通常是一行记录， event 也是事务的基本单位。event 从 source，流向 channel，再到 sink，本身 为一个字节数组，并可携带 headers(头信息) 信息。event 代表着一个数据的最 小完整单元，从外部数据源来，向外部的目的地去。

      一个完整的 event 包括：event headers、event body、event 信息，其中 event 信息就是 flume 收集到的日记记录。

      Flume自带两种 Channel：Memory Channel 和 File Channel。

      Memory Channel 是内存中的队列。Memory Channel 在不需要关心数据丢失的情景下适用。如果需要关系数据丢失，那么 Memory Channel 就不应该使用，因为程序死亡、机器宕机或者重启都会导致数据丢失。

      File Channel将所有事件写到磁盘。因此在程序关闭或机器宕机的情况下不会丢失数据。

Flume 采集系统架构图

1. 简单结构
   单个 agent 采集数据
   
   多个串联
   

2. 复杂的结构
   
   
   

Flume 安装部署

1. 上传安装包到数据源所在节点上，解压 tar -zxvf apache-flume-1.8.0-bin.tar.gz 。
2. 然后进入 flume 的目录，修改 conf 下的 flume-env.sh，在里面配置 JAVA_HOME。
3. 根据数据采集需求配置采集方案，描述在配置文件中(文件名可任意自定义)
4. 指定采集方案配置文件，在相应的节点上启动 flume agent。

Flume的简单案例

• 接收 netcat 端口数据，在控制台打印。

  1. 先在 flume 的 conf 目录下新建一个文件
     vim netcat-logger.conf

     # 定义这个 agent 中各组件的名字 
     a1.sources = r1 
     a1.sinks = k1 
     a1.channels = c1 
     # 描述和配置 source 组件r1
     a1.sources.r1.type = netcat 
     a1.sources.r1.bind = localhost 
     a1.sources.r1.port = 44444 
     # 描述和配置 sink 组件：k1 
     a1.sinks.k1.type = logger 
     # 描述和配置 channel 组件，此处使用是内存缓存的方式 
     a1.channels.c1.type = memory 
     a1.channels.c1.capacity = 1000 
     a1.channels.c1.transactionCapacity = 100
     # 描述和配置 source channel sink 之间的连接关系 
     a1.sources.r1.channels = c1 
     a1.sinks.k1.channel = c1
     

  2. 启动 agent 去采集数据：

     bin/flume-ng agent -c conf -f conf/netcat-logger.conf -n a1 -	Dflume.root.logger=INFO,console
     

     -c conf 指定 flume 自身的配置文件所在目录
     -f conf/netcat-logger.con 指定我们所描述的采集方案
     -n a1 指定我们这个 agent 的名字

  3. 测试

           先要往 agent 采集监听的端口上发送数据，让 agent 有数据可采。 随便在一个能跟 agent 节点联网的机器上：

           nc localhost 44444

• 采集目录到 HDFS
  采集需求：

        服务器的某特定目录下，会不断产生新的文件，每当有新文件出现， 就需要把文件采集到 HDFS 中去

        根据需求，首先定义3大要素

  1. 采集源头 即 source——监控文件目录 : spooldir。
  2. 下沉目标，即 sink——HDFS 文件系统 : hdfs sink。
  3. source 和 sink 之间的传递通道——channel，可用 file channel 也可以用 内存 channel。

  配置文件编写
  vim dirToHDFS.conf

  # Name the components on this agent 
  a1.sources = r1 
  a1.sinks = k1
  a1.channels = c1
  # Describe/configure the source
   ##注意：不能往监控目中重复丢同名文件 
  a1.sources.r1.type = spooldir 
  a1.sources.r1.spoolDir = /root/logs 
  a1.sources.r1.fileHeader = true
  # Describe the sink 
  a1.sinks.k1.type = hdfs 
  a1.sinks.k1.hdfs.path = /flume/events/%y-%m-%d/%H%M/ a1.sinks.k1.hdfs.filePrefix = events
  a1.sinks.k1.hdfs.round = true 
  a1.sinks.k1.hdfs.roundValue = 10 
  a1.sinks.k1.hdfs.roundUnit = minute
  a1.sinks.k1.hdfs.rollInterval = 3 
  a1.sinks.k1.hdfs.rollSize = 20 
  a1.sinks.k1.hdfs.rollCount = 5
  a1.sinks.k1.hdfs.batchSize = 1 
  a1.sinks.k1.hdfs.useLocalTimeStamp = true
  #生成的文件类型，默认是 Sequencefile可用 DataStream，则为普通文本 a1.sinks.k1.hdfs.fileType = DataStream 
  
  # Use a channel which buffers events in memory 
  a1.channels.c1.type = memory 
  a1.channels.c1.capacity = 1000 
  a1.channels.c1.transactionCapacity = 100
  
  # Bind the source and sink to the channel 
  a1.sources.r1.channels = c1
  a1.sinks.k1.channel = c1
  

  Channel 参数解释：
  capacity：默认该通道中最大的可以存储的 event 数量
  trasactionCapacity：每次最大可以从 source 中拿到或者送到 sink 中的 event 数量
  启动flume

  bin/flume-ng agent -c conf -f conf/dirToHDFS.conf  -n a1 -Dflume.root.logger=INFO,console
  

• 采集文件到 HDFS
  采集需求：

        比如业务系统使用 log4j 生成的日志，日志内容不断增加，需要把追 加到日志文件中的数据实时采集到 hdfs。

        根据需求，首先定义3大要素

  1. 采集源，即 source——监控文件内容更新 : exec ‘tail -F file’
  2. 下沉目标，即 sink——HDFS 文件系统 : hdfs sink
  3. source 和 sink 之间的传递通道——channel，可用 file channel 也可以用 内存 channel。

  配置文件编写

  # Name the components on this agent
  a1.sources = r1
  a1.sinks = k1 
  a1.channels = c1
  # Describe/configure the source
  a1.sources.r1.type = exec 
  a1.sources.r1.command = tail -F /root/logs/test.log a1.sources.r1.channels = c1
  # Describe the sink
  a1.sinks.k1.type = hdfs
  a1.sinks.k1.hdfs.path = /flume/tailout/%y-%m-%d/%H%M/ a1.sinks.k1.hdfs.filePrefix = events
  a1.sinks.k1.hdfs.round = true 
  a1.sinks.k1.hdfs.roundValue = 10 
  a1.sinks.k1.hdfs.roundUnit = minute 
  a1.sinks.k1.hdfs.rollInterval = 3 
  a1.sinks.k1.hdfs.rollSize = 20 
  a1.sinks.k1.hdfs.rollCount = 5
  a1.sinks.k1.hdfs.batchSize = 1 
  a1.sinks.k1.hdfs.useLocalTimeStamp = true
  
  #生成的文件类型，默认是 Sequencefile，可用 DataStream，则为普通文本
  a1.sinks.k1.hdfs.fileType = DataStream
  # Use a channel which buffers events in memory
  a1.channels.c1.type = memory 
  a1.channels.c1.capacity = 1000 
  a1.channels.c1.transactionCapacity = 100
  
  
  # Bind the source and sink to the channel
  a1.sources.r1.channels = c1
  a1.sinks.k1.channel = c1
  

Flume自定义MySQLSource

自定义Source说明

      Source是负责接收数据到Flume Agent的组件。Source组件可以处理各种类型、各种格式的日志数据，包括avro、thrift、exec、jms、spooling directory、netcat、sequence generator、syslog、http、legacy。官方提供的source类型已经很多，但是有时候并不能满足实际开发当中的需求，此时我们就需要根据实际需求自定义某些Source。

      如：实时监控MySQL，从MySQL中获取数据传输到HDFS或者其他存储框架，所以此时需要我们自己实现MySQLSource。

      官方也提供了自定义source的接口：

      官网说明：https://flume.apache.org/FlumeDeveloperGuide.html#source

自定义MySQLSource组成

自定义 MySQLSource步骤

      根据官方说明自定义 MySqlSource 需要继承 AbstractSource 类并实现 Configurable 和 PollableSource 接口。 实现相应方法：

getBackOffSleepIncrement()//暂不用
getMaxBackOffSleepInterval()//暂不用
configure(Context context)//初始化context

      process()//获取数据（从 MySql 获取数据，业务处理比较复杂，所以我们定义一个专门的类—— SQLSourceHelper 来处理跟 MySql 的交互），封装成 Event 并写入 Channel ，这个方法被循环调用

stop()//关闭相关的资源

代码实现

导入 POM 依赖

<dependencies>
    <dependency>
        <groupId>org.apache.flume</groupId>
        <artifactId>flume-ng-core</artifactId>
        <version>1.7.0</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.27</version>
    </dependency>
</dependencies>

添加配置信息

在 ClassPath 下添加 jdbc.properties 和 log4j. properties
jdbc.properties:

dbDriver=com.mysql.jdbc.Driver
dbUrl=jdbc:mysql://hadoop102:3306/mysqlsource?useUnicode=true&characterEncoding=utf-8
dbUser=root
dbPassword=000000

log4j. properties:

#--------console-----------
log4j.rootLogger=info,myconsole,myfile
log4j.appender.myconsole=org.apache.log4j.ConsoleAppender
log4j.appender.myconsole.layout=org.apache.log4j.SimpleLayout
#log4j.appender.myconsole.layout.ConversionPattern =%d [%t] %-5p 	[%c] - %m%n

#log4j.rootLogger=error,myfile
log4j.appender.myfile=org.apache.log4j.DailyRollingFileAppender
log4j.appender.myfile.File=/tmp/flume.log
log4j.appender.myfile.layout=org.apache.log4j.PatternLayout
log4j.appender.myfile.layout.ConversionPattern =%d [%t] %-5p [%c] - %m%n

SQLSourceHelper

1. 属性说明：

   属性	说明（括号中为默认值）

   |
   runQueryDelay | 查询时间间隔（10000）|
   | batchSize| 缓存大小（100）|
   | startFrom| 查询语句开始id（0）|
   | currentIndex| 查询语句当前id，每次查询之前需要查元数据表|
   | recordSixe |查询返回条数|
   | table |监控的表名|
   | columnsToSelect| 查询字段（*）|
   | customQuery |用户传入的查询语句|
   | query |查询语句|
   | defaultCharsetResultSet| 编码格式（UTF-8）|

2. 方法说明：

   方法	说明
   SQLSourceHelper(Context context)	构造方法，初始化属性及获取JDBC连接
   InitConnection(String url, String user, String pw)	获取JDBC连接
   checkMandatoryProperties()	校验相关属性是否设置（实际开发中可增加内容）
   buildQuery()	根据实际情况构建sql语句，返回值String
   executeQuery()	执行sql语句的查询操作，返回值List<List>
   getAllRows(List<List> queryResult)	将查询结果转换为String，方便后续操作
   updateOffset2DB(int size)	根据每次查询结果将offset写入元数据表
   execSql(String sql)	具体执行sql语句方法
   getStatusDBIndex(int startFrom)	获取元数据表中的offset
   queryOne(String sql)	获取元数据表中的offset实际sql语句执行方法
   close()	关闭资源

3. 代码分析
   

4. 代码实现

   import org.apache.flume.Context;
   import org.apache.flume.conf.ConfigurationException;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   
   import java.io.IOException;
   import java.sql.*;
   import java.text.ParseException;
   import java.util.ArrayList;
   import java.util.List;
   import java.util.Properties;
   
   public class SQLSourceHelper {
   
       private static final Logger LOG = LoggerFactory.getLogger(SQLSourceHelper.class);
   
       private int runQueryDelay, //两次查询的时间间隔
               startFrom,            //开始id
               currentIndex,	        //当前id
               recordSixe = 0,      //每次查询返回结果的条数
               maxRow;                //每次查询的最大条数
   
       private String table,       //要操作的表
               columnsToSelect,     //用户传入的查询的列
               customQuery,          //用户传入的查询语句
               query,                 //构建的查询语句
               defaultCharsetResultSet;//编码集
   
       //上下文，用来获取配置文件
       private Context context;
   
       //为定义的变量赋值（默认值），可在flume任务的配置文件中修改
       private static final int DEFAULT_QUERY_DELAY = 10000;
       private static final int DEFAULT_START_VALUE = 0;
       private static final int DEFAULT_MAX_ROWS = 2000;
       private static final String DEFAULT_COLUMNS_SELECT = "*";
       private static final String DEFAULT_CHARSET_RESULTSET = "UTF-8";
   
       private static Connection conn = null;
       private static PreparedStatement ps = null;
       private static String connectionURL, connectionUserName, connectionPassword;
   
       //加载静态资源
   static {
   
           Properties p = new Properties();
   
           try {
               p.load(SQLSourceHelper.class.getClassLoader().getResourceAsStream("jdbc.properties"));
               connectionURL = p.getProperty("dbUrl");
               connectionUserName = p.getProperty("dbUser");
               connectionPassword = p.getProperty("dbPassword");
               Class.forName(p.getProperty("dbDriver"));
   
           } catch (IOException | ClassNotFoundException e) {
               LOG.error(e.toString());
           }
       }
   
       //获取JDBC连接
       private static Connection InitConnection(String url, String user, String pw) {
           try {
   
               Connection conn = DriverManager.getConnection(url, user, pw);
   
               if (conn == null)
                   throw new SQLException();
   
               return conn;
   
           } catch (SQLException e) {
               e.printStackTrace();
           }
   
           return null;
       }
   
       //构造方法
   SQLSourceHelper(Context context) throws ParseException {
   
           //初始化上下文
           this.context = context;
   
           //有默认值参数：获取flume任务配置文件中的参数，读不到的采用默认值
           this.columnsToSelect = context.getString("columns.to.select", DEFAULT_COLUMNS_SELECT);
   
           this.runQueryDelay = context.getInteger("run.query.delay", DEFAULT_QUERY_DELAY);
   
           this.startFrom = context.getInteger("start.from", DEFAULT_START_VALUE);
   
           this.defaultCharsetResultSet = context.getString("default.charset.resultset", DEFAULT_CHARSET_RESULTSET);
   
           //无默认值参数：获取flume任务配置文件中的参数
           this.table = context.getString("table");
           this.customQuery = context.getString("custom.query");
   
           connectionURL = context.getString("connection.url");
   
           connectionUserName = context.getString("connection.user");
   
           connectionPassword = context.getString("connection.password");
   
           conn = InitConnection(connectionURL, connectionUserName, connectionPassword);
   
           //校验相应的配置信息，如果没有默认值的参数也没赋值，抛出异常
           checkMandatoryProperties();
   
           //获取当前的id
           currentIndex = getStatusDBIndex(startFrom);
   
           //构建查询语句
           query = buildQuery();
       }
   
       //校验相应的配置信息（表，查询语句以及数据库连接的参数）
   private void checkMandatoryProperties() {
   
           if (table == null) {
               throw new ConfigurationException("property table not set");
           }
   
           if (connectionURL == null) {
               throw new ConfigurationException("connection.url property not set");
           }
   
           if (connectionUserName == null) {
               throw new ConfigurationException("connection.user property not set");
           }
   
           if (connectionPassword == null) {
               throw new ConfigurationException("connection.password property not set");
           }
       }
   
       //构建sql语句
   private String buildQuery() {
   
           String sql = "";
   
           //获取当前id
           currentIndex = getStatusDBIndex(startFrom);
           LOG.info(currentIndex + "");
   
           if (customQuery == null) {
               sql = "SELECT " + columnsToSelect + " FROM " + table;
           } else {
               sql = customQuery;
           }
   
           StringBuilder execSql = new StringBuilder(sql);
   
           //以id作为offset
           if (!sql.contains("where")) {
               execSql.append(" where ");
               execSql.append("id").append(">").append(currentIndex);
   
               return execSql.toString();
           } else {
               int length = execSql.toString().length();
   
               return execSql.toString().substring(0, length - String.valueOf(currentIndex).length()) + currentIndex;
           }
       }
   
       //执行查询
   List<List<Object>> executeQuery() {
   
           try {
               //每次执行查询时都要重新生成sql，因为id不同
               customQuery = buildQuery();
   
               //存放结果的集合
               List<List<Object>> results = new ArrayList<>();
   
               if (ps == null) {
                   //
                   ps = conn.prepareStatement(customQuery);
               }
   
               ResultSet result = ps.executeQuery(customQuery);
   
               while (result.next()) {
   
                   //存放一条数据的集合（多个列）
                   List<Object> row = new ArrayList<>();
   
                   //将返回结果放入集合
                   for (int i = 1; i <= result.getMetaData().getColumnCount(); i++) {
                       row.add(result.getObject(i));
                   }
   
                   results.add(row);
               }
   
               LOG.info("execSql:" + customQuery + "\nresultSize:" + results.size());
   
               return results;
           } catch (SQLException e) {
               LOG.error(e.toString());
   
               // 重新连接
               conn = InitConnection(connectionURL, connectionUserName, connectionPassword);
   
           }
   
           return null;
       }
   
       //将结果集转化为字符串，每一条数据是一个list集合，将每一个小的list集合转化为字符串
   List<String> getAllRows(List<List<Object>> queryResult) {
   
           List<String> allRows = new ArrayList<>();
   
           if (queryResult == null || queryResult.isEmpty())
               return allRows;
   
           StringBuilder row = new StringBuilder();
   
           for (List<Object> rawRow : queryResult) {
   
               Object value = null;
   
               for (Object aRawRow : rawRow) {
   
                   value = aRawRow;
   
                   if (value == null) {
                       row.append(",");
                   } else {
                       row.append(aRawRow.toString()).append(",");
                   }
               }
   
               allRows.add(row.toString());
               row = new StringBuilder();
           }
   
           return allRows;
       }
   
       //更新offset元数据状态，每次返回结果集后调用。必须记录每次查询的offset值，为程序中断续跑数据时使用，以id为offset
       void updateOffset2DB(int size) {
           //以source_tab做为KEY，如果不存在则插入，存在则更新（每个源表对应一条记录）
           String sql = "insert into flume_meta(source_tab,currentIndex) VALUES('"
                   + this.table
                   + "','" + (recordSixe += size)
                   + "') on DUPLICATE key update source_tab=values(source_tab),currentIndex=values(currentIndex)";
   
           LOG.info("updateStatus Sql:" + sql);
   
           execSql(sql);
       }
   
       //执行sql语句
   private void execSql(String sql) {
   
           try {
               ps = conn.prepareStatement(sql);
   
               LOG.info("exec::" + sql);
   
               ps.execute();
           } catch (SQLException e) {
               e.printStackTrace();
           }
       }
   
       //获取当前id的offset
   private Integer getStatusDBIndex(int startFrom) {
   
           //从flume_meta表中查询出当前的id是多少
           String dbIndex = queryOne("select currentIndex from flume_meta where source_tab='" + table + "'");
   
           if (dbIndex != null) {
               return Integer.parseInt(dbIndex);
           }
   
           //如果没有数据，则说明是第一次查询或者数据表中还没有存入数据，返回最初传入的值
           return startFrom;
       }
   
       //查询一条数据的执行语句(当前id)
   private String queryOne(String sql) {
   
           ResultSet result = null;
   
           try {
               ps = conn.prepareStatement(sql);
               result = ps.executeQuery();
   
               while (result.next()) {
                   return result.getString(1);
               }
           } catch (SQLException e) {
               e.printStackTrace();
           }
   
           return null;
       }
   
       //关闭相关资源
   void close() {
   
           try {
               ps.close();
               conn.close();
           } catch (SQLException e) {
               e.printStackTrace();
           }
       }
   
       int getCurrentIndex() {
           return currentIndex;
       }
   
       void setCurrentIndex(int newValue) {
           currentIndex = newValue;
       }
   
       int getRunQueryDelay() {
           return runQueryDelay;
       }
   
       String getQuery() {
           return query;
       }
   
       String getConnectionURL() {
           return connectionURL;
       }
   
       private boolean isCustomQuerySet() {
           return (customQuery != null);
       }
   
       Context getContext() {
           return context;
       }
   
       public String getConnectionUserName() {
           return connectionUserName;
       }
   
       public String getConnectionPassword() {
           return connectionPassword;
       }
   
       String getDefaultCharsetResultSet() {
           return defaultCharsetResultSet;
       }
   }
   
   

MySQLSource

代码实现：

import java.text.ParseException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class SQLSource extends AbstractSource implements Configurable, PollableSource {

    //打印日志
private static final Logger LOG = LoggerFactory.getLogger(SQLSource.class);

    //定义sqlHelper
    private SQLSourceHelper sqlSourceHelper;


    @Override
    public long getBackOffSleepIncrement() {
        return 0;
    }

    @Override
    public long getMaxBackOffSleepInterval() {
        return 0;
    }

    @Override
public void configure(Context context) {

        try {
            //初始化
            sqlSourceHelper = new SQLSourceHelper(context);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    @Override
public Status process() throws EventDeliveryException {

        try {
            //查询数据表
            List<List<Object>> result = sqlSourceHelper.executeQuery();

            //存放event的集合
            List<Event> events = new ArrayList<>();

            //存放event头集合
            HashMap<String, String> header = new HashMap<>();

            //如果有返回数据，则将数据封装为event
            if (!result.isEmpty()) {

                List<String> allRows = sqlSourceHelper.getAllRows(result);

                Event event = null;

                for (String row : allRows) {
                    event = new SimpleEvent();
                    event.setBody(row.getBytes());
                    event.setHeaders(header);
                    events.add(event);
                }

                //将event写入channel
                this.getChannelProcessor().processEventBatch(events);

                //更新数据表中的offset信息
                sqlSourceHelper.updateOffset2DB(result.size());
            }

            //等待时长
            Thread.sleep(sqlSourceHelper.getRunQueryDelay());

            return Status.READY;
        } catch (InterruptedException e) {
            LOG.error("Error procesing row", e);

            return Status.BACKOFF;
        }
    }

    @Override
public synchronized void stop() {

        LOG.info("Stopping sql source {} ...", getName());

        try {
            //关闭资源
            sqlSourceHelper.close();
        } finally {
            super.stop();
        }
    }
}

测试

Jar 包归位

1. 将MySql驱动包放入Flume的lib目录下

   [atguigu@hadoop102 flume]$ cp \
   /opt/sorfware/mysql-libs/mysql-connector-java-5.1.27/mysql-connector-java-5.1.27-bin.jar \
   /opt/module/flume/lib/
   

   2. 打包项目并将 Jar 包放入 Flume 的 lib 包目录下。

配置文件归位

1. 创建配置文件并打开

   [atguigu@hadoop102 job]$ touch mysql.conf
   [atguigu@hadoop102 job]$ vim mysql.conf 
   

2. 添加如下内容

   # Name the components on this agent
   a1.sources = r1
   a1.sinks = k1
   a1.channels = c1
   
   # Describe/configure the source
   a1.sources.r1.type = com.bw.flume.SQLSource  
   a1.sources.r1.connection.url = jdbc:mysql://192.168.9.102:3306/mysqlsource
   a1.sources.r1.connection.user = root  
   a1.sources.r1.connection.password = 000000  
   a1.sources.r1.table = student  
   a1.sources.r1.columns.to.select = *  
   #a1.sources.r1.incremental.column.name = id  
   #a1.sources.r1.incremental.value = 0 
   a1.sources.r1.run.query.delay=5000
   
   # Describe the sink
   a1.sinks.k1.type = logger
   
   # Describe the channel
   a1.channels.c1.type = memory
   a1.channels.c1.capacity = 1000
   a1.channels.c1.transactionCapacity = 100
   
   # Bind the source and sink to the channel
   a1.sources.r1.channels = c1
   a1.sinks.k1.channel = c1
   

MySql 表归位

1. 创建MySqlSource数据库

   CREATE DATABASE mysqlsource；
   

2. 在MySqlSource数据库下创建数据表Student和元数据表Flume_meta

   CREATE TABLE `student` (
   `id` int(11) NOT NULL AUTO_INCREMENT,
   `name` varchar(255) NOT NULL,
   PRIMARY KEY (`id`)
   );
   CREATE TABLE `flume_meta` (
   `source_tab` varchar(255) NOT NULL,
   `currentIndex` varchar(255) NOT NULL,
   PRIMARY KEY (`source_tab`)
   );
   

3. 向表中添加数据

   1 zhangsan
   2 lisi
   3 wangwu
   4 zhaoliu
   

查看结果

1. 任务执行

   [atguigu@hadoop102 flume]$ bin/flume-ng agent --conf conf/ --name a1 \
   --conf-file job/mysql.conf -Dflume.root.logger=INFO,console
   

2. 结果展示

   

知识扩展（了解）

常见正则表达式语法

元字符	描述
^	匹配输入字符串的开始位置。如果设置了RegExp对象的Multiline属性，^也匹配“\n”或“\r”之后的位置。
$	匹配输入字符串的结束位置。如果设置了RegExp对象的Multiline属性，$也匹配“\n”或“\r”之前的位置。
*	匹配前面的子表达式任意次。例如，zo*能匹配“z”，“zo”以及“zoo”。*等价于{0,}。
+	匹配前面的子表达式一次或多次(大于等于1次）。例如，“zo+”能匹配“zo”以及“zoo”，但不能匹配“z”。+等价于{1,}。
[a-z]	字符范围。匹配指定范围内的任意字符。例如，“[a-z]”可以匹配“a”到“z”范围内的任意小写字母字符。注意:只有连字符在字符组内部时,并且出现在两个字符之间时,才能表示字符的范围; 如果出字符组的开头,则只能表示连字符本身.

企业真实面试题

你是如何实现Flume数据传输的监控的

使用第三方框架Ganglia实时监控Flume。

Flume 的 Source，Sink，Channel 的作用？你们 Source 是什么类型？

1. 作用

         Source 组件是专门用来收集数据的，可以处理各种类型、各种格式的日志数据，包括 avro、thrift、exec、jms、spooling directory、netcat、sequence generator、syslog、http、legacy

         Channel 组件对采集到的数据进行缓存，可以存放在 Memory 或 File 中。

      Sink 组件是用于把数据发送到目的地的组件，目的地包括 Hdfs、Logger、avro、thrift、ipc、file、Hbase、solr、自定义

2. 我公司采用的Source类型为：

      监控后台日志：exec

      监控后台产生日志的端口：netcat

Flume的Channel Selectors

Flume 参数调优

1. Source
   

         增加 Source 个（使用 Tair Dir Source 时可增加 FileGroups 个数）可以增大 Source 的读取数据的能力。例如：当某一个目录产生的文件过多时需要将这个文件目录拆分成多个文件目录，同时配置好多个 Source 以保证 Source 有足够的能力获取到新产生的数据。

         batchSize 参数决定 Source 一次批量运输到 Channel 的 event 条数，适当调大这个参数可以提高 Source 搬运 Event 到 Channel 时的性能。

2. Channel

         type 选择 memory 时 Channel 的性能最好，但是如果 Flume 进程意外挂掉可能会丢失数据。type 选择 file 时 Channel 的容错性更好，但是性能上会比 memory channel 差。

         使用 file Channel 时 dataDirs 配置多个不同盘下的目录可以提高性能。

         Capacity 参数决定 Channel 可容纳最大的event条数。transactionCapacity 参数决定每次 Source 往 channel 里面写的最大 event 条数和每次 Sink 从channel 里面读的最大 event 条数。 transactionCapacity 需要大于 Source 和 Sink 的 batchSize 参数。

3. Sink

         增加 Sink 的个数可以增加 Sink 消费 event 的能力。Sink 也不是越多越好够用就行，过多的 Sink 会占用系统资源，造成系统资源不必要的浪费。

          batchSize 参数决定 Sink 一次批量从 Channel 读取的 event 条数，适当调大这个参数可以提高 Sink 从 Channel 搬出 event 的性能。

Flume 的事务机制

       Flume 的事务机制（类似数据库的事务机制）：Flume 使用两个独立的事务分别负责从 Soucrce 到 Channel ，以及从 Channel 到 Sink 的事件传递。比如 spooling directory source 为文件的每一行创建一个事件，一旦事务中所有的事件全部传递到 Channel 且提交成功，那么 Soucrce 就将该文件标记为完成。同理，事务以类似的方式处理从 Channel 到 Sink 的传递过程，如果因为某种原因使得事件无法记录，那么事务将会回滚。且所有的事件都会保持到 Channel 中，等待重新传递。

Flume采集数据为什么不会丢失?

       Channel 存储可以存储在 File中，数据传输自身有事务。