flume1.9 用户指南（中文版）

概述

Apache Flume是一个分布式，可靠且可用的系统，用于有效地从许多不同的source收集，聚合和移动大量日志数据到集中式数据存储。

Apache Flume的使用不仅限于日志数据聚合。由于数据source是可定制的，因此Flume可用于传输大量event 数据，包括但不限于网络流量数据，社交媒体生成的数据，电子邮件消息以及几乎任何可能的数据source。

Apache Flume是Apache Software Foundation的顶级项目。

系统要求

1. Java运行时环境 - Java 1.8或更高版本
2. 内存 - 为source，channel或 sink 配置的内存
3. 磁盘空间 - channel或sink配置的磁盘空间
4. 目录权限 - agent使用的目录的读/写权限

架构

数据流模型

Flume event 被定义为具有字节有效负载和可选字符串属性集的数据流单元。Flume  agent 是一个（JVM）进程，它承载event 从外部source流向下一个目标（跃点）的组件。


Flume source消耗由外部 source（如Web服务器）传递给它的 event 。外部source以目标Flume source识别的格式向Flume发送event 。例如，Avro Flume source可用于从Avro客户端或从Avrosink发送event 的流中的其他Flume agent 接收Avroevent 。可以使用Thrift Flume Source定义类似的流程，以接收来自Thrift Sink或Flume Thrift Rpc客户端或Thrift客户端的event ，这些客户端使用Flume thrift协议生成的任何语言编写。当Flume source接收event 时，它将其存储到一个或多个channels 。该channel是一个被动存储器，可以保持event 直到它被Flume sink消耗。文件channel就是一个例子 - 它由本地文件系统支持。sink从channel中移除event 并将其放入外部存储库（如HDFS（通过Flume HDFS sink））或将其转发到流中下一个Flume agent （下一跳）的Flume source。给定 agent 中的source和sink与channel中暂存的event 异步运行。

复杂的流程

Flume允许用户构建多跳流，其中event 在到达最终目的地之前经过多个 agent 。它还允许fan-in 和fan-out，上下文路由和故障跳跃的备份路由（故障转移）。

可靠性

event 在每个 agent 的channel中进行。然后将event 传递到流中的下一个 agent 或终端存储库（如HDFS）。只有将event 存储在下一个 agent 的channel或终端存储库中后，才会从channel中删除这些event 。这就是Flume中的单跳消息传递语义如何提供流的端到端可靠性。

Flume使用事务方法来保证event 的可靠传递。source和sink分别在事务中封装由channel 提供的事务中放置或提供的event 的存储/检索。这可确保event 集在流中从一个点到另一个点可靠地传递。在多跳流的情况下，来自前一跳的sink和来自下一跳的source都运行其事务以确保数据安全地存储在下一跳的channel 中。

可恢复性

event 在channel中进行，该channel管理从故障中恢复。Flume支持由本地文件系统支持的持久文件channel。还有一个内存channel，它只是将event 存储在内存中的队列中，这更快，但是当 agent 进程死亡时仍然留在内存channel中的任何event 都无法恢复。

设置

设置 agent

Flume agent 配置存储在本地配置文件中。这是一个遵循Java属性文件格式的文本文件。可以在同一配置文件中指定一个或多个 agent 的配置。配置文件包括 agent 中每个source，sink和channel的属性以及它们如何连接在一起以形成数据流。

配置单个组件

流中的每个组件（source，sink或channel）都具有特定于类型和实例化的名称，类型和属性集。例如，Avrosource需要主机名（或IP地址）和端口号来接收数据。内存channel可以具有最大队列大小（“容量”），HDFS sink需要知道文件系统URI，创建文件的路径，文件轮换频率（“hdfs.rollInterval”）等。组件的所有此类属性需要在托管Flume agent 的属性文件中设置。

将各个部分连接在一起

agent 需要知道要加载哪些组件以及它们如何连接以构成流程。这是通过列出 agent 中每个source，sink和channel的名称，然后为每个sink和source指定连接channel来完成的。例如， agent 通过名为file-channel的文件channel将event 从名为avroWeb的Avrosource流向HDFS sink hdfs-cluster1。配置文件将包含这些组件的名称和文件channel，作为avroWebsource和hdfs-cluster1 sink的共享channel。

启动 agent

使用名为flume-ng的shell脚本启动 agent 程序，该脚本位于Flume发行版的bin目录中。您需要在命令行上指定 agent 名称，config目录和配置文件：

$ bin/flume-ng agent -n $agent_name -c conf -f conf/flume-conf.properties.template

现在， agent 将开始运行在给定属性文件中配置的source和sink。

一个简单的例子

在这里，我们给出一个示例配置文件，描述单节点Flume部署。此配置允许用户生成event ，然后将其记录到控制台。

# example.conf: A single-node Flume configuration
 
# Name the components on this agent
a1.sources = r1
a1.sinks = k1
a1.channels = c1
 
# Describe/configure the source
a1.sources.r1.type = netcat
a1.sources.r1.bind = localhost
a1.sources.r1.port = 44444
 
# Describe the sink
a1.sinks.k1.type = logger
 
# 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

此配置定义名为a1的单个 agent 。a1有一个监听端口44444上的数据的source，一个缓冲内存中event 数据的channel，以及一个将event 数据记录到控制台的sink。配置文件命名各种组件，然后描述其类型和配置参数。给定的配置文件可能会定义几个命名的 agent  当一个给定的Flume进程启动时，会传递一个标志，告诉它要显示哪个命名 agent。

鉴于此配置文件，我们可以按如下方式启动Flume：

$ bin/flume-ng agent --conf conf --conf-file example.conf --name a1 -Dflume.root.logger=INFO,console

请注意，在完整部署中，我们通常会包含一个选项： --conf=<conf-dir> 。所述  <conf-dir>  目录将包括一个shell 脚本f lume-env.sh 和潜在的一个log4j的属性文件。在这个例子中，我们传递一个Java选项来强制Flume登录到控制台，我们没有自定义环境脚本。

从一个单独的终端，我们可以telnet端口44444并向Flume发送一个event ：

$ telnet localhost 44444
Trying 127.0.0.1...
Connected to localhost.localdomain (127.0.0.1).
Escape character is '^]'.
Hello world! <ENTER>
OK

原始的Flume终端将在日志消息中输出event 。

12/06/19 15:32:19 INFO source.NetcatSource: Source starting
12/06/19 15:32:19 INFO source.NetcatSource: Created serverSocket:sun.nio.ch.ServerSocketChannelImpl[/127.0.0.1:44444]
12/06/19 15:32:34 INFO sink.LoggerSink: Event: { headers:{} body: 48 65 6C 6C 6F 20 77 6F 72 6C 64 21 0D          Hello world!. }

恭喜 - 您已成功配置并部署了Flume agent ！后续部分更详细地介绍了 agent 配置。

在配置文件中使用环境变量

Flume能够替换配置中的环境变量。例如：

a1.sources = r1
a1.sources.r1.type = netcat
a1.sources.r1.bind = 0.0.0.0
a1.sources.r1.port = ${NC_PORT}
a1.sources.r1.channels = c1

注意：它目前仅适用于values ，不适用于 keys 。 (Ie. only on the “right side” of the = mark of the config lines.)

通过设置propertiesImplementation = org.apache.flume.node.EnvVarResolverProperties，可以通过 agent 程序调用上的Java系统属性启用此功能。

例如：

$ NC_PORT=44444 bin/flume-ng agent –conf conf –conf-file example.conf –name a1 -Dflume.root.logger=INFO,console -DpropertiesImplementation=org.apache.flume.node.EnvVarResolverProperties

请注意，上面只是一个示例，可以通过其他方式配置环境变量，包括在 conf/flume-env.sh.

记录原始数据

在许多生产环境中记录流经摄取 pipeline 的原始数据流不是所希望的行为，因为这可能导致泄漏敏感数据或安全相关配置（例如密钥）泄漏到Flume日志文件。默认情况下，Flume不会记录此类信息。另一方面，如果数据管道被破坏，Flume将尝试提供调试DEBUG的线索。

调试event 管道问题的一种方法是设置 连接到Logger Sink的附加内存channel，它将所有event 数据输出到Flume日志。但是，在某些情况下，这种方法是不够的。

为了能够记录event 和配置相关的数据，除了log4j属性外，还必须设置一些Java系统属性。

要启用与配置相关的日志记录，请设置Java系统属性-Dorg.apache.flume.log.printconfig=true 。这可以在命令行上传递，也可以在flume-env.sh中的JAVA_OPTS变量中设置。

要启用数据记录，请 按照上述相同方式设置Java系统属性 -Dorg.apache.flume.log.rawdata=true 。对于大多数组件，还必须将log4j日志记录级别设置为DEBUG或TRACE，以使特定于event 的日志记录显示在Flume日志中。

下面是启用配置日志记录和原始数据日志记录的示例，同时还将Log4j日志级别设置为DEBUG以用于控制台输出：

$ bin/flume-ng agent --conf conf --conf-file example.conf --name a1 -Dflume.root.logger=DEBUG,console -Dorg.apache.flume.log.printconfig=true -Dorg.apache.flume.log.rawdata=true

基于Zookeeper的配置

Flume通过Zookeeper支持 agent 配置。这是一个实验性功能。配置文件需要在可配置前缀下的Zookeeper中上传。配置文件存储在Zookeeper节点数据中。以下是 agent 商a1和a2的Zookeeper节点树的外观

- /flume
 |- /a1 [Agent config file]
 |- /a2 [Agent config file]

上载配置文件后，使用以下选项启动 agent

$ bin/flume-ng agent –conf conf -z zkhost:2181,zkhost1:2181 -p /flume –name a1 -Dflume.root.logger=INFO,console

Argument Name	Default	Description
z	–	Zookeeper连接字符串。以逗号分隔的主机名列表：port
p	/flume	Zookeeper中的基本路径，用于存储 agent 配置

Flume拥有完全基于插件的架构。虽然Flume附带了许多开箱即用的 source，channels，sink，serializers 等，但许多实现都与Flume分开运行。安装第三方插件

虽然通过将自己的jar包添加到flume-env.sh文件中的FLUME_CLASSPATH变量中，始终可以包含自定义Flume组件，但Flume现在支持一个名为plugins.d的特殊目录，该目录会自动获取以特定格式打包的插件。这样可以更轻松地管理插件打包问题，以及更简单的调试和几类问题的故障排除，尤其是库依赖性冲突。

目录

该plugins.d 目录位于 $FLUME_HOME/plugins.d 。在启动时，flume-ng 启动脚本在plugins.d目录中查找符合以下格式的插件，并在启动java时将它们包含在正确的路径中。

插件的目录布局

plugins.d 中的每个插件（子目录）最多可以有三个子目录：

1. lib - the plugin’s jar(s)
2. libext - the plugin’s dependency jar(s)
3. native - any required native libraries, such as .so files

plugins.d目录中的两个插件示例：

plugins.d/
plugins.d/custom-source-1/
plugins.d/custom-source-1/lib/my-source.jar
plugins.d/custom-source-1/libext/spring-core-2.5.6.jar
 
plugins.d/custom-source-2/
plugins.d/custom-source-2/lib/custom.jar
plugins.d/custom-source-2/native/gettext.so 

数据摄取

Flume支持许多从外部来source摄取数据的机制。

RPC

Flume发行版中包含的Avro客户端可以使用avro RPC机制将给定文件发送到Flume Avrosource：

$ bin/flume-ng avro-client -H localhost -p 41414 -F /usr/logs/log.10

上面的命令会将 /usr/logs/log.10 的内容发送到监听该端口的Flume source。

执行命令

有一个exec source执行给定的命令并消耗输出。输出的单“行”   即。文本后跟回车符（'\ r'）或换行符（'\ n'）或两者一起。

网络流

Flume支持以下机制从常用日志流类型中读取数据，例如：

1. Avro
2. Thrift
3. Syslog
4. Netcat

设置多 agent 流程



为了跨多个 agent 或跳数据流，先前 agent 的sink和当前跳的source需要是avro类型，sink指向source的主机名（或IP地址）和端口。

合并

日志收集中非常常见的情况是大量日志生成客户端将数据发送到连接到存储子系统的少数消费者 agent 。例如，从数百个Web服务器收集的日志发送给写入HDFS集群的十几个 agent 。



这可以通过使用avrosink配置多个第一层 agent 在Flume中实现，所有这些 agent 都指向单个 agent 的avrosource（同样，您可以在这种情况下使用thriftsource/sink/客户端）。第二层 agent 上的此source将接收的event 合并到单个信道中，该信道由信宿器消耗到其最终目的地。

多路复用流程

Flume支持将event 流多路复用到一个或多个目的地。这是通过定义可以复制或选择性地将event 路由到一个或多个信道的流复用器来实现的。



上面的例子显示了来自 agent “foo”的source代码将流程扩展到三个不同的channel。扇出可以复制或多路复用。在复制流的情况下，每个event 被发送到所有三个channel。对于多路复用情况，当event 的属性与预配置的值匹配时，event 将被传递到可用channel的子集。例如，如果一个名为“txnType”的event 属性设置为“customer”，那么它应该转到channel1和channel3，如果它是“vendor”，那么它应该转到channel2，否则转到channel3。可以在 agent 的配置文件中设置映射。

配置

如前面部分所述，Flume agent 程序配置是从类似于具有分层属性设置的Java属性文件格式的文件中读取的.

定义流程

要在单个 agent 中定义流，您需要通过channel链接source和sink。您需要列出给定 agent 的source，sink和channel，然后将source和sink指向channel。source实例可以指定多个channel，但sink实例只能指定一个channel。格式如下：

# list the sources, sinks and channels for the agent
<Agent>.sources = <Source>
<Agent>.sinks = <Sink>
<Agent>.channels = <Channel1> <Channel2>
 
# set channel for source
<Agent>.sources.<Source>.channels = <Channel1> <Channel2> ...
 
# set channel for sink
<Agent>.sinks.<Sink>.channel = <Channel1>

例如，名为agent_foo的 agent 正在从外部avro客户端读取数据并通过内存channel将其发送到HDFS。

配置文件weblog.config可能如下所示：

# list the sources, sinks and channels for the agent
agent_foo.sources = avro-appserver-src-1
agent_foo.sinks = hdfs-sink-1
agent_foo.channels = mem-channel-1
 
# set channel for source
agent_foo.sources.avro-appserver-src-1.channels = mem-channel-1
 
# set channel for sink
agent_foo.sinks.hdfs-sink-1.channel = mem-channel-1

这将使event 从avro-AppSrv-source流向hdfs-Cluster1-sink，通过内存channelmem-channel-1。

当使用weblog.config作为其配置文件启动 agent 程序时，它将实例化该流程。

配置单个组件

定义流后，您需要设置每个source，sink和channel的属性。这是以相同的分层命名空间方式完成的，您可以在其中设置组件类型以及特定于每个组件的属性的其他值：

# properties for sources
<Agent>.sources.<Source>.<someProperty> = <someValue>
 
# properties for channels
<Agent>.channel.<Channel>.<someProperty> = <someValue>
 
# properties for sinks
<Agent>.sources.<Sink>.<someProperty> = <someValue>

需要为Flume的每个组件设置属性“type”，以了解它需要什么类型的对象。每个source，sink和channel类型都有自己的一组属性，使其能够按预期运行。所有这些都需要根据需要进行设置。在前面的示例中，我们有一个从avro-AppSrv-source到hdfs-Cluster1-sink的流程通过内存channelmem-channel-1。这是一个显示每个组件配置的示例：

agent_foo.sources = avro-AppSrv-source
agent_foo.sinks = hdfs-Cluster1-sink
agent_foo.channels = mem-channel-1
 
# set channel for sources, sinks
 
# properties of avro-AppSrv-source
agent_foo.sources.avro-AppSrv-source.type = avro
agent_foo.sources.avro-AppSrv-source.bind = localhost
agent_foo.sources.avro-AppSrv-source.port = 10000
 
# properties of mem-channel-1
agent_foo.channels.mem-channel-1.type = memory
agent_foo.channels.mem-channel-1.capacity = 1000
agent_foo.channels.mem-channel-1.transactionCapacity = 100
 
# properties of hdfs-Cluster1-sink
agent_foo.sinks.hdfs-Cluster1-sink.type = hdfs
agent_foo.sinks.hdfs-Cluster1-sink.hdfs.path = hdfs://namenode/flume/webdata
 
#...

在 agent 中添加多个流

单个Flume agent 可以包含多个独立流。您可以在配置中列出多个source，sink和channel。可以链接这些组件以形成多个流：

# list the sources, sinks and channels for the agent
<Agent>.sources = <Source1> <Source2>
<Agent>.sinks = <Sink1> <Sink2>
<Agent>.channels = <Channel1> <Channel2>

然后，您可以将source和sink链接到channel（用于sink）的相应channel（用于source），以设置两个不同的流。例如，如果您需要在 agent 中设置两个流，一个从外部avro客户端到外部HDFS，另一个从尾部输出到avrosink，那么这是一个配置来执行此操作：

# list the sources, sinks and channels in the agent
agent_foo.sources = avro-AppSrv-source1 exec-tail-source2
agent_foo.sinks = hdfs-Cluster1-sink1 avro-forward-sink2
agent_foo.channels = mem-channel-1 file-channel-2
 
# flow #1 configuration
agent_foo.sources.avro-AppSrv-source1.channels = mem-channel-1
agent_foo.sinks.hdfs-Cluster1-sink1.channel = mem-channel-1
 
# flow #2 configuration
agent_foo.sources.exec-tail-source2.channels = file-channel-2
agent_foo.sinks.avro-forward-sink2.channel = file-channel-2

配置多 agent 流程

要设置多层流，您需要有 sink 指向下一跳的 avro/thrift  source。这将导致第一个Flume agent 将event 转发到下一个Flume agent 。例如，如果您使用avro客户端定期向本地Flume agent 发送文件（每个event 1个文件），则此本地 agent 可以将其转发到另一个已安装存储的 agent

Weblog agent 配置：

# list sources, sinks and channels in the agent
agent_foo.sources = avro-AppSrv-source
agent_foo.sinks = avro-forward-sink
agent_foo.channels = file-channel
 
# define the flow
agent_foo.sources.avro-AppSrv-source.channels = file-channel
agent_foo.sinks.avro-forward-sink.channel = file-channel
 
# avro sink properties
agent_foo.sinks.avro-forward-sink.type = avro
agent_foo.sinks.avro-forward-sink.hostname = 10.1.1.100
agent_foo.sinks.avro-forward-sink.port = 10000
 
# configure other pieces
#...

HDFS agent 配置：

# list sources, sinks and channels in the agent
agent_foo.sources = avro-collection-source
agent_foo.sinks = hdfs-sink
agent_foo.channels = mem-channel
 
# define the flow
agent_foo.sources.avro-collection-source.channels = mem-channel
agent_foo.sinks.hdfs-sink.channel = mem-channel
 
# avro source properties
agent_foo.sources.avro-collection-source.type = avro
agent_foo.sources.avro-collection-source.bind = 10.1.1.100
agent_foo.sources.avro-collection-source.port = 10000
 
# configure other pieces
#...

在这里，我们将weblog agent 的avro-forward-sink链接到hdfs agent 的avro-collection-source。这将导致来自外部应用程序服务器source的event 最终存储在HDFS中。

扇出流量

如前一节所述，Flume支持扇出从一个source到多个channel的流量。扇出有两种模式 : 复制和多路复用。在复制流程中，event 将发送到所有已配置的channel。在多路复用的情况下，event 仅被发送到合格 channels 的子集。为了散开流量，需要指定source的channel列表以及扇出它的策略。这是通过添加可以复制或多路复用的channel“选择器”来完成的。如果它是多路复用器，则进一步指定选择规则。如果您没有指定选择器，那么默认情况下它会复制：

# List the sources, sinks and channels for the agent
<Agent>.sources = <Source1>
<Agent>.sinks = <Sink1> <Sink2>
<Agent>.channels = <Channel1> <Channel2>
 
# set list of channels for source (separated by space)
<Agent>.sources.<Source1>.channels = <Channel1> <Channel2>
 
# set channel for sinks
<Agent>.sinks.<Sink1>.channel = <Channel1>
<Agent>.sinks.<Sink2>.channel = <Channel2>
 
<Agent>.sources.<Source1>.selector.type = replicating

多路复用选择具有另一组属性以分流流。这需要指定event 属性到channel集的映射。选择器检查event 头中的每个已配置属性。如果它与指定的值匹配，则该event 将发送到映射到该值的所有channel。如果没有匹配项，则将event 发送到配置为默认值的channel集：

# Mapping for multiplexing selector
<Agent>.sources.<Source1>.selector.type = multiplexing
<Agent>.sources.<Source1>.selector.header = <someHeader>
<Agent>.sources.<Source1>.selector.mapping.<Value1> = <Channel1>
<Agent>.sources.<Source1>.selector.mapping.<Value2> = <Channel1> <Channel2>
<Agent>.sources.<Source1>.selector.mapping.<Value3> = <Channel2>
#...
 
<Agent>.sources.<Source1>.selector.default = <Channel2>

映射允许为每个值重叠channel。

以下示例具有多路复用到两个路径的单个流。名为agent_foo的 agent 具有单个avrosource和两个链接到两个sink的channel：

# list the sources, sinks and channels in the agent
agent_foo.sources = avro-AppSrv-source1
agent_foo.sinks = hdfs-Cluster1-sink1 avro-forward-sink2
agent_foo.channels = mem-channel-1 file-channel-2
 
# set channels for source
agent_foo.sources.avro-AppSrv-source1.channels = mem-channel-1 file-channel-2
 
# set channel for sinks
agent_foo.sinks.hdfs-Cluster1-sink1.channel = mem-channel-1
agent_foo.sinks.avro-forward-sink2.channel = file-channel-2
 
# channel selector configuration
agent_foo.sources.avro-AppSrv-source1.selector.type = multiplexing
agent_foo.sources.avro-AppSrv-source1.selector.header = State
agent_foo.sources.avro-AppSrv-source1.selector.mapping.CA = mem-channel-1
agent_foo.sources.avro-AppSrv-source1.selector.mapping.AZ = file-channel-2
agent_foo.sources.avro-AppSrv-source1.selector.mapping.NY = mem-channel-1 file-channel-2
agent_foo.sources.avro-AppSrv-source1.selector.default = mem-channel-1

选择器检查名为“State”的标头。如果该值为“CA”，则将其发送到mem-channel-1，如果其为“AZ”，则将其发送到文件channel-2，或者如果其为“NY”则为两者。如果“状态”标题未设置或与三者中的任何一个都不匹配，则它将转到mem-channel-1，其被指定为“default”。

选择器还支持可选channel。要为标头指定可选channel，可通过以下方式使用config参数“optional”：

# channel selector configuration
agent_foo.sources.avro-AppSrv-source1.selector.type = multiplexing
agent_foo.sources.avro-AppSrv-source1.selector.header = State
agent_foo.sources.avro-AppSrv-source1.selector.mapping.CA = mem-channel-1
agent_foo.sources.avro-AppSrv-source1.selector.mapping.AZ = file-channel-2
agent_foo.sources.avro-AppSrv-source1.selector.mapping.NY = mem-channel-1 file-channel-2
agent_foo.sources.avro-AppSrv-source1.selector.optional.CA = mem-channel-1 file-channel-2
agent_foo.sources.avro-AppSrv-source1.selector.mapping.AZ = file-channel-2
agent_foo.sources.avro-AppSrv-source1.selector.default = mem-channel-1

选择器将首先尝试写入所需的channel，如果其中一个channel无法使用event ，则会使事务失败。在所有渠道上重新尝试交易。一旦所有必需的channel消耗了event ，则选择器将尝试写入可选channel。任何可选channel使用该event 的失败都会被忽略而不会重试。

如果可选信道与特定报头的所需信道之间存在重叠，则认为该信道是必需的，并且信道中的故障将导致重试所有必需信道集。例如，在上面的示例中，对于标题“CA”，mem-channel-1被认为是必需的channel，即使它被标记为必需和可选，并且写入此channel的失败将导致该event 在为选择器配置的所有channel上重试。

请注意，如果标头没有任何所需的channel，则该event 将被写入默认channel，并将尝试写入该标头的可选channel。如果未指定所需的channel，则指定可选channel仍会将event 写入默认channel。如果没有将channel指定为默认channel且没有必需channel，则选择器将尝试将event 写入可选channel。在这种情况下，任何失败都会被忽略。

支持

多个Flume组件支持SSL / TLS协议，以便安全地与其他系统通信。

Component	SSL server or client
Avro Source	server
Avro Sink	client
Thrift Source	server
Thrift Sink	client
Kafka Source	client
Kafka Channel	client
Kafka Sink	client
HTTP Source	server
JMS Source	client
Syslog TCP Source	server
Multiport Syslog TCP Source	server

SSL兼容组件具有若干配置参数来设置SSL，例如启用SSL标志，密钥库/信任库参数（位置，密码，类型）和其他SSL参数（例如禁用的协议）

始终在 agent 配置文件的组件级别指定为组件启用SSL。因此，某些组件可能配置为使用SSL，而其他组件则不配置（即使具有相同的组件类型）

密钥库/信任库设置可以在组件级别或全局指定。

在组件级别设置的情况下，通过组件特定参数在 agent 配置文件中配置密钥库/信任库。此方法的优点是组件可以使用不同的密钥库（如果需要）。缺点是必须为 agent 配置文件中的每个组件复制密钥库参数。组件级别设置是可选的，但如果已定义，则其优先级高于全局参数。

使用全局设置，只需定义一次密钥库/信任库参数，并对所有组件使用相同的设置，这意味着更少和更集中的配置。

可以通过系统属性或通过环境变量来配置全局设置。

系统属性	环境变量	描述
javax.net.ssl.keyStore	FLUME_SSL_KEYSTORE_PATH	密钥库位置
javax.net.ssl.keyStorePassword	FLUME_SSL_KEYSTORE_PASSWORD	密钥库密码
javax.net.ssl.keyStoreType	FLUME_SSL_KEYSTORE_TYPE	密钥库类型（默认为JKS）
javax.net.ssl.trustStore	FLUME_SSL_TRUSTSTORE_PATH	信任库位置
javax.net.ssl.trustStorePassword	FLUME_SSL_TRUSTSTORE_PASSWORD	信任库密码
javax.net.ssl.trustStoreType	FLUME_SSL_TRUSTSTORE_TYPE	信任库类型（默认为JKS）
flume.ssl.include.protocols	FLUME_SSL_INCLUDE_PROTOCOLS	计算启用的协议时要包括的协议。逗号（，）分隔列表。如果提供，排除的协议将从此列表中排除。
flume.ssl.exclude.protocols	FLUME_SSL_EXCLUDE_PROTOCOLS	计算启用的协议时要排除的协议。逗号（，）分隔列表。
flume.ssl.include.cipherSuites	FLUME_SSL_INCLUDE_CIPHERSUITES	在计算启用的密码套件时包含的密码套件。逗号（，）分隔列表。如果提供，排除的密码套件将被排除在此列表之外。
flume.ssl.exclude.cipherSuites	FLUME_SSL_EXCLUDE_CIPHERSUITES	在计算启用的密码套件时要排除的密码套件。逗号（，）分隔列表。

可以在命令行上传递SSL系统属性，也可以在conf / flume-env.sh中设置JAVA_OPTS环境变量（尽管使用命令行是不可取的，因为包含密码的命令将保存到命令历史记录中。）

export JAVA_OPTS="$JAVA_OPTS -Djavax.net.ssl.keyStore=/path/to/keystore.jks"
export JAVA_OPTS="$JAVA_OPTS -Djavax.net.ssl.keyStorePassword=password"

Flume使用JSSE（Java安全套接字扩展）中定义的系统属性，因此这是设置SSL的标准方法。另一方面，在系统属性中指定密码意味着可以在进程列表中看到密码。对于不可接受的情况，也可以在环境变量中定义参数。在这种情况下，Flume在内部从相应的环境变量初始化JSSE系统属性。

SSL环境变量可以在启动Flume之前在shell环境中设置，也可以在conf / flume-env.sh中设置（尽管使用命令行是不可取的，因为包含密码的命令将保存到命令历史记录中。）

export FLUME_SSL_KEYSTORE_PATH=/path/to/keystore.jks
export FLUME_SSL_KEYSTORE_PASSWORD=password

** 请注意：**

• 必须在组件级别启用SSL。仅指定全局SSL参数不会产生任何影响。
• 如果在多个级别指定全局SSL参数，则优先级如下（从高到低）：
  • agent 配置中的组件参数
  • 系统属性
  • 环境变量
• 如果为组件启用了SSL，但未以上述任何方式指定SSL参数，则
  • 在密钥库的情况下：配置错误
  • 在truststores的情况下：将使用默认信任库（Oracle JDK中的jssecacerts / cacerts）
• 在所有情况下，可信任密码都是可选的。如果未指定，则在JDK打开信任库时，不会对信任库执行完整性检查。

source 和接收批量大小和channel事务容量

source和sink可以具有批量大小参数，该参数确定它们在一个批次中处理的最大event 数。这发生在具有称为事务容量的上限的channel事务中。批量大小必须小于渠道的交易容量。有一个明确的检查，以防止不兼容的设置。只要读取配置，就会进行此检查。

Flume Source

Avro Source

监听Avro端口并从外部Avro客户端流接收event 。当与另一个（上一跳）Flume agent 上的内置Avro Sink配对时，它可以创建分层集合拓扑。必需属性以粗体显示

属性名称	默认	描述
channels	-
type	-	组件类型名称，需要是avro
bind	-	要侦听的主机名或IP地址
port	-	要绑定的端口号
threads	-	生成的最大工作线程数
selector.type
selector.*
interceptors	-	以空格分隔的拦截器列表
interceptors.*
compression-type	none	这可以是“none”或“deflate”。压缩类型必须与匹配AvroSource的压缩类型匹配
SSL	false	将其设置为true以启用SSL加密。如果启用了SSL，则还必须通过组件级参数（请参阅下文）或全局SSL参数（请参阅SSL / TLS支持部分）指定“密钥库”和“密钥库密码” 。
keysore	-	这是Java密钥库文件的路径。如果未在此处指定，则将使用全局密钥库（如果已定义，则配置错误）。
keystore-password	-	Java密钥库的密码。如果未在此处指定，则将使用全局密钥库密码（如果已定义，则配置错误）。
keystore-type	JKS	Java密钥库的类型。这可以是“JKS”或“PKCS12”。如果未在此处指定，则将使用全局密钥库类型（如果已定义，则默认为JKS）。
exclude-protocols	SSLv3	要排除的以空格分隔的SSL / TLS协议列表。除指定的协议外，将始终排除SSLv3。
include-protocols	-	要包含的以空格分隔的SSL / TLS协议列表。启用的协议将是包含的协议，没有排除的协议。如果包含协议为空，则它包括每个支持的协议。
exclude-cipher-suites	-	要排除的以空格分隔的密码套件列表。
include-cipher-suites	-	以空格分隔的密码套件列表。启用的密码套件将是包含的密码套件，不包括排除的密码套件。如果included-cipher-suites为空，则包含每个支持的密码套件。
ipFilter	false	将此设置为true以启用ipFiltering for netty
ipFilterRules	-	使用此配置定义N netty ipFilter模式规则。

agent 名为a1的示例：

a1.sources = r1
a1.channels = c1
a1.sources.r1.type = avro
a1.sources.r1.channels = c1
a1.sources.r1.bind = 0.0.0.0
a1.sources.r1.port = 4141

ipFilterRules的示例

ipFilterRules定义由逗号分隔的N个netty ipFilters模式规则必须采用此格式。

<’allow’ or deny>:<’ip’ or ‘name’ for computer name>:<pattern> or allow/deny:ip/name:pattern
example: ipFilterRules=allow:ip:127.*,allow:name:localhost,deny:ip:*

请注意，匹配的第一个规则将适用，如下例所示，来自localhost上的客户端

这将允许localhost上的客户端拒绝来自任何其他ip的客户端“allow:name:localhost,deny:ip:这将拒绝localhost上的客户端允许来自任何其他ip的客户端“deny:name:localhost,allow:ip: 

Thrift Source

侦听Thrift端口并从外部Thrift客户端流接收event 。当与另一个（上一跳）Flume agent 上的内置ThriftSink配对时，它可以创建分层集合拓扑。可以通过启用kerberos身份验证将Thriftsource配置为以安全模式启动。agent-principal和agent-keytab是Thriftsource用于向kerberos KDC进行身份验证的属性。必需属性以粗体显示

属性名称	默认	描述
channels	-
type	-	组件类型名称，需要节俭
bind	-	要侦听的主机名或IP地址
port	-	要绑定的端口号
threads	-	生成的最大工作线程数
selector.type
selector.*
interceptors	-	空格分隔的拦截器列表
interceptors.*
SSL	false	将其设置为true以启用SSL加密。如果启用了SSL，则还必须通过组件级参数（请参阅下文）或全局SSL参数（请参阅SSL / TLS支持部分）指定“密钥库”和“密钥库密码”。
keystore	-	这是Java密钥库文件的路径。如果未在此处指定，则将使用全局密钥库（如果已定义，则配置错误）。
keystore-password	-	Java密钥库的密码。如果未在此处指定，则将使用全局密钥库密码（如果已定义，则配置错误）。
keystore-type	JKS	Java密钥库的类型。这可以是“JKS”或“PKCS12”。如果未在此处指定，则将使用全局密钥库类型（如果已定义，则默认为JKS）。
exclude-protocols		要排除的以空格分隔的SSL / TLS协议列表。除指定的协议外，将始终排除SSLv3。
include-protocols	-	要包含的以空格分隔的SSL / TLS协议列表。启用的协议将是包含的协议，没有排除的协议。如果包含协议为空，则它包括每个支持的协议。
exclude-cipher-suites	-	要排除的以空格分隔的密码套件列表。
include-cipher-suites	-	以空格分隔的密码套件列表。启用的密码套件将是包含的密码套件，不包括排除的密码套件。
kerberos		设置为true以启用kerberos身份验证。在kerberos模式下，成功进行身份验证需要agent-principal和agent-keytab。安全模式下的Thriftsource仅接受来自已启用kerberos且已成功通过kerberos KDC验证的Thrift客户端的连接。
agent-principal	-	Thrift Source使用的kerberos主体对kerberos KDC进行身份验证。
agent-keytab	-	Thrift Source与 agent 主体结合使用的keytab位置，用于对kerberos KDC进行身份验证。

agent 名为a1的示例：

a1.sources = r1
a1.channels = c1
a1.sources.r1.type = thrift
a1.sources.r1.channels = c1
a1.sources.r1.bind = 0.0.0.0
a1.sources.r1.port = 4141

Exec Source

Exec source在启动时运行给定的Unix命令，并期望该进程在标准输出上连续生成数据（stderr被简单地丢弃，除非属性logStdErr设置为true）。如果进程因任何原因退出，则source也会退出并且不会生成其他数据。这意味着cat [named pipe] 或tail -F [file]等配置将产生所需的结果，而日期 可能不会 - 前两个命令产生数据流，而后者产生单个event 并退出。必需属性以粗体显示

属性名称	默认	描述
channels	-
type	-	组件类型名称，需要是exec
command	-	要执行的命令
shell	-	用于运行命令的shell调用。例如 /bin/sh -c 。仅适用于依赖shell功能的命令，如通配符，后退标记，管道等。
restartThrottle	10000	尝试重新启动之前等待的时间（以毫秒为单位）
restart	false	是否应该重新执行已执行的cmd
logStdErr	false	是否应记录命令的stderr
BATCHSIZE	20	一次读取和发送到channel的最大行数
batchTimeout	3000	在向下游推送数据之前，如果未达到缓冲区大小，则等待的时间（以毫秒为单位）
selector.type	replication	复制或多路复用
selector.*		取决于selector.type值
interceptors	-	以空格分隔的拦截器列表
interceptors.*

警告

Exec Source和其他异步source的问题在于，如果无法将event 放入Channel中，则source无法保证客户端知道它。在这种情况下，数据将丢失。例如，最常请求的功能之一是 tail -F [file] 类似用例，其中应用程序写入磁盘上的日志文件，Flume将文件作为尾部发送，将每一行作为event 发送。虽然这是可能的，但是有一个明显的问题; 如果channel 填满并且Flume无法发送event ，会发生什么？由于某种原因，Flume无法向编写日志文件的应用程序指示它需要保留日志或event 尚未发送。如果这没有意义，您只需要知道：当使用Exec Source等单向异步接口时，您的应用程序永远无法保证已收到数据！

作为此警告的延伸 - 并且完全清楚 - 使用此source时，event 传递绝对没有保证。

为了获得更强的可靠性保证，请考虑Spooling Directory Source，Taildir Source或通过SDK直接与Flume集成。

agent 名为a1的示例：

a1.sources = r1
a1.channels = c1
a1.sources.r1.type = exec
a1.sources.r1.command = tail -F /var/log/secure
a1.sources.r1.channels = c1

'shell'配置用于通过命令shell（例如Bash或Powershell）调用'命令'。'command'作为参数传递给'shell'执行。这允许'命令'使用shell中的功能，例如通配符，后退标记，管道，循环，条件等。如果没有'shell'配置，将直接调用'command'。'shell'的常用值： ‘/bin/sh -c’, ‘/bin/ksh -c’, ‘cmd /c’, ‘powershell -Command’, etc.

a1.sources.tailsource-1.type = exec
a1.sources.tailsource-1.shell = /bin/bash -c
a1.sources.tailsource-1.command = for i in /path/*.txt; do cat $i; done

JMS Source

JMS Source从JMS目标（例如队列或主题）读取消息。作为JMS应用程序，它应该与任何JMS提供程序一起使用，但仅使用ActiveMQ进行测试。JMSsource提供可配置的批量大小，消息选择器，用户/传递和消息到水槽event 转换器。请注意，供应商提供的JMS jar应该包含在Flume类路径中，使用plugins.d目录（首选），命令行上的-classpath或flume-env.sh中的FLUME_CLASSPATH变量。必需属性以粗体显示

属性名称	默认	描述
channels	-
type	-	组件类型名称，需要是jms
initialContextFactory	-	Inital Context Factory，例如：org.apache.activemq.jndi.ActiveMQInitialContextFactory
connectionFactory	-	连接工厂应显示为的JNDI名称
providerURL	-	JMS提供程序URL
destinationName	-	目的地名称
destinationType	-	目的地类型（队列或主题）
messageSelector	-	创建使用者时使用的消息选择器
userName	-	目标/提供商的用户名
PASSWORDFILE	-	包含目标/提供程序密码的文件
BATCHSIZE	100	一批中要使用的消息数
converter.type	DEFAULT	用于将消息转换为水槽event 的类。见下文。
converter.*	-	转换器属性。
converter.charset	UTF-8	仅限默认转换器。在将JMS TextMessages转换为字节数组时使用的字符集。
createDurableSubscription	false	是否创建持久订阅。持久订阅只能与destinationType主题一起使用。如果为true，则必须指定“clientId”和“durableSubscriptionName”。
clientId	-	JMS客户端标识符在创建后立即在Connection上设置。持久订阅必需。
durableSubscriptionName	-	用于标识持久订阅的名称。持久订阅必需。

消息转换器

JMSsource允许可插拔转换器，尽管默认转换器可能适用于大多数用途。默认转换器能够将字节，文本和对象消息转换为FlumeEvents。在所有情况下，消息中的属性都将作为标题添加到FlumeEvent中。

BytesMessage：

消息的字节被复制到FlumeEvent的主体。每封邮件无法转换超过2GB的数据。

TextMessage的：

消息文本转换为字节数组并复制到FlumeEvent的主体。默认转换器默认使用UTF-8，但这是可配置的。

ObjectMessage：

Object被写入包含在ObjectOutputStream中的ByteArrayOutputStream，并将生成的数组复制到FlumeEvent的主体。

agent 名为a1的示例：

a1.sources = r1
a1.channels = c1
a1.sources.r1.type = jms
a1.sources.r1.channels = c1
a1.sources.r1.initialContextFactory = org.apache.activemq.jndi.ActiveMQInitialContextFactory
a1.sources.r1.connectionFactory = GenericConnectionFactory
a1.sources.r1.providerURL = tcp://mqserver:61616
a1.sources.r1.destinationName = BUSINESS_DATA
a1.sources.r1.destinationType = QUEUE

SSL 和 JMS Source

JMS客户端实现通常支持通过JSSE（Java安全套接字扩展）定义的某些Java系统属性来配置SSL / TLS。为Flume的JVM指定这些系统属性，JMSsource（或更准确地说是JMSsource使用的JMS客户端实现）可以通过SSL连接到JMS服务器（当然，仅当JMS服务器也已设置为使用SSL时）。它应该可以与任何JMS提供程序一起使用，并且已经过ActiveMQ，IBM MQ和Oracle WebLogic的测试。

以下部分仅介绍Flume方面所需的SSL配置步骤。您可以在Flume Wiki上找到有关不同JMS提供程序的服务器端设置以及完整工作配置示例的更详细说明。

** SSL 传输/服务器身份验证：**

如果JMS服务器使用自签名证书或其证书由不受信任的CA（例如公司自己的CA）签名，则需要设置信任库（包含正确的证书）并传递给Flume。它可以通过全局SSL参数完成。有关全局SSL设置的更多详细信息，请参阅SSL / TLS支持部分。

使用SSL时，某些JMS提供程序需要SSL特定的JNDI初始上下文工厂和/或提供程序URL设置（例如，ActiveMQ使用ssl：// URL前缀而不是tcp：//）。在这种情况下，必须在 agent 配置文件中调整source属性（initialContextFactory和/或providerURL）

客户端证书身份验证（双向SSL）：

JMS Source可以通过客户端证书身份验证而不是通常的用户/密码登录来对JMS服务器进行身份验证（使用SSL并且JMS服务器配置为接受此类身份验证时）。

包含用于身份验证的Flume密钥的密钥库需要再次通过全局SSL参数进行配置。有关全局SSL设置的更多详细信息，请参阅SSL / TLS支持部分。

密钥库应该只包含一个密钥（如果存在多个密钥，则将使用第一个密钥）。密钥密码必须与密钥库密码相同。

在客户端证书身份验证的情况下，不需要在Flume agent 配置文件中为JMSsource指定userName / passwordFile属性。

请注意：

与其他组件不同，JMS Source没有组件级别的配置参数。也没有启用SSL标志。SSL设置由JNDI / Provider URL设置（最终是JMS服务器设置）以及truststore / keystore的存在/不存在控制。

Spooling Directory Source

此source允许您通过将要摄取的文件放入磁盘上的“spooling ”目录来摄取数据。此source将查看新文件的指定目录，并将在新文件出现时解析event 。event 解析逻辑是可插入的。在给定文件完全读入channel后，默认情况下通过重命名文件来指示完成，或者可以删除它或使用trackerDir来跟踪已处理的文件。

与Exec source不同，即使Flume重新启动或被杀死，此source也是可靠的并且不会遗漏数据。作为这种可靠性的交换，只有不可变的，唯一命名的文件必须被放入spooling directory.中。Flume试图检测这些问题，如果违反则会声明失败：

1. 如果在放入 spooling directory 后写入文件，Flume会将错误打印到其日志文件并停止处理。
2. 如果稍后重复使用文件名，Flume将在其日志文件中输出错误并停止处理。

为避免上述问题，在将文件名移动到 spooling directory 中时，添加唯一标识符（例如时间戳）可能很有用。

尽管该source的可靠性保证，但仍存在如果发生某些下游故障则可能重复event 的情况。这与其他Flume组件提供的保证一致。

属性名称	默认	描述
channels	-
type	-	组件类型名称需要是spooldir。
spoolDir	-	从中读取文件的目录。
fileSuffix	.COMPLETED	后缀附加到完全摄取的文件
deletePolicy	never	何时删除已完成的文件：从never 或 immediate
FileHeader	false	是否添加存储绝对路径文件名的标头。
fileHeaderKey	file	将绝对路径文件名附加到event 标题时使用的标题键。
basenameHeader	false	是否添加存储文件基本名称的标头。
basenameHeaderKey	basename	标题将文件的基本名称附加到event 标题时使用的标题。
includePattern	.*$	正则表达式，指定要包含的文件。它可以与ignorePattern一起使用。如果一个文件同时匹配ignorePattern和includePattern正则表达式，该文件将被忽略。
ignorePattern	$	正则表达式，指定要忽略的文件（跳过）。它可以与includePattern一起使用。如果一个文件同时匹配ignorePattern和includePattern正则表达式，该文件将被忽略。
trackerDir	.flumespool	用于存储与文件处理相关的元数据的目录。如果此路径不是绝对路径，则将其解释为相对于spoolDir。
trackingPolicy	rename	跟踪策略定义如何跟踪文件处理。它可以是“重rename”或“tracker_dir”。此参数仅在deletePolicy为“never”时有效。“重rename” - 处理完文件后，会根据fileSuffix参数重命名。“tracker_dir” - 不重命名文件，但会在trackerDir中创建新的空文件。新的跟踪器文件名source自摄取的文件名和fileSuffix。
consumeOrder	oldest	spooling directory 中的文件将以 oldest， youngest和 random 的方式使用。如果是oldest和youngest的，文件的最后修改时间将用于比较文件。如果出现相同，将首先消耗具有最小字典顺序的文件。在 random的情况下，任何文件将被随机挑选。当使用oldest和youngest时，整个目录将被扫描以选择oldest/youngest的文件，如果存在大量文件，这可能会很慢，而使用random可能会导致旧文件在新文件不断进入时很晚被消耗 spooling directory。
pollDelay	500	轮询新文件时使用的延迟（以毫秒为单位）。
recursiveDirectorySearch	false	是否监视子目录以查找要读取的新文件。
maxBackoff	4000	如果channel已满，则在连续尝试写入channel之间等待的最长时间（以毫秒为单位）。source将以低退避开始，并在每次channel抛出ChannelException时以指数方式增加，直到此参数指定的值。
BATCHSIZE	100	批量传输到channel的粒度
inputCharset	UTF-8	反序列化器使用的字符集，将输入文件视为文本。
decodeErrorPolicy	FAIL	当我们在输入文件中看到不可解码的字符时该怎么办。FAIL：抛出异常并且无法解析文件。 REPLACE：用“替换字符”char替换不可解析的字符，通常是Unicode U+FFFD 。 IGNORE：删除不可解析的字符序列。
deserializer	LINE	指定用于将文件解析为event 的反序列​​化程序。默认将每行解析为event 。指定的类必须实现EventDeserializer.Builder。
deserializer.*		每个event 反序列化器不同。
bufferMaxLines	-	（Obselete）此选项现在被忽略。
bufferMaxLineLength	5000	（已弃用）提交缓冲区中行的最大长度。请改用deserializer.maxLineLength。
selector.type	replicating	replicating  or   multiplexing
selector.*		取决于selector.type值
interceptors	-	以空格分隔的拦截器列表
interceptors.*

名为agent-1的 agent 示例：

a1.channels = ch-1
a1.sources = src-1
 
a1.sources.src-1.type = spooldir
a1.sources.src-1.channels = ch-1
a1.sources.src-1.spoolDir = /var/log/apache/flumeSpool
a1.sources.src-1.fileHeader = true

Event Deserializers

以下event 反序列化器随Flume一起提供。

LINE

此解串器为每行文本输入生成一个event

物业名称	默认	描述
deserializer.maxLineLength	2048	单个event 中包含的最大字符数。如果一行超过此长度，则会被截断，并且该行上的其余字符将出现在后续event 中。
deserializer.outputCharset	UTF-8	用于编码放入channel的event 的字符集。

AVRO

此解串器能够读取Avro容器文件，并在文件中为每个Avro记录生成一个event 。每个event 都使用标头进行注释，该标头指示所使用的模式。event 的主体是二进制Avro记录数据，不包括模式或容器文件元素的其余部分。

请注意，如果假脱机目录source必须重试将其中一个event 放入channel（例如，因为channel已满），则它将重置并从最新的Avro容器文件同步点重试。为了减少此类故障情况下的潜在event 重复，请在Avro输入文件中更频繁地写入同步标记。

物业名称	默认	描述
deserializer.schemaType	HASH	如何表示模式。默认情况下，或者 指定值HASH时，会对Avro架构进行哈希处理，并将哈希值存储在event 头“flume.avro.schema.hash”中的每个event 中。如果指定了LITERAL，则JSON编码的模式本身存储在event 头“flume.avro.schema.literal”中的每个event 中。与HASH模式相比，使用LITERAL模式效率相对较低。

BlobDeserializer>

此反序列化器为每个event 读取二进制大对象（BLOB），通常每个文件一个BLOB。例如PDF或JPG文件。请注意，此方法不适用于非常大的对象，因为整个BLOB都缓存在RAM中。

物业名称	默认	描述
解串器	-	此类的FQCN：org.apache.flume.sink.solr.morphline.BlobDeserializer$Builder
deserializer.maxBlobLength	100000000	要读取的最大字节数和给定请求的缓冲区

Taildir Source

注意: 此source作为预览功能提供。它不适用于Windows。

观察指定的文件，并在检测到添加到每个文件的新行后几乎实时地拖尾它们。如果正在写入新行，则此source将重试读取它们以等待写入完成。

此source是可靠的，即使tail文件旋转也不会丢失数据。它定期以JSON格式写入给定位置文件上每个文件的最后读取位置。如果Flume由于某种原因停止或停止，它可以从写在现有位置文件上的位置重新开始tail。

在其他用例中，此source也可以使用给定的位置文件从每个文件的任意位置开始拖尾。当指定路径上没有位置文件时，默认情况下它将从每个文件的第一行开始拖尾。

文件将按修改时间顺序使用。将首先使用具有最早修改时间的文件。

此source不会重命名或删除或对正在挂载的文件执行任何修改。目前此source不支持tail二进制文件。它逐行读取文本文件。

属性名称	默认	描述
channels	-
type	-	组件类型名称，需要是TAILDIR。
filegroups	-	以空格分隔的文件组列表。每个文件组都指示一组要挂起的文件。
filegroups.	-	文件组的绝对路径。正则表达式（而不是文件系统模式）只能用于文件名。
positionFile	~/.flume/taildir_position.json	以JSON格式文件以记录每个尾部文件的inode，绝对路径和最后位置。
headers.	-	标题值，使用标题键设置。可以为一个文件组指定多个标头。
byteOffsetHeader	false	是否将tailed line 的字节偏移量添加到名为“byteoffset”的标头中。
skipToEnd	false	在未写入位置文件的文件的情况下是否跳过位置到EOF。
idleTimeout	120000	关闭非活动文件的时间（毫秒）。如果关闭的文件附加了新行，则此source将自动重新打开它。
writePosInterval	3000	写入位置文件上每个文件的最后位置的间隔时间（ms）。
BATCHSIZE	100	一次读取和发送到channel的最大行数。使用默认值通常很好。
maxBatchCount	Long.MAX_VALUE	控制从同一文件连续读取的批次数。如果source正在拖尾多个文件，并且其中一个文件以快速写入，则可以防止处理其他文件，因为繁忙文件将在无限循环中读取。在这种情况下，降低此值。
backoffSleepIncrement	1000	在最后一次尝试未找到任何新数据时，重新尝试轮询新数据之前的时间延迟增量。
maxBackoffSleep	5000	每次重新尝试轮询新数据时的最大时间延迟，当最后一次尝试未找到任何新数据时。
cachePatternMatching	true	对于包含数千个文件的目录，列出目录并应用文件名正则表达式模式可能非常耗时。缓存匹配文件列表可以提高性能。消耗文件的顺序也将被缓存。要求文件系统以至少1秒的粒度跟踪修改时间。
FileHeader	false	是否添加存储绝对路径文件名的标头。
fileHeaderKey	file	将绝对路径文件名附加到event 标题时使用的标题键。

agent 名为a1的示例:

a1.sources = r1
a1.channels = c1
a1.sources.r1.type = TAILDIR
a1.sources.r1.channels = c1
a1.sources.r1.positionFile = /var/log/flume/taildir_position.json
a1.sources.r1.filegroups = f1 f2
a1.sources.r1.filegroups.f1 = /var/log/test1/example.log
a1.sources.r1.headers.f1.headerKey1 = value1
a1.sources.r1.filegroups.f2 = /var/log/test2/.*log.*
a1.sources.r1.headers.f2.headerKey1 = value2
a1.sources.r1.headers.f2.headerKey2 = value2-2
a1.sources.r1.fileHeader = true
a1.sources.ri.maxBatchCount = 1000

Kafka Source

Kafka Source是一个Apache Kafka消费者，它从Kafka主题中读取消息。如果您运行了多个Kafka source，则可以使用相同的使用者组配置它们，以便每个source都读取一组唯一的主题分区。这目前支持Kafka服务器版本0.10.1.0或更高版本。测试完成了2.0.1，这是发布时最高的可用版本。

属性名称	默认	描述
channels	-
type	-	组件类型名称，需要是org.apache.flume.source.kafka.KafkaSource
kafka.bootstrap.servers	-	source代码使用的Kafka集群中的 agent 列表
kafka.consumer.group.id	flume	独特的消费者群体。在多个source或 agent 中设置相同的ID表示它们是同一个使用者组的一部分
kafka.topics	-	以逗号分隔的主题列表，kafka消费者将从中读取消息。
kafka.topics.regex	-	正则表达式，用于定义source订阅的主题集。此属性具有比kafka.topics更高的优先级，并覆盖kafka.topics（如果存在）。
BATCHSIZE	1000	一批中写入Channel的最大消息数
batchDurationMillis	1000	将批次写入channel之前的最长时间（以毫秒为单位）只要达到第一个大小和时间，就会写入批次。
backoffSleepIncrement	1000	Kafka Topic 显示为空时触发的初始和增量等待时间。等待时间将减少对空kafka Topic 的激进ping操作。一秒钟是摄取用例的理想选择，但使用拦截器的低延迟操作可能需要较低的值。
maxBackoffSleep	5000	Kafka Topic 显示为空时触发的最长等待时间。5秒是摄取用例的理想选择，但使用拦截器的低延迟操作可能需要较低的值。
useFlumeEventFormat	false	默认情况下，event 将从Kafka Topic 直接作为字节直接进入event 主体。设置为true以读取event 作为Flume Avro二进制格式。与Kafka Sink上的相同属性或Kafka Channel上的parseAsFlumeEvent属性一起使用时，这将保留在生成端发送的任何Flume标头。
setTopicHeader	true	设置为true时，将检索到的消息的主题存储到由topic Header属性定义的标头中 。
topicHeader	topic	如果setTopicHeader属性设置为true，则定义用于存储接收消息主题名称的标头名称。如果与Kafka SinktopicHeader属性结合使用，应该小心，以避免将消息发送回循环中的同一主题。
kafka.consumer.security.protocol	PLAINTEXT	如果使用某种级别的安全性写入Kafka，则设置为SASL_PLAINTEXT，SASL_SSL或SSL。有关安全设置的其他信息，请参见下文。
more consumer security props		如果使用SASL_PLAINTEXT，SASL_SSL或SSL，请参阅Kafka安全性以获取需要在使用者上设置的其他属性。
Other Kafka Consumer Properties	-	这些属性用于配置Kafka Consumer。可以使用Kafka支持的任何消费者财产。唯一的要求是使用前缀kafka.consumer添加属性名称 。例如：kafka.consumer.auto.offset.reset

** 注意 **

Kafka Source会覆盖两个Kafka使用者参数：source 和每次batch 提交的时候会将auto.commit.enable设置为“false”，并提交每个批处理。Kafka Source至少保证一次消息检索策略。

source启动时可以存在重复项。

Kafka Source还提供了key.deserializer（org.apache.kafka.common.serialization.StringSerializer）和value.deserializer（org.apache.kafka.common.serialization.ByteArraySerializer）的默认值。

不建议修改这些参数。

不推荐使用的属性

属性名称	默认	描述
topic	-	使用kafka.topics
groupId	flume	使用kafka.consumer.group.id
zookeeperConnect	-	自0.9.x起不再受kafka消费者客户端的支持。使用kafka.bootstrap.servers与kafka集群建立连接
migrateZookeeperOffsets	true	如果找不到Kafka存储的偏移量，请在Zookeeper中查找偏移量并将它们提交给Kafka。这应该是支持从旧版本的Flume无缝Kafka客户端迁移。迁移后，可以将其设置为false，但通常不需要这样做。如果未找到Zookeeper偏移量，则Kafka配置kafka.consumer.auto.offset.reset定义如何处理偏移量。 有关详细信息，请查看Kafka文档

通过逗号分隔的主题列表进行主题订阅的示例:

tier1.sources.source1.type = org.apache.flume.source.kafka.KafkaSource
tier1.sources.source1.channels = channel1
tier1.sources.source1.batchSize = 5000
tier1.sources.source1.batchDurationMillis = 2000
tier1.sources.source1.kafka.bootstrap.servers = localhost:9092
tier1.sources.source1.kafka.topics = test1, test2
tier1.sources.source1.kafka.consumer.group.id = custom.g.id

正则表达式主题订阅的示例:

ier1.source.source1.type  =  org.apache.flume.source.kafka.KafkaSource
tier1.source.source1.channel  =  channel1
tier1.source.source1.kafka.bootstrap.servers  =  本地主机：9092
tier1.source.source1.kafka .topics.regex  =  ^ topic [0-9] $
＃默认使用kafka.consumer.group.id = flume

** Security 和 Kafka Source：**

Flume和Kafka之间的通信渠道支持安全认证和数据加密。对于安全身份验证，可以使用Kafka 0.9.0版中的SASL / GSSAPI（Kerberos V5）或SSL（即使该参数名为SSL，实际协议是TLS实现）

截至目前，数据加密仅由SSL / TLS提供。

将kafka.consumer.security.protocol设置为以下任何值意味着：

• SASL_PLAINTEXT - 无数据加密的Kerberos或纯文本身份验证
• SASL_SSL - 使用数据加密的Kerberos或纯文本身份验证
• SSL - 基于TLS的加密，带有可选的身份验证

** 警告 **

启用S​​SL时性能会下降，其大小取决于CPU类型和JVM实现。参考：Kafka安全概述 和跟踪此问题的jira： KAFKA-2561

** TLS 和 Kafka Source：**

请阅读配置Kafka客户端SSL中描述的步骤， 以了解用于微调的其他配置设置，例如以下任何一项：安全提供程序，密码套件，启用的协议，信任库或密钥库类型。

配置服务器端身份验证和数据加密的示例:

a1.sources.source1.type = org.apache.flume.source.kafka.KafkaSource
a1.sources.source1.kafka.bootstrap.servers = kafka-1:9093,kafka-2:9093,kafka-3:9093
a1.sources.source1.kafka.topics = mytopic
a1.sources.source1.kafka.consumer.group.id = flume-consumer
a1.sources.source1.kafka.consumer.security.protocol = SSL
# optional, the global truststore can be used alternatively
a1.sources.source1.kafka.consumer.ssl.truststore.location=/path/to/truststore.jks
a1.sources.source1.kafka.consumer.ssl.truststore.password=<password to access the truststore>

在此处指定信任库是可选的，可以使用全局信任库。有关全局SSL设置的更多详细信息，请参阅SSL / TLS支持部分

注意：默认情况下， 未定义属性ssl.endpoint.identification.algorithm，因此不会执行主机名验证。要启用主机名验证，请设置以下属性

a1.sources.source1.kafka.consumer.ssl.endpoint.identification.algorithm=HTTPS

启用后，客户端将根据以下两个字段之一验证服务器的完全限定域名（FQDN）：

1. 通用名称（CN）https://tools.ietf.org/html/rfc6125#section-2.3
2. 主题备选名称（SAN）https://tools.ietf.org/html/rfc5280#section-4.2.1.6

如果还需要客户端身份验证，则还需要将以下内容添加到Flume agent 配置中，或者可以使用全局SSL设置（请参阅SSL / TLS支持部分）。每个Flume agent 都必须拥有其客户证书，Kafka经纪人必须单独或通过其签名链来信任。常见示例是由单个根CA签署每个客户端证书，而后者又由Kafka经纪人信任。

# optional, the global keystore can be used alternatively
a1.sources.source1.kafka.consumer.ssl.keystore.location=/path/to/client.keystore.jks
a1.sources.source1.kafka.consumer.ssl.keystore.password=<password to access the keystore>

** Kerberos 和 Kafka source **

要将Kafka source与使用Kerberos保护的Kafka群集一起使用，请为消费者设置上面提到的consumer.security.protocol属性。与Kafka agent 一起使用的Kerberos密钥表和主体在JAAS文件的“KafkaClient”部分中指定。“客户端”部分描述了Zookeeper连接（如果需要）。有关 JAAS文件内容的信息，请参阅Kafka doc。可以通过flume-env.sh中的JAVA_OPTS指定此JAAS文件的位置以及可选的系统范围的kerberos配置：

JAVA_OPTS="$JAVA_OPTS -Djava.security.krb5.conf=/path/to/krb5.conf"
JAVA_OPTS="$JAVA_OPTS -Djava.security.auth.login.config=/path/to/flume_jaas.conf"

使用SASL_PLAINTEXT的示例安全配置：

a1.sources.source1.type = org.apache.flume.source.kafka.KafkaSource
a1.sources.source1.kafka.bootstrap.servers = kafka-1:9093,kafka-2:9093,kafka-3:9093
a1.sources.source1.kafka.topics = mytopic
a1.sources.source1.kafka.consumer.group.id = flume-consumer
a1.sources.source1.kafka.consumer.security.protocol = SASL_PLAINTEXT
a1.sources.source1.kafka.consumer.sasl.mechanism = GSSAPI
a1.sources.source1.kafka.consumer.sasl.kerberos.service.name = kafka

使用SASL_SSL的安全配置示例：

a1.sources.source1.type = org.apache.flume.source.kafka.KafkaSource
a1.sources.source1.kafka.bootstrap.servers = kafka-1:9093,kafka-2:9093,kafka-3:9093
a1.sources.source1.kafka.topics = mytopic
a1.sources.source1.kafka.consumer.group.id = flume-consumer
a1.sources.source1.kafka.consumer.security.protocol = SASL_SSL
a1.sources.source1.kafka.consumer.sasl.mechanism = GSSAPI
a1.sources.source1.kafka.consumer.sasl.kerberos.service.name = kafka
# optional, the global truststore can be used alternatively
a1.sources.source1.kafka.consumer.ssl.truststore.location=/path/to/truststore.jks
a1.sources.source1.kafka.consumer.ssl.truststore.password=<password to access the truststore>

示例JAAS文件。有关其内容的参考，请参阅SASL配置的 Kafka文档中所需认证机制（GSSAPI / PLAIN）的客户端配置部分。由于Kafka Source也可能连接到Zookeeper以进行偏移迁移，因此“Client”部分也添加到此示例中。除非您需要偏移迁移，否则不需要这样做，或者您需要此部分用于其他安全组件。另外，请确保Flume进程的操作系统用户对jaas和keytab文件具有读权限。

Client {
  com.sun.security.auth.module.Krb5LoginModule required
  useKeyTab=true
  storeKey=true
  keyTab="/path/to/keytabs/flume.keytab"
  principal="flume/flumehost1.example.com@YOURKERBEROSREALM";
};
 
KafkaClient {
  com.sun.security.auth.module.Krb5LoginModule required
  useKeyTab=true
  storeKey=true
  keyTab="/path/to/keytabs/flume.keytab"
  principal="flume/flumehost1.example.com@YOURKERBEROSREALM";
};

NetCat TCP source

类似于netcat的source，它侦听给定端口并将每行文本转换为event 。像nc -k -l [host] [port]这样的行为。换句话说，它打开一个指定的端口并监听数据。期望是提供的数据是换行符分隔的文本。每行文本都转换为Flume event ，并通过连接的channel发送。必需属性以 粗体显示

Property Name	Default	Description
channels	–
type	–	The component type name, needs to be netcat
bind	–	Host name or IP address to bind to
port	–	Port # to bind to
max-line-length	512	Max line length per event body (in bytes)
ack-every-event	true	Respond with an “OK” for every event received
selector.type	replicating	replicating or multiplexing
selector.*		Depends on the selector.type value
interceptors	–	Space-separated list of interceptors
interceptors.*

Example for agent named a1:

a1.sources = r1
a1.channels = c1
a1.sources.r1.type = netcat
a1.sources.r1.bind = 0.0.0.0
a1.sources.r1.port = 6666
a1.sources.r1.channels = c1

NetCat UDP source

根据原始的Netcat（TCP）source，该source监听给定端口并将每行文本转换为event 并通过连接的channel发送。像nc -u -k -l [host] [port]这样的行为。必需属性以 粗体显示

Property Name	Default	Description
channels	–
type	–	The component type name, needs to be netcatudp
bind	–	Host name or IP address to bind to
port	–	Port # to bind to
remoteAddressHeader	–
selector.type	replicating	replicating or multiplexing
selector.*		Depends on the selector.type value
interceptors	–	Space-separated list of interceptors
interceptors.*

agent 名为a1的示例：

a1.sources = r1
a1.channels = c1
a1.sources.r1.type = netcatudp
a1.sources.r1.bind = 0.0.0.0
a1.sources.r1.port = 6666
a1.sources.r1.channels = c1

Sequence Generator Source

一个简单的sequence 生成器，它使用从0开始的计数器连续生成event ，递增1并在totalEvents处停止。无法向channel 发送event 时重试。主要用于测试。在重试期间，它使重试消息的主体保持与以前相同，以便在目的地重复数据删除之后，唯一event 的数量应等于指定的totalEvents。必需属性以粗体显示

Property Name	Default	Description
channels	–
type	–	The component type name, needs to be seq
selector.type		replicating or multiplexing
selector.*	replicating	Depends on the selector.type value
interceptors	–	Space-separated list of interceptors
interceptors.*
batchSize	1	Number of events to attempt to process per request loop.
totalEvents	Long.MAX_VALUE	Number of unique events sent by the source.

Example for agent named a1:

a1.sources = r1
a1.channels = c1
a1.sources.r1.type = seq
a1.sources.r1.channels = c1

Syslog Source

读取syslog数据并生成Flume event 。UDP source将整个消息视为单个event 。TCPsource为每个由换行符（'n'）分隔的字符串创建一个新 event

必需属性以粗体显示

Syslog TCPsource

原始的，经过验证的syslog TCPsource代码

属性名称	默认	描述
channels	-
type	-	组件类型名称，需要是 syslogtcp
host	-	要绑定的主机名或IP地址
port	-	要绑定的端口号
eventSize	2500	单个event 行的最大大小（以字节为单位）
keepFields	none	将此设置为“all”将保留event 正文中的Priority，Timestamp和Hostname。还允许包含间隔开的字段列表。目前，可以包括以下字段：优先级，版本，时间戳，主机名。值'true'和'false'已被弃用，采用'all'和'none'。
clientIPHeader	-	如果指定，客户端的IP地址将使用此处指定的标头名称存储在每个event 的标头中。这允许拦截器和channel选择器基于客户端的IP地址定制路由逻辑。不要在此处使用标准Syslog标头名称（如_host_），因为在这种情况下将覆盖event 标头。
clientHostnameHeader	-	如果指定，则客户端的主机名将使用此处指定的标头名称存储在每个event 的标头中。这允许拦截器和channel选择器基于客户端的主机名自定义路由逻辑。检索主机名可能涉及名称服务反向查找，这可能会影响性能。不要在此处使用标准Syslog标头名称（如_host_），因为在这种情况下将覆盖event 标头。
selector.type		replicating or multiplexing
selector.*	replicating	取决于selector.type值
interceptors	-	以空格分隔的拦截器列表
interceptors.*
SSL	false	将其设置为true以启用SSL加密。如果启用了SSL，则还必须通过组件级参数（请参阅下文）或全局SSL参数（请参阅SSL / TLS支持部分）指定“密钥库”和“密钥库密码” 。
keystore	-	这是Java密钥库文件的路径。如果未在此处指定，则将使用全局密钥库（如果已定义，则配置错误）。
keystore-password	-	Java密钥库的密码。如果未在此处指定，则将使用全局密钥库密码（如果已定义，则配置错误）。
keystore-type	JKS	Java密钥库的类型。这可以是“JKS”或“PKCS12”。如果未在此处指定，则将使用全局密钥库类型（如果已定义，则默认为JKS）。
exclude-protocols	SSLv3	要排除的以空格分隔的SSL / TLS协议列表。除指定的协议外，将始终排除SSLv3。
include-protocols	-	要包含的以空格分隔的SSL / TLS协议列表。启用的协议将是包含的协议，没有排除的协议。如果包含协议为空，则它包括每个支持的协议。
exclude-cipher-suites	-	要排除的以空格分隔的密码套件列表。
include-cipher-suites	-	以空格分隔的密码套件列表。启用的密码套件将是包含的密码套件，不包括排除的密码套件。如果included-cipher-suites为空，则包含每个支持的密码套件。

For example, a syslog TCP source for agent named a1:

a1.sources = r1
a1.channels = c1
a1.sources.r1.type = syslogtcp
a1.sources.r1.port = 5140
a1.sources.r1.host = localhost
a1.sources.r1.channels = c1

多端口Syslog TCP source

这是Syslog TCPsource的更新，更快，多端口版本。请注意，端口配置设置已替换端口。多端口功能意味着它可以以有效的方式一次监听多个端口。此source使用Apache Mina库来执行此操作。提供对RFC-3164和许多常见RFC-5424格式消息的支持。还提供了配置基于每个端口的字符集的功能。

属性名称	默认	描述
channels	-
type	-	组件类型名称，需要是multiport_syslogtcp
host	-	要绑定的主机名或IP地址。
ports	-	要绑定到的空格分隔列表（一个或多个）。
eventSize	2500	单个event 行的最大大小（以字节为单位）。
keepFields	none	将此设置为“all”将保留event 正文中的Priority，Timestamp和Hostname。还允许包含间隔开的字段列表。目前，可以包括以下字段：优先级，版本，时间戳，主机名。值'true'和'false'已被弃用，采用'all'和'none'。
portHeader	-	如果指定，端口号将使用此处指定的标头名称存储在每个event 的标头中。这允许拦截器和channel选择器基于传入端口定制路由逻辑。
clientIPHeader	-	如果指定，客户端的IP地址将使用此处指定的标头名称存储在每个event 的标头中。这允许拦截器和channel选择器基于客户端的IP地址定制路由逻辑。不要在此处使用标准Syslog标头名称（如_host_），因为在这种情况下将覆盖event 标头。
clientHostnameHeader	-	如果指定，则客户端的主机名将使用此处指定的标头名称存储在每个event 的标头中。这允许拦截器和channel选择器基于客户端的主机名自定义路由逻辑。检索主机名可能涉及名称服务反向查找，这可能会影响性能。不要在此处使用标准Syslog标头名称（如_host_），因为在这种情况下将覆盖event 标头。
charset.default	UTF-8	将syslogevent 解析为字符串时使用的默认字符集。
charset.port	-	字符集可基于每个端口进行配置。
BATCHSIZE	100	每个请求循环尝试处理的最大event 数。使用默认值通常很好。
readBufferSize	1024	内部Mina读缓冲区的大小。提供性能调整。使用默认值通常很好。
numProcessors	（auto-detected）	处理消息时系统上可用的处理器数量。默认是使用Java Runtime API自动检测CPU数量。Mina将为每个检测到的CPU生成2个请求处理线程，这通常是合理的。
selector.type	replicating	replicating, multiplexing, or custom
selector.*	-	取决于selector.type值
interceptors	-	以空格分隔的拦截器列表。
interceptors.*
SSL	false	将其设置为true以启用SSL加密。如果启用了SSL，则还必须通过组件级参数（请参阅下文）或全局SSL参数（请参阅SSL / TLS支持部分）指定“密钥库”和“密钥库密码” 。
keystore	-	这是Java密钥库文件的路径。如果未在此处指定，则将使用全局密钥库（如果已定义，则配置错误）。
keystore-password	-	Java密钥库的密码。如果未在此处指定，则将使用全局密钥库密码（如果已定义，则配置错误）。
keystore-type	JKS	Java密钥库的类型。这可以是“JKS”或“PKCS12”。如果未在此处指定，则将使用全局密钥库类型（如果已定义，则默认为JKS）。
exclude-protocols	SSLv3	要排除的以空格分隔的SSL / TLS协议列表。除指定的协议外，将始终排除SSLv3。
include-protocols	-	要包含的以空格分隔的SSL / TLS协议列表。启用的协议将是包含的协议，没有排除的协议。如果包含协议为空，则它包括每个支持的协议。
exclude-cipher-suites	-	要排除的以空格分隔的密码套件列表。
include-cipher-suites	-	以空格分隔的密码套件列表。启用的密码套件将是包含的密码套件，不包括排除的密码套件。如果included-cipher-suites为空，则包含每个支持的密码套件。

For example, a multiport syslog TCP source for agent named a1:

a1.sources = r1
a1.channels = c1
a1.sources.r1.type = multiport_syslogtcp
a1.sources.r1.channels = c1
a1.sources.r1.host = 0.0.0.0
a1.sources.r1.ports = 10001 10002 10003
a1.sources.r1.portHeader = port

Syslog UDPsource

Property Name	Default	Description
channels	–
type	–	The component type name, needs to be syslogudp
host	–	Host name or IP address to bind to
port	–	Port # to bind to
keepFields	false	Setting this to true will preserve the Priority, Timestamp and Hostname in the body of the event.
clientIPHeader	–	If specified, the IP address of the client will be stored in the header of each event using the header name specified here. This allows for interceptors and channel selectors to customize routing logic based on the IP address of the client. Do not use the standard Syslog header names here (like _host_) because the event header will be overridden in that case.
clientHostnameHeader	–	If specified, the host name of the client will be stored in the header of each event using the header name specified here. This allows for interceptors and channel selectors to customize routing logic based on the host name of the client. Retrieving the host name may involve a name service reverse lookup which may affect the performance. Do not use the standard Syslog header names here (like _host_) because the event header will be overridden in that case.
selector.type		replicating or multiplexing
selector.*	replicating	Depends on the selector.type value
interceptors	–	Space-separated list of interceptors
interceptors.*

For example, a syslog UDP source for agent named a1:

a1.sources = r1
a1.channels = c1
a1.sources.r1.type = syslogudp
a1.sources.r1.port = 5140
a1.sources.r1.host = localhost
a1.sources.r1.channels = c1

HTTP Source<

通过HTTP POST和GET接受Flumeevent 的source。GET应仅用于实验。HTTP请求由可插入的“处理程序”转换为flume event ，该处理程序必须实现HTTPSourceHandler接口。该处理程序获取HttpServletRequest并返回flume event 列表。从一个Http请求处理的所有event 都在一个事务中提交给channel，从而允许在诸如文件channel之类的channel上提高效率。如果处理程序抛出异常，则此source将返回HTTP状态400.如果channel已满，或者source无法将event 附加到channel，则source将返回HTTP 503 - 暂时不可用状态

在一个发布请求中发送的所有event 都被视为一个批处理，并在一个事务中插入到channel中

此source基于Jetty 9.4，并提供了设置其他Jetty特定参数的功能，这些参数将直接传递给Jetty组件

属性名称	默认	描述
type		组件类型名称需要为http
port	-	source应绑定的端口。
bind	0.0.0.0	要侦听的主机名或IP地址
handler	org.apache.flume.source.http.JSONHandler	处理程序类的FQCN。
handler.*	-	配置处理程序的参数
selector.type	replicating	replicating or multiplexing
selector.*		取决于selector.type值
interceptors	-	以空格分隔的拦截器列表
interceptors.*
SSL	假	将属性设置为true，以启用SSL。HTTP Source不支持SSLv3。
exclude-protocols	在SSLv3	要排除的以空格分隔的SSL / TLS协议列表。除指定的协议外，将始终排除SSLv3。
include-protocols	-	要包含的以空格分隔的SSL / TLS协议列表。启用的协议将是包含的协议，没有排除的协议。如果包含协议为空，则它包括每个支持的协议。
exclude-cipher-suites	-	要排除的以空格分隔的密码套件列表。
include-cipher-suites	-	以空格分隔的密码套件列表。启用的密码套件将是包含的密码套件，不包括排除的密码套件。
keystore		密钥库的位置，包括密钥库文件名。如果启用了SSL但未在此处指定密钥库，则将使用全局密钥库（如果已定义，则配置错误）。
keystore-password		密钥库密码。如果启用了SSL但未在此处指定密钥库密码，则将使用全局密钥库密码（如果已定义，则配置错误）。
keystore-type	JKS	密钥库类型。这可以是“JKS”或“PKCS12”。
QueuedThreadPool.*		要在org.eclipse.jetty.util.thread.QueuedThreadPool上设置的Jetty特定设置。NB QueuedThreadPool仅在设置了此类的至少一个属性时使用。
HttpConfiguration.*		要在org.eclipse.jetty.server.HttpConfiguration上设置Jetty特定设置
SslContextFactory.*		要在org.eclipse.jetty.util.ssl.SslContextFactory上设置的Jetty特定设置（仅在ssl设置为true时适用）。
ServerConnector.*		要在org.eclipse.jetty.server.ServerConnector上设置的Jetty特定设置

不推荐使用的属性

物业名称	默认	描述
keystorePassword	-	使用密钥库密码。不推荐的值将被新的值覆盖。
excludeProtocols	SSLv3	使用exclude-protocols。不推荐的值将被新的值覆盖。
enableSSL	false	使用ssl。不推荐的值将被新的值覆盖。

NB使用上面列出的对象上的setter-methods设置Jetty特定设置。有关完整的详细信息，请参阅这些类的Javadoc（QueuedThreadPool， HttpConfiguration，SslContextFactory和 ServerConnector）

使用特定于Jetty的设置时，上面命名的属性将优先（例如，excludeProtocols将优先于SslContextFactory.ExcludeProtocols）。所有房产都是小写的。

An example http source for agent named a1:

a1.sources = r1
a1.channels = c1
a1.sources.r1.type = http
a1.sources.r1.port = 5140
a1.sources.r1.channels = c1
a1.sources.r1.handler = org.example.rest.RestHandler
a1.sources.r1.handler.nickname = random props
a1.sources.r1.HttpConfiguration.sendServerVersion = false
a1.sources.r1.ServerConnector.idleTimeout = 300

JSONHandler

开箱即用的处理程序可以处理以JSON格式表示的event ，并支持UTF-8，UTF-16和UTF-32字符集。处理程序接受一个event 数组（即使只有一个event ，event 必须在数组中发送），并根据请求中指定的编码将它们转换为Flumeevent 。如果未指定编码，则假定为UTF-8。JSON处理程序支持UTF-8，UTF-16和UTF-32。event 表示如下。

[{
  "headers" : {
             "timestamp" : "434324343",
             "host" : "random_host.example.com"
             },
  "body" : "random_body"
  },
  {
  "headers" : {
             "namenode" : "namenode.example.com",
             "datanode" : "random_datanode.example.com"
             },
  "body" : "really_random_body"
  }]

要设置charset，请求必须具有指定为application/json的 内容类型 ; charset = UTF-8（根据需要用UTF-16或UTF-32替换UTF-8）

以此处理程序所期望的格式创建event 的一种方法是使用Flume SDK中提供的JSONEvent并使用Google Gson使用Gson＃fromJson（Object，Type）方法创建JSON字符串。要作为event 列表的此方法的第二个参数传递的类型标记可以通过以下方式创建：

Type type = new TypeToken<List<JSONEvent>>() {}.getType();

BlobHandler

默认情况下，HTTPSource将JSON输入拆分为Flumeevent 。作为替代方案，BlobHandler是HTTPSource的处理程序，它返回包含请求参数的event 以及使用此请求上载的二进制大对象（BLOB）。例如PDF或JPG文件。请注意，此方法不适用于非常大的对象，因为它会将整个BLOB缓存在RAM中。

属性名称	默认	描述
handler	-	此类的FQCN：org.apache.flume.sink.solr.morphline.BlobHandler
handler.maxBlobLength	100000000	要读取的最大字节数和给定请求的缓冲区

Stress source

StressSource是一个内部负载生成source实现，对压力测试非常有用。它允许用户使用空标头配置event 有效负载的大小。用户可以配置要发送的event 总数以及要传递的最大成功event 数。

必需属性以粗体显示

物业名称	默认	描述
type	-	组件类型名称，需要是org.apache.flume.source.StressSource
size	500	每个event 的有效载荷大小。单位：字节
maxTotalEvents	-1	要发送的最大event 数
maxSuccessfulEvents	-1	成功发送的最大event 数
BATCHSIZE	1	一批中要发送的event 数
maxEventsPerSecond	0	设置为大于零的整数时，在source上强制执行速率限制。

Example for agent named a1:

a1.sources = stresssource-1
a1.channels = memoryChannel-1
a1.sources.stresssource-1.type = org.apache.flume.source.StressSource
a1.sources.stresssource-1.size = 10240
a1.sources.stresssource-1.maxTotalEvents = 1000000
a1.sources.stresssource-1.channels = memoryChannel-1

Legacy Sources

legacy source允许Flume 1.x agent 从Flume 0.9.4 agent 接收event 。它接受Flume 0.9.4格式的event ，将它们转换为Flume 1.0格式，并将它们存储在连接的channel中。0.9.4event 属性（如timestamp，pri，host，nanos等）将转换为1.xevent 头属性。旧版source支持Avro和Thrift RPC连接。要在两个Flume版本之间使用此桥接，您需要使用avroLegacy或thriftLegacysource启动Flume 1.x agent 。0.9.4 agent 应该让 agent Sink指向1.x agent 的主机/端口。

注意

Flume 1.x的可靠性语义与Flume 0.9.x的可靠性语义不同。旧版source不支持Flume 0.9.x agent 的E2E或DFO模式。唯一支持的0.9.x模式是尽力而为，尽管1.x流的可靠性设置将适用于传统source保存到Flume 1.xchannel后的event

必需属性以粗体显示

Avro Legacy Source

属性名称	默认	描述
channels	-
type	-	组件类型名称，需要是org.apache.flume.source.avroLegacy.AvroLegacySource
host	-	要绑定的主机名或IP地址
port	-	要听的端口＃
selector.type		replicating or multiplexing
selector.*	replicating	取决于selector.type值
interceptors	-	以空格分隔的拦截器列表
interceptors.*

Example for agent named a1:

a1.sources = r1
a1.channels = c1
a1.sources.r1.type = org.apache.flume.source.avroLegacy.AvroLegacySource
a1.sources.r1.host = 0.0.0.0
a1.sources.r1.bind = 6666
a1.sources.r1.channels = c1

Thrift Legacy Source

属性名称	默认	描述
channels	-
type	-	组件类型名称，需要是org.apache.flume.source.thriftLegacy.ThriftLegacySource
host	-	要绑定的主机名或IP地址
port	-	要听的端口＃
selector.type		replicating or multiplexing
selector.*	replicating	取决于selector.type值
interceptors	-	以空格分隔的拦截器列表
interceptors.*

Example for agent named a1:

a1.sources = r1
a1.channels = c1
a1.sources.r1.type = org.apache.flume.source.thriftLegacy.ThriftLegacySource
a1.sources.r1.host = 0.0.0.0
a1.sources.r1.bind = 6666
a1.sources.r1.channels = c1

Custom Source

自定义source是您自己的Source接口实现。启动Flume agent 时，自定义source的类及其依赖项必须包含在 agent 程序的类路径中。自定义source的类型是其FQCN。

属性名称	默认	描述
channels	-
type	-	组件类型名称，需要是您的FQCN
selector.type		replicating or multiplexing
selector.*	replicating	取决于selector.type值
interceptors	-	以空格分隔的拦截器列表
interceptors.*

Example for agent named a1:

a1.sources = r1
a1.channels = c1
a1.sources.r1.type = org.example.MySource
a1.sources.r1.channels = c1

Scribe Source

Scribe是另一种摄取系统。要采用现有的Scribe摄取系统，Flume应该使用基于Thrift的ScribeSource和兼容的传输协议。要部署Scribe，请遵循Facebook的指南。必需属性以粗体显示

属性名称	默认	描述
type	-	组件类型名称，需要是org.apache.flume.source.scribe.ScribeSource
port	1499	应该连接Scribe的端口
maxReadBufferBytes	16384000	Thrift默认FrameBuffer大小
workerThreads	5	在Thrift中处理线程数
selector.type
selector.*

Example for agent named a1:

a1.sources = r1
a1.channels = c1
a1.sources.r1.type = org.apache.flume.source.scribe.ScribeSource
a1.sources.r1.port = 1463
a1.sources.r1.workerThreads = 5
a1.sources.r1.channels = c1

Flume Sinks

HDFS Sink

此sink将event 写入Hadoop分布式文件系统（HDFS）。它目前支持创建文本和序列文件。它支持两种文件type的压缩。可以根据经过的时间或数据大小或event 数量定期滚动文件（关闭当前文件并创建新文件）。它还根据 event source自的时间戳或机器等属性对数据进行分区/分区。HDFS目录路径可能包含格式转义序列，将由HDFS sink 替换，以生成用于存储event 的目录/文件名。使用此sink需要安装hadoop，以便Flume可以使用Hadoop jar与HDFS集群进行通信。请注意，需要支持sync（）调用的Hadoop版本。

以下是支持的转义序列：

别号	描述
％{host}	名为“host”的event 标头的替换值。支持任意标题名称。
％T	Unix时间，以毫秒为单位
％a	locale的工作日短名称（周一，周二，......）
％A	locale的完整工作日名称（周一，周二......）
％b	locale的短月名（Jan，Feb，...）
％B	locale的长月名（1月，2月......）
％C	locale的日期和时间（2005年3月3日23:05:25）
％d	每月的一天（01）
％E	没有填充的月份日（1）
％d	日期; 与％m /％d /％y相同
％H	小时（00..23）
％I	小时（01..12）
％j	一年中的一天（001..366）
％K	小时（0..23）
％M	月（01..12）
％N	没有填充的月份（1..12）
％M	分钟（00..59）
％p	locale相当于am或pm
％S	自1970-01-01 00:00:00 UTC以来的秒数
％S	第二（00..59）
％Y	年份的最后两位数（00..99）
％Y	年（2010年）
％Z	+ hhmm数字时区（例如，-0400）
％[localhost]	替换运行 agent 程序的主机的hostname
％[IP]	替换运行 agent 程序的主机的IP地址
％[FQDN]	替换运行 agent 程序的主机的规范hostname

注意：转义字符串％[localhost]，％[IP]和％[FQDN]都依赖于Java获取hostname的能力，这在某些网络环境中可能会失败。

正在使用的文件将在名称末尾包含“.tmp”。文件关闭后，将删除此扩展程序。这允许排除目录中的部分完整文件。必需属性以粗体显示

注意

对于所有与时间相关的转义序列，event 标题中必须存在带有“timestamp”键的标头（除非hdfs.useLocalTimeStamp设置为true）。自动添加此方法的一种方法是使用TimestampInterceptor。

名称	默认	描述
channel	-
type	-	组件type名称，需要是hdfs
hdfs.path	-	HDFS目录路径（ eg hdfs://namenode/flume/webdata/  ）
hdfs.filePrefix	FlumeData	名称前缀为Flume在hdfs目录中创建的文件
hdfs.fileSuffix	-	附加到文件的后缀（例如.avro - 注意：不会自动添加句点）
hdfs.inUsePrefix	-	用于水槽主动写入的临时文件的前缀
hdfs.inUseSuffix	.TMP	用于临时文件的后缀，flume主动写入
hdfs.emptyInUseSuffix	false	如果为false，则在写入输出时使用hdfs.inUseSuffix。关闭输出后，hdfs.inUseSuffix将从输出文件名中删除。如果为true，则忽略hdfs.inUseSuffix参数，而是使用空字符串。
hdfs.rollInterval	30	滚动当前文件之前等待的秒数（0 =根据时间间隔从不滚动）
hdfs.rollSize	1024	触发滚动的文件大小，以字节为单位（0：永不基于文件大小滚动）
hdfs.rollCount	10	在滚动之前写入文件的event 数（0 =从不基于event 数滚动）
hdfs.idleTimeout	0	超时后非活动文件关闭（0 =禁用自动关闭空闲文件）
hdfs.batchSize	100	在将文件刷新到HDFS之前写入文件的event 数
hdfs.codeC	-	压缩编解码器。以下之一：gzip，bzip2，lzo，lzop，snappy
hdfs.fileType	SequenceFile	文件格式：当前SequenceFile，DataStream或CompressedStream （1）DataStream不会压缩输出文件，请不要设置codeC（2）CompressedStream需要使用可用的codeC设置hdfs.codeC
hdfs.maxOpenFiles	5000	仅允许此数量的打开文件。如果超过此数量，则关闭最旧的文件。
hdfs.minBlockReplicas	-	指定每个HDFS块的最小副本数。如果未指定，则它来自类路径中的默认Hadoop配置。
hdfs.writeFormat	可写	序列文件记录的格式。一个文本或可写。在使用Flume创建数据文件之前设置为Text，否则Apache Impala（孵化）或Apache Hive无法读取这些文件。
hdfs.threadsPoolSize	10	HDFS IO操作的每个HDFS  sink的线程数（open, write, etc. ）
hdfs.rollTimerPoolSize	1	每个HDFS sink用于调度定时文件滚动的线程数
hdfs.kerberosPrincipal	-	用于访问安全HDFS的Kerberos用户主体
hdfs.kerberosKeytab	-	用于访问安全HDFS的Kerberos密钥表
hdfs.proxyUser
hdfs.round	false	是否应将时间戳向下舍入（如果为true，则影响除％t之外的所有基于时间的转义序列）
hdfs.roundValue	1	舍入到此最高倍（在使用hdfs.roundUnit配置的单位中），小于当前时间。
hdfs.roundUnit	second	舍入值的单位 -  second, minute or hour.
hdfs.timeZone	Local Time	应该用于解析目录路径的时区名称，例如America/Los_Angeles。
hdfs.useLocalTimeStamp	false	替换转义序列时，请使用本地时间（而不是event 头中的时间戳）。
hdfs.closeTries	0	启动近距离尝试后，sink必须尝试重命名文件的次数。如果设置为1，则此sink将不会重新尝试失败的重命名（例如，由于NameNode或DataNode失败），并且可能使文件处于打开状态，扩展名为.tmp。如果设置为0，sink将尝试重命名该文件，直到最终重命名该文件（它将尝试的次数没有限制）。如果关闭调用失败但数据将保持不变，则文件可能仍保持打开状态，在这种情况下，只有在Flume重启后文件才会关闭。
hdfs.retryInterval	180	连续尝试关闭文件之间的时间（以秒为单位）。每次关闭调用都会花费多次RPC往返Namenode，因此将此设置得太低会导致名称节点上的大量负载。如果设置为0或更小，则如果第一次尝试失败，sink将不会尝试关闭文件，并且可能使文件保持打开状态或扩展名为“.tmp”。
serializer	TEXT	其他可能的选项包括avro_event或EventSerializer.Builder接口的实现的完全限定类名 。
serializer.*

不推荐使用的属性:

名称	默认	描述
hdfs.callTimeout	30000	HDFS操作允许的毫秒数，例如open，write，flush，close。 如果发生许多HDFS超时操作，则应增加此数量。

Example for agent named a1:

a1.channels = c1
a1.sinks = k1
a1.sinks.k1.type = hdfs
a1.sinks.k1.channel = c1
a1.sinks.k1.hdfs.path = /flume/events/%y-%m-%d/%H%M/%S
a1.sinks.k1.hdfs.filePrefix = events-
a1.sinks.k1.hdfs.round = true
a1.sinks.k1.hdfs.roundValue = 10
a1.sinks.k1.hdfs.roundUnit = minute

以上配置将时间戳向下舍入到最后10分钟。例如，时间戳为2012年6月12日上午11:54:34的event 将导致hdfs路径变为

/flume/events/2012-06-12/1150/00.

Hive Sink

此sink将包含分隔文本或JSON数据的event 直接流式传输到Hive表或分区。event 使用Hive事务编写。一旦将一组event 提交给Hive，它们就会立即显示给Hive查询。水槽将流入的分区既可以预先创建，也可以选择Flume创建它们，如果它们缺失的话。传入event 数据中的字段将映射到Hive表中的相应列

名称	默认	描述
channel	-
type	-	组件type名称需要是hive
hive.metastore	-	Hive Metastore URI（  eg thrift://a.b.com:9083  ）
hive.database	-	Hive数据库名称
hive.table	-	Hive表名
hive.partition	-	逗号分隔标识要写入的分区的分区值列表。可能包含转义序列。例如：如果表格被分区（大陆：字符串，国家：字符串，时间：字符串），那么'亚洲，印度，2014-02-26-01-21'将表示大陆=亚洲，国家=印度，时间= 2014 -02-26-01-21
hive.txnsPerBatchAsk	100	Hive向Flume等流媒体客户端授予一批交易而非单笔交易。此设置配置每个事务批处理所需的事务数。来自单个批次中所有事务的数据最终都在一个文件中。Flume将在批处理中的每个事务中写入最多batchSizeevent 。此设置与batchSize一起提供对每个文件大小的控制。请注意，最终Hive会将这些文件透明地压缩为更大的文件。
heartBeatInterval	240	（以秒为单位）发送到Hive的连续心跳之间的间隔，以防止未使用的事务过期。将此值设置为0可禁用心跳。
autoCreatePartitions	true	Flume将自动创建必要的Hive分区以进行流式传输
BATCHSIZE	15000	在单个Hive事务中写入Hive的最大event 数
maxOpenConnections	500	仅允许此数量的打开连接。如果超过此数量，则关闭最近最少使用的连接。
callTimeout	10000	（以毫秒为单位）Hive和HDFS   I/O操作的超时，例如openTxn，write，commit，abort。
serializer		Serializer负责解析event 中的字段并将它们映射到hive表中的列。serializer器的选择取决于event 中数据的格式。支持的序列化程序：DELIMITED和JSON
roundUnit	minute	舍入值的单位 - 秒，分钟或小时。
roundValue	1	舍入到此最高倍数（在使用hive.roundUnit配置的单位中），小于当前时间
时区	Local Time	应该用于解析分区中转义序列的时区名称，例如America / Los_Angeles。
useLocalTimeStamp	false	替换转义序列时，请使用本地时间（而不是event 头中的时间戳）。

为Hive sink提供了以下序列化程序：

JSON：处理UTF8编码的Json（严格语法）event ，不需要配置。JSON中的对象名称直接映射到Hive表中具有相同名称的列。内部使用org.apache.hive.hcatalog.data.JsonSerDe，但独立于Hive表的Serde。此序列化程序需要安装HCatalog。

DELIMITED：处理简单的分隔文本event 。内部使用LazySimpleSerde，但独立于Hive表的Serde。

名称	默认	描述
serializer.delimiter	，	（type：字符串）传入数据中的字段分隔符。要使用特殊字符，请用双引号括起来，例如“\t”
serializer.fieldnames	-	从输入字段到hive表中的列的映射。指定为hive表列名称的逗号分隔列表（无空格），按发生顺序标识输入字段。要跳过字段，请保留未指定的列名称。例如。'time ,, ip，message'表示输入映射到hive表中的time，ip和message列的第1，第3和第4个字段。
serializer.serdeSeparator	Ctrl-A	（type：字符）自定义基础serde使用的分隔符。如果serializer.fieldnames中的字段与表列的顺序相同，则serializer.delimiter与serializer.serdeSeparator相同，并且serializer.fieldnames中的字段数小于或等于表的数量，可以提高效率列，因为传入event 正文中的字段不需要重新排序以匹配表列的顺序。对于'\t'这样的特殊字符使用单引号。确保输入字段不包含此字符。注意：如果serializer.delimiter是单个字符，最好将其设置为相同的字符

以下是支持的转义序列：

别号	描述
％{host}	名为“host”的event 标头的替换值。支持任意标题名称。
％T	Unix时间，以毫秒为单位
％a	locale的工作日短名称（周一，周二，......）
％A	locale的完整工作日名称（周一，周二......）
％b	locale的短月名（Jan，Feb，...）
％B	locale的长月名（1月，2月......）
％C	locale的日期和时间（2005年3月3日23:05:25）
％d	每月的一天（01）
％d	日期; 与％m /％d /％y相同
％H	小时（00..23）
％I	小时（01..12）
％j	一年中的一天（001..366）
％K	小时（0..23）
％M	月（01..12）
％M	分钟（00..59）
％p	locale相当于am或pm
％S	自1970-01-01 00:00:00 UTC以来的秒数
％S	第二（00..59）
％Y	年份的最后两位数（00..99）
％Y	年（2010年）
％Z	+ hhmm 数字时区（例如，-0400）

注意

对于所有与时间相关的转义序列，event 标题中必须存在具有键“timestamp”的标头（除非useLocalTimeStamp设置为true）。自动添加此方法的一种方法是使用TimestampInterceptor。

示例Hive表：

create table weblogs ( id int , msg string )
    partitioned by (continent string, country string, time string)
    clustered by (id) into 5 buckets
    stored as orc;

Example for agent named a1:

a1.channels = c1
a1.channels.c1.type = memory
a1.sinks = k1
a1.sinks.k1.type = hive
a1.sinks.k1.channel = c1
a1.sinks.k1.hive.metastore = thrift://127.0.0.1:9083
a1.sinks.k1.hive.database = logsdb
a1.sinks.k1.hive.table = weblogs
a1.sinks.k1.hive.partition = asia,%{country},%y-%m-%d-%H-%M
a1.sinks.k1.useLocalTimeStamp = false
a1.sinks.k1.round = true
a1.sinks.k1.roundValue = 10
a1.sinks.k1.roundUnit = minute
a1.sinks.k1.serializer = DELIMITED
a1.sinks.k1.serializer.delimiter = "\t"
a1.sinks.k1.serializer.serdeSeparator = '\t'
a1.sinks.k1.serializer.fieldnames =id,,msg

以上配置将时间戳向下舍入到最后10分钟。例如，将时间戳标头设置为2012年6月12日上午11:54:34且“country”标头设置为“india”的event 将评估为分区（continent ='asia'，country ='india'，time ='2012-06-12-11-50'。序列化程序配置为接受包含三个字段的制表符分隔输入并跳过第二个字段。

Logger Sink

在INFO级别记录event 。通常用于测试/调试目的。必需属性以粗体显示。此sink是唯一的例外，它不需要在“ 记录原始数据”部分中说明的额外配置。

属性名称	默认	描述
channel	-
type	-	组件type名称，需要是  logger
maxBytesToLog	16	要记录的event 主体的最大字节数

Example for agent named a1:

a1.channels = c1
a1.sinks = k1
a1.sinks.k1.type = logger
a1.sinks.k1.channel = c1

Avro Sink

这个Sink形成了Flume的分层收集支持的一半。发送到此sink的Flume event 将转换为Avro event 并发送到配置的hostname/port  pair 。event 将从配置的channel中批量获取配置的批处理大小。必需属性以粗体显示

属性名称	默认	描述
channel	-
type	-	组件type名称，需要是avro。
hostname	-	要绑定的hostname或IP地址。
port	-	要听的端口＃。
batch-size	100	要一起批量发送的event 数。
connect-timeout	20000	允许第一个（握手）请求的时间量（ms）。
request-timeout	20000	在第一个之后允许请求的时间量（ms）。
reset-connection-interval	none	重置连接到下一跳之前的时间量。这将迫使Avro Sink重新连接到下一跳。这将允许sink在添加新闻主机时连接到硬件负载平衡器后面的主机，而无需重新启动 agent 。
compression-type	none	这可以是“ none ”或“  deflate ”。压缩type必须与匹配AvroSource的压缩type匹配
compression-level	6	压缩event 的压缩级别。0 =无压缩，1-9是压缩。数字越大，压缩越多
SSL	false	设置为true以启用此AvroSink的SSL。配置SSL时，您可以选择设置“truststore”，“truststore-password”，“truststore-type”，并指定是否“trust-all-certs”。
trust-all-certs	false	如果将此设置为true，则不会检查远程服务器（Avrosource）的SSL服务器证书。这不应该在生产中使用，因为它使攻击者更容易执行中间人攻击并“监听”加密连接。
truststore	-	自定义Java信任库文件的路径。Flume使用此文件中的证书颁发机构信息来确定是否应该信任远程Avro Source的SSL身份验证凭据。如果未指定，则将使用全局密钥库。如果未指定全局密钥库，则将使用缺省Java JSSE证书颁发机构文件（通常为Oracle JRE中的“jssecacerts”或“cacerts”）。
truststore-password	-	信任库的密码。如果未指定，则将使用全局密钥库密码（如果已定义）。
truststore-type	JKS	Java信任库的type。这可以是“JKS”或其他受支持的Java信任库type。如果未指定，则将使用全局密钥库type（如果已定义，则defautl为JKS）。
exclude-protocols	在SSLv3	要排除的以空格分隔的SSL/TLS协议列表。除指定的协议外，将始终排除SSLv3。
maxIoWorkers	2 *机器中可用处理器的数量	I / O工作线程的最大数量。这是在NettyAvroRpcClient NioClientSocketChannelFactory上配置的。

Example for agent named a1:

a1.channels = c1
a1.sinks = k1
a1.sinks.k1.type = avro
a1.sinks.k1.channel = c1
a1.sinks.k1.hostname = 10.10.10.10
a1.sinks.k1.port = 4545

Thrift Sink

这个水槽形成了Flume的分层收集支持的一半。发送到此sink的Flume event 将转换为Thrift event 并发送到配置的hostname/port pair。event 将从配置的channel中批量获取配置的批处理大小。

可以通过启用kerberos身份验证将Thrift sink配置为以安全模式启动。要与以安全模式启动的Thriftsource通信，Thriftsink也应该以安全模式运行。client-principal和client-keytab是Thriftsink用于向kerberos KDC进行身份验证的属性。server-principal表示Thriftsource的主体，此sink配置为以安全模式连接。必需属性以粗体显示

属性名称	默认	描述
channel	-
type	-	组件type名称，需要节俭。
hostname	-	要绑定的hostname或IP地址。
port	-	要听的端口＃。
batch-size	100	要一起批量发送的event 数。
connect-timeout	20000	允许第一个（握手）请求的时间量（ms）。
request-timeout	20000	在第一个之后允许请求的时间量（ms）。
connection-reset-interval	none	重置连接到下一跳之前的时间量。这将迫使Thrift Sink重新连接到下一跳。这将允许sink在添加新闻主机时连接到硬件负载平衡器后面的主机，而无需重新启动 agent 。
SSL	false	设置为true以为此ThriftSink启用SSL。配置SSL时，您可以选择设置“truststore”，“truststore-password”和“truststore-type”
truststore	-	自定义Java信任库文件的路径。Flume使用此文件中的证书颁发机构信息来确定是否应该信任远程Thrift Source的SSL身份验证凭据。如果未指定，则将使用全局密钥库。如果未指定全局密钥库，则将使用缺省Java JSSE证书颁发机构文件（通常为Oracle JRE中的“jssecacerts”或“cacerts”）。
truststore-password	-	信任库的密码。如果未指定，则将使用全局密钥库密码（如果已定义）。
truststore-type	JKS	Java信任库的type。这可以是“JKS”或其他受支持的Java信任库type。如果未指定，则将使用全局密钥库type（如果已定义，则defautl为JKS）。
exclude-protocols	SSLv3	要排除的以空格分隔的SSL / TLS协议列表
Kerberos的	false	设置为true以启用kerberos身份验证。在kerberos模式下，需要client-principal，client-keytab和server-principal才能成功进行身份验证并与启用kerberos的Thrift Source进行通信。
client-principal	-	Thrift Sink使用的kerberos校长对kerberos KDC进行身份验证。
client-keytab	-	Thrift Sink与客户端主体结合使用的keytab位置，用于对kerberos KDC进行身份验证。
server-principal	-	Thrift Sink配置为连接到的Thrift Source的kerberos主体。

Example for agent named a1:

a1.channels = c1
a1.sinks = k1
a1.sinks.k1.type = thrift
a1.sinks.k1.channel = c1
a1.sinks.k1.hostname = 10.10.10.10
a1.sinks.k1.port = 4545

IRC Sink

IRC sink从附加channel接收消息，并将这些消息中继到已配置的IRC目标。必需属性以粗体显示

属性名称	默认	描述
channel	-
type	-	组件type名称，需要是irc
hostname	-	要连接的hostname或IP地址
port	6667	要连接的远程主机的端口号
nick	-	昵称
user	-	用户名
password	-	用户密码
chan	-	channel
name
splitlines	-	（布尔值）
splitChars中	n	行分隔符（如果你要在配置文件中输入默认值，那么你需要转义反斜杠，如下所示：“\ n”）

Example for agent named a1:

a1.channels = c1
a1.sinks = k1
a1.sinks.k1.type = irc
a1.sinks.k1.channel = c1
a1.sinks.k1.hostname = irc.yourdomain.com
a1.sinks.k1.nick = flume
a1.sinks.k1.chan = #flume

File Roll Sink

在本地文件系统上存储event 。必需属性以粗体显示

属性名称	默认	描述
channel	-
type	-	组件type名称，需要是file_roll。
sink.directory	-	将存储文件的目录
sink.pathManager	DEFAULT	要使用的PathManager实现。
sink.pathManager.extension	-	如果使用默认的PathManager，则为文件扩展名。
sink.pathManager.prefix	-	如果使用默认PathManager，则添加到文件名开头的字符串
sink.rollInterval	30	每30秒滚动一次文件。指定0将禁用滚动并导致所有event 都写入单个文件。
sink.serializer	TEXT	其他可能的选项包括avro_event或EventSerializer.Builder接口实现的FQCN。
sink.batchSize	100

Example for agent named a1:

a1.channels = c1
a1.sinks = k1
a1.sinks.k1.type = file_roll
a1.sinks.k1.channel = c1
a1.sinks.k1.sink.directory = /var/log/flume

Null Sink

丢弃从channel收到的所有event 。必需属性以粗体显示

属性名称	默认	描述
channel	-
type	-	组件type名称必须为null。
BATCHSIZE	100

Example for agent named a1:

a1.channels = c1
a1.sinks = k1
a1.sinks.k1.type = null
a1.sinks.k1.channel = c1

HBase Sink

此sink将数据写入HBase。Hbase配置是从类路径中遇到的第一个hbase-site.xml中获取的。实现由配置指定的HbaseEventSerializer的类用于将event 转换为HBase put和/或 increments 。然后将这些put 和increments 写入HBase。该sink提供与HBase相同的一致性保证，HBase是当前行的原子性。如果Hbase无法写入某些event ，则sink将重播该事务中的所有event

HBase Sink支持将数据写入安全HBase。要写入安全HBase， agent 程序正在运行的用户必须具有对sink配置为写入的表的写入权限。可以在配置中指定用于对KDC进行身份验证的主体和密钥表。Flume agent 程序类路径中的hbase-site.xml必须将身份验证设置为kerberos（有关如何执行此操作的详细信息，请参阅HBase文档）

为方便起见，Flume提供了两个序列化器。

SimpleHbaseEventSerializer（org.apache.flume.sink.hbase.SimpleHbaseEventSerializer）按原样将event 主体写入HBase，并可选择增加Hbase中的列。这主要是一个示例实现。

RegexHbaseEventSerializer（org.apache.flume.sink.hbase.RegexHbaseEventSerializer）根据给定的正则表达式打破event 体，并将每个部分写入不同的列。

type是FQCN：org.apache.flume.sink.hbase.HBaseSink。

必需属性以粗体显示

属性名称	默认	描述
channel	-
type	-	组件type名称，需要是hbase
table	-	Hbase中要写入的表的名称。
ColumnFamily	-	Hbase中的列族写入。
zookeeperQuorum	-	法定人数规格。这是hbase-site.xml中属性hbase.zookeeper.quorum的值
znodeParent	/hbase	-ROOT-区域的znode的基本路径。价值zookeeper.znode.parent在HBase的-site.xml中
BATCHSIZE	100	每个txn要写入的event 数。
coalesceIncrements	false	如果sink将多个增量合并到每个批次的单元格中。如果有限数量的单元格有多个增量，这可能会提供更好的性能。
serializer	org.apache.flume.sink.hbase.SimpleHbaseEventSerializer	默认增量列=“iCol”，有效负载列=“pCol”。
serializer.*	-	要传递给序列化程序的属性。
kerberosPrincipal	-	用于访问安全HBase的Kerberos用户主体
kerberosKeytab	-	用于访问安全HBase的Kerberos密钥表

Example for agent named a1:

a1.channels = c1
a1.sinks = k1
a1.sinks.k1.type = hbase
a1.sinks.k1.table = foo_table
a1.sinks.k1.columnFamily = bar_cf
a1.sinks.k1.serializer = org.apache.flume.sink.hbase.RegexHbaseEventSerializer
a1.sinks.k1.channel = c1

HBase2 Sink

HBase2Sink相当于HBase版本2的HBaseSink。提供的功能和配置参数与HBaseSink的情况相同（除了sinktype中的hbase2标签和包/类名称）

type是FQCN：org.apache.flume.sink.hbase2.HBase2Sink

必需属性以粗体显示

属性名称	默认	描述
channel	-
type	-	组件type名称，需要是hbase2
table	-	HBase中要写入的表的名称。
ColumnFamily	-	HBase中的列族写入。
zookeeperQuorum	-	这是hbase-site.xml中属性hbase.zookeeper.quorum的值
znodeParent	/hbase	-ROOT-区域的znode的基本路径。价值zookeeper.znode.parent在HBase的-site.xml中
BATCHSIZE	100	每个txn要写入的event 数。
coalesceIncrements	false	如果sink将多个增量合并到每个批次的单元格中。如果有限数量的单元格有多个增量，这可能会提供更好的性能。
serializer	org.apache.flume.sink.hbase2.SimpleHBase2EventSerializer	默认增量列=“iCol”，有效负载列=“pCol”。
serializer.*	-	要传递给序列化程序的属性。
kerberosPrincipal	-	用于访问安全HBase的Kerberos用户主体
kerberosKeytab	-	用于访问安全HBase的Kerberos密钥表

Example for agent named a1:

a1.channels = c1
a1.sinks = k1
a1.sinks.k1.type = hbase2
a1.sinks.k1.table = foo_table
a1.sinks.k1.columnFamily = bar_cf
a1.sinks.k1.serializer = org.apache.flume.sink.hbase2.RegexHBase2EventSerializer
a1.sinks.k1.channel = c1

AsyncHBaseSink

此sink使用异步模型将数据写入HBase。实现由配置指定的AsyncHbaseEventSerializer的类用于将event 转换为HBase put和/或 increments。然后将这些放置和增量写入HBase。此sink使用Asynchbase API写入HBase。该sink提供与HBase相同的一致性保证，HBase是当前行的原子性。如果Hbase无法写入某些event ，则sink将重播该事务中的所有event 。AsyncHBaseSink只能与HBase 1.x一起使用。AsyncHBaseSink使用的异步客户端库不适用于HBase 2.type为FQCN：org.apache.flume.sink.hbase.AsyncHBaseSink。必需属性以粗体显示

属性名称	默认	描述
channel	-
type	-	组件type名称，需要是asynchbase
table	-	Hbase中要写入的表的名称。
zookeeperQuorum	-	法定人数规格。这是hbase-site.xml中属性hbase.zookeeper.quorum的值
znodeParent	/hbase	-ROOT-区域的znode的基本路径。价值zookeeper.znode.parent在HBase的-site.xml中
ColumnFamily	-	Hbase中的列族写入。
batchSize	100	每个txn要写入的event 数。
coalesceIncrements	false	如果sink将多个增量合并到每个批次的单元格中。如果有限数量的单元格有多个增量，这可能会提供更好的性能。
timeout	60000	sink为事务中的所有event 等待来自hbase的acks的时间长度（以毫秒为单位）。
serializer	org.apache.flume.sink.hbase.SimpleAsyncHbaseEventSerializer
serializer.*	-	要传递给序列化程序的属性。
async.*	-	要传递给asyncHbase库的属性。这些属性优先于旧的zookeeperQuorum和znodeParent值。您可以在AsyncHBase的文档页面中找到可用属性的列表 。

请注意，此sink在配置中获取Zookeeper Quorum和父znode信息。可以在flume配置文件中指定Zookeeper Quorum和父节点配置。或者，这些配置值取自类路径中的第一个hbase-site.xml文件。

如果配置中未提供这些，则sink将从类路径中的第一个hbase-site.xml文件中读取此信息。

Example for agent named a1:

a1.channels = c1
a1.sinks = k1
a1.sinks.k1.type = asynchbase
a1.sinks.k1.table = foo_table
a1.sinks.k1.columnFamily = bar_cf
a1.sinks.k1.serializer = org.apache.flume.sink.hbase.SimpleAsyncHbaseEventSerializer
a1.sinks.k1.channel = c1

MorphlineSolrSink

此sink从Flume event 中提取数据，对其进行转换，并将其近乎实时地加载到Apache Solr服务器中，后者又向最终用户或搜索应用程序提供查询.

此sink非常适合将原始数据流式传输到HDFS（通过HdfsSink）并同时提取，转换并将相同数据加载到Solr（通过MorphlineSolrSink）的用例。特别是，此sink可以处理来自不同数据source的任意异构原始数据，并将其转换为对搜索应用程序有用的数据模型

ETL功能可使用morphline配置文件进行自定义，该文件定义了一系列转换命令，用于将event 记录从一个命令传递到另一个命令

Morphlines可以看作是Unix管道的演变，其中数据模型被推广为使用通用记录流，包括任意二进制有效载荷。morphline命令有点像Flume拦截器。Morphlines可以嵌入到Flume等Hadoop组件中。

用于解析和转换一组标准数据格式（如日志文件，Avro，CSV，文本，HTML，XML，PDF，Word，Excel等）的命令是开箱即用的，还有其他自定义命令和解析器用于其他数据格式可以添加为morphline插件。可以索引任何type的数据格式，并且可以生成任何type的Solr模式的任何Solr文档，并且可以注册和执行任何自定义ETL逻辑。

Morphlines操纵连续的记录流。数据模型可以描述如下：记录是一组命名字段，其中每个字段具有一个或多个值的有序列表。值可以是任何Java对象。也就是说，记录本质上是一个哈希表，其中每个哈希表条目包含一个String键和一个Java对象列表作为值。（该实现使用Guava的ArrayListMultimap，它是一个ListMultimap）。请注意，字段可以具有多个值，并且任何两个记录都不需要使用公共字段名称。

这个sink将Flumeevent 的主体填充到_attachment_body中记录字段中，并将Flumeevent 的标头复制到同名的记录字段中。然后命令可以对此数据执行操作。

支持路由到SolrCloud集群以提高可伸缩性。索引负载可以分布在大量MorphlineSolrSink上，以提高可伸缩性。可以跨多个MorphlineSolrSink复制索引负载以实现高可用性，例如使用Flume功能，例如负载平衡sink处理器。MorphlineInterceptor还可以帮助实现到多个Solr集合的动态路由（例如，用于多租户）

必须将环境所需的morphline和solr jar放在Apache Flume安装的lib目录中。

type是FQCN：org.apache.flume.sink.solr.morphline.MorphlineSolrSink

必需属性以粗体显示

属性名称	默认	描述
channel	-
type	-	组件type名称，需要是org.apache.flume.sink.solr.morphline.MorphlineSolrSink
morphlineFile	-	本地文件系统与morphline配置文件的相对或绝对路径。示例：/etc/flume-ng/conf/morphline.conf
morphlineId	null	如果morphline配置文件中有多个morphlines，则用于标识morphline的可选名称
batchSize	1000	每个水槽事务要采取的最大event 数。
batchDurationMillis	1000	每个水槽事务的最大持续时间（ms）。事务在此持续时间之后或超过batchSize时提交，以先到者为准。
handlerClass	org.apache.flume.sink.solr.morphline.MorphlineHandlerImpl	实现org.apache.flume.sink.solr.morphline.MorphlineHandler的类的FQCN
isProductionMode	false	应该为关键任务，大规模在线生产系统启用此标志，这些系统需要在发生不可恢复的异常时无需停机即可取得进展。与未知Solr架构字段相关的损坏或格式错误的解析器输入数据，解析器错误和错误会产生不可恢复的异常。
recoverableExceptionClasses	org.apache.solr.client.solrj.SolrServerException	以逗号分隔的可恢复异常列表，这些异常往往是暂时的，在这种情况下，可以重试相应的任务。示例包括网络连接错误，超时等。当生产模式标志设置为true时，使用此参数配置的可恢复异常将不会被忽略，因此将导致重试。
isIgnoringRecoverableExceptions	false	如果不可恢复的异常被意外错误分类为可恢复，则应启用此标志。这使得sink能够取得进展并避免永远重试event 。

Example for agent named a1:

a1.channels = c1
a1.sinks = k1
a1.sinks.k1.type = org.apache.flume.sink.solr.morphline.MorphlineSolrSink
a1.sinks.k1.channel = c1
a1.sinks.k1.morphlineFile = /etc/flume-ng/conf/morphline.conf
# a1.sinks.k1.morphlineId = morphline1
# a1.sinks.k1.batchSize = 1000
# a1.sinks.k1.batchDurationMillis = 1000

ElasticSearchSink

此sink将数据写入弹性搜索集群。默认情况下，将写入event 以便Kibana图形界面可以显示它们 - 就像logstash一样编写它们一样

必须将环境所需的elasticsearch和lucene-core jar放在Apache Flume安装的lib目录中。Elasticsearch要求客户端JAR的主要版本与服务器的主要版本匹配，并且两者都运行相同的JVM次要版本。如果这不正确，将出现SerializationExceptions。要选择所需的版本，请首先确定elasticsearch的版本以及目标群集正在运行的JVM版本。然后选择与主要版本匹配的elasticsearch客户端库。0.19.x客户端可以与0.19.x群集通信; 0.20.x可以与0.20.x对话，0.90.x可以与0.90.x对话。确定elasticsearch版本后，读取pom.xml文件以确定要使用的正确lucene-core JAR版本。

event 将每天写入新索引。名称将是<indexName> -yyyy-MM-dd，其中<indexName>是indexName参数。sink将在午夜UTC开始写入新索引。

默认情况下，ElasticSearchLogStashEventSerializer会为弹性搜索序列化event 。可以使用serializer参数覆盖此行为。此参数接受org.apache.flume.sink.elasticsearch.ElasticSearchEventSerializer或org.apache.flume.sink.elasticsearch.ElasticSearchIndexRequestBuilderFactory的实现。不推荐使用ElasticSearchEventSerializer来支持更强大的ElasticSearchIndexRequestBuilderFactory

type是FQCN：org.apache.flume.sink.elasticsearch.ElasticSearchSink

必需属性以粗体显示

属性名称	默认	描述
channel	-
type	-	组件type名称，需要是org.apache.flume.sink.elasticsearch.ElasticSearchSink
hostname	-	逗号分隔的hostname：port列表，如果端口不存在，将使用默认端口'9300'
indexName	flume	将附加日期的索引的名称。示例'flume' - >'flume-yyyy-MM-dd'支持任意标题替换，例如。％{header}替换为命名event 标头的值
indexType	logs	索引文档的type，默认为'log'支持任意标头替换，例如。％{header}替换为命名event 标头的值
clusterName	elasticsearch	要连接的ElasticSearch集群的名称
batchSize	100	每个txn要写入的event 数。
ttl	-	TTL以天为单位，设置时会导致过期文档自动删除，如果没有设置，文档将永远不会被自动删除。TTL在早期的整数形式中都被接受，例如a1.sink.k1.ttl = 5，还有限定符ms（毫秒），s（秒），m（分钟），h（小时），d（天）和w（周）。示例a1.sink.k1.ttl = 5d将TTL设置为5天。按照http://www.elasticsearch.org/guide/reference/mapping/ttl-field/以获取更多信息。
serializer	org.apache.flume.sink.elasticsearch.ElasticSearchLogStashEventSerializer	要使用的ElasticSearchIndexRequestBuilderFactory或ElasticSearchEventSerializer。接受任一类的实现，但首选ElasticSearchIndexRequestBuilderFactory。
serializer.*	-	要传递给序列化程序的属性。

注意

使用标头替换可以方便地使用event 标头的值来动态决定在存储event 时要使用的indexName和indexType。使用此功能时应谨慎，因为event 提交者现在可以控制indexName和indexType。此外，如果使用elasticsearch REST客户端，则event 提交者可以控制所使用的URL路径

Example for agent named a1:

a1.channels = c1
a1.sinks = k1
a1.sinks.k1.type = elasticsearch
a1.sinks.k1.hostNames = 127.0.0.1:9200,127.0.0.2:9300
a1.sinks.k1.indexName = foo_index
a1.sinks.k1.indexType = bar_type
a1.sinks.k1.clusterName = foobar_cluster
a1.sinks.k1.batchSize = 500
a1.sinks.k1.ttl = 5d
a1.sinks.k1.serializer = org.apache.flume.sink.elasticsearch.ElasticSearchDynamicSerializer
a1.sinks.k1.channel = c1

Kite Dataset Sink

将event 写入Kite数据集的实验sink。此sink将反序列化每个传入event 的主体，并将结果记录存储在风筝数据集中。它通过按URI加载数据集来确定目标数据集。

唯一支持的序列化的Avro和记录模式必须在event 标题使用或者被通过，flume.avro.schema.literal与JSON模式表示或flume.avro.schema.url有一个网址，该模式可能会发现（hdfs：/ ...支持URI）。这与使用deserializer.schemaType = LITERAL的Log4jAppender水槽客户端和false脱机目录source的Avro反序列化器 兼容。

注1：不支持flume.avro.schema.hash标头。注意2：在某些情况下，在超过滚动间隔后可能会略微发生文件滚动。但是，此延迟不会超过5秒。在大多数情况下，延迟是可以忽略的。

属性名称	默认	描述
channel	-
type	-	必须是org.apache.flume.sink.kite.DatasetSink
kite.dataset.uri	-	要打开的数据集的URI
kite.repo.uri	-	要打开的存储库的URI（不建议使用;请改用kite.dataset.uri）
kite.dataset.namespace	-	数据集的命名空间，其中将写入记录（不建议使用;请改用kite.dataset.uri）
kite.dataset.name	-	将写入记录的数据集的名称（不建议使用;请改用kite.dataset.uri）
kite.batchSize	100	每批中要处理的记录数
kite.rollInterval	30	释放数据文件之前的最长等待时间（秒）
kite.flushable.commitOnBatch	true	如果为true，将提交Flume事务，并在每批kite.batchSize 记录上刷新writer。此设置仅适用于可刷新数据集。如果为 true，则可以将具有提交数据的临时文件保留在数据集目录中。需要手动恢复这些文件，以使数据对DatasetReaders可见。
kite.syncable.syncOnBatch	true	控制sink在提交事务时是否也将同步数据。此设置仅适用于可同步数据集。同步gaurentees数据将写入远程系统上的稳定存储，同时只刷新数据已离开Flume的客户端缓冲区的gaurentees。当kite.flushable.commitOnBatch属性设置为false时，此属性也必须设置为false。
kite.entityParser	Avro	将Flume Events变为Kite实体的Parser 。有效值是avro和EntityParser.Builder接口的实现的完全限定类名。
kite.failurePolicy	retry	政策处理不可恢复的错误，如缺少 架构在event 头。默认值retry将使当前批处理失败，并再次尝试与旧行为匹配。其他有效值是保存，这将写原始event 到kite.error.dataset.uri数据集，以及一个实现的完全限定类名FailurePolicy.Builder接口。
kite.error.dataset.uri	-	当kite.failurePolicy设置为save时，保存失败event 的数据集的URI 。需要的时候kite.failurePolicy设置为保存。
auth.kerberosPrincipal	-	用于HDFS安全身份验证的Kerberos用户主体
auth.kerberosKeytab	-	主体的Kerberos keytab位置（本地FS）
auth.proxyUser	-	HDFS操作的有效用户，如果与kerberos主体不同

Kafka Sink

这是一个Flume Sink实现，可以将数据发布到 Kafka主题。其中一个目标是将Flume与Kafka集成，以便基于拉的处理系统可以处理来自各种Flume source的数据。

这目前支持Kafka服务器版本0.10.1.0或更高版本。测试完成了2.0.1，这是发布时最高的可用版本

必需属性以粗体字体标记

属性名称	默认	描述
type	-	必须设置为org.apache.flume.sink.kafka.KafkaSink
kafka.bootstrap.servers	-	Kafka-Sink将连接到的经纪人列表，以获取主题分区列表这可以是经纪人的部分列表，但我们建议至少两个用于HA。格式为逗号分隔的hostname：port列表
kafka.topic	default-flume-topic	Kafka中将发布消息的主题。如果配置了此参数，则会将消息发布到此主题。如果event 标头包含“主题”字段，则event 将发布到该主题，从而覆盖此处配置的主题。支持任意头部替换，例如。％{header}将替换为名为“header”的event 标头的值。（如果使用替换，建议将Kafka agent 的“auto.create.topics.enable”属性设置为true。）
flumeBatchSize	100	一批中要处理的消息数。较大批量可提高吞吐量，同时增加延迟。
kafka.producer.acks	1	在考虑成功写入之前，有多少副本必须确认消息。接受的值为0（从不等待确认），1（仅等待前导），-1（等待所有副本）将此值设置为-1，以避免在某些领导失败的情况下丢失数据。
useFlumeEventFormat	false	默认情况下，event 直接从event 主体作为字节放到Kafka主题上。设置为true以将event 存储为Flume Avro二进制格式。与KafkaSource上的相同属性或Kafka Channel上的parseAsFlumeEvent属性一起使用时，这将保留生成端的任何Flume头。
defaultPartitionId	-	指定要发送到此channel中的所有event 的Kafka分区ID（整数），除非被partitionIdHeader覆盖。默认情况下，如果未设置此属性，则event 将由Kafka Producer的分区程序分发 - 包括按键（如果指定）（或由kafka.partitioner.class指定的分区程序）。
partitionIdHeader	-	设置后，sink将使用event 标头中使用此属性的值命名的字段的值，并将消息发送到主题的指定分区。如果该值表示无效分区，则将抛出EventDeliveryException。如果存在标头值，则此设置将覆盖defaultPartitionId。
allowTopicOverride	true	设置后，sink将允许将消息生成到topicHeader属性指定的主题中（如果提供）。
topicHeader	topic	当与allowTopicOverride一起设置时，将生成一个消息，该消息将使用此属性的值命名为标头的值。与Kafka Source topicHeader属性一起使用时应小心，以避免创建环回。
kafka.producer.security.protocol	PLAINTEXT	如果使用某种级别的安全性写入Kafka，则设置为SASL_PLAINTEXT，SASL_SSL或SSL。有关安全设置的其他信息，请参见下文。
more producer security props		如果使用SASL_PLAINTEXT，则SASL_SSL或SSL会引用Kafka安全性以获取需要在生产者上设置的其他属性。
其他Kafka Producer Properties	-	这些属性用于配置Kafka Producer。可以使用Kafka支持的任何生产者属性。唯一的要求是使用前缀kafka.producer添加属性名称 。例如：kafka.producer.linger.ms

注意

Kafka Sink使用Flume Event标头中的topic和key 属性将event 发送到Kafka。如果topic 中存在headers ，则会将event 发送到该特定topic，从而覆盖为Sink配置的主题。如果key 在topic存在，关键还是使用Kafkatopic分区分区数据。具有相同密钥的event 将发送到同一分区。如果密钥为空，则将event 发送到随机分区。

Kafka sink还为key.serializer（org.apache.kafka.common.serialization.StringSerializer）和value.serializer（org.apache.kafka.common.serialization.ByteArraySerializer）

提供默认值。不建议修改这些参数

不推荐使用的属性:

属性名称	默认	描述
brokerList	-	使用kafka.bootstrap.servers
topic	default-flume-topic	使用kafka.topic
BATCHSIZE	100	使用kafka.flumeBatchSize
requiredAcks	1	使用kafka.producer.acks

下面给出Kafka sink的示例配置。以kafka生产者前缀kafka.producer开头的属性。创建Kafka生成器时传递的属性不限于此示例中给出的属性。此外，可以在此处包含您的自定义属性，并通过作为方法参数传入的Flume Context对象在预处理器中访问它们。

a1.sinks.k1.channel = c1
a1.sinks.k1.type = org.apache.flume.sink.kafka.KafkaSink
a1.sinks.k1.kafka.topic = mytopic
a1.sinks.k1.kafka.bootstrap.servers = localhost:9092
a1.sinks.k1.kafka.flumeBatchSize = 20
a1.sinks.k1.kafka.producer.acks = 1
a1.sinks.k1.kafka.producer.linger.ms = 1
a1.sinks.k1.kafka.producer.compression.type = snappy

安全和Kafka Sink

Flume和Kafka之间的通信channel支持安全认证和数据加密。对于安全身份验证，可以使用Kafka 0.9.0版中的SASL / GSSAPI（Kerberos V5）或SSL（即使该参数名为SSL，实际协议是TLS实现）

截至目前，数据加密仅由SSL / TLS提供。

将kafka.producer.security.protocol设置为以下任何值意味着：

• SASL_PLAINTEXT - 无数据加密的Kerberos或纯文本身份验证
• SASL_SSL - 使用数据加密的Kerberos或纯文本身份验证
• SSL - 基于TLS的加密，带有可选的身份验证

警告

启用S​​SL时性能会下降，其大小取决于CPUtype和JVM实现。参考：Kafka安全概述 和跟踪此问题的jira： KAFKA-2561

TLS和Kafka Sink：

请阅读配置Kafka客户端SSL中描述的步骤， 以了解用于微调的其他配置设置，例如以下任何一项：安全提供程序，密码套件，启用的协议，信任库或密钥库type。

配置服务器端身份验证和数据加密的示例。

在此处指定信任库是可选的，可以使用全局信任库。有关全局SSL设置的更多详细信息，请参阅SSL / TLS支持部分。

注意：默认情况下， 未定义属性ssl.endpoint.identification.algorithm，因此不会执行hostname验证。要启用hostname验证，请设置以下属性

a1.sinks.sink1.kafka.producer.ssl.endpoint.identification.algorithm = HTTPS

启用后，客户端将根据以下两个字段之一验证服务器的完全限定域名（FQDN）：

1. 通用名称（CN） https://tools.ietf.org/html/rfc6125#section-2.3
2. 主题备选名称（SAN）https://tools.ietf.org/html/rfc5280#section-4.2.1.6

如果还需要客户端身份验证，则还需要将以下内容添加到Flume agent 配置中，或者可以使用全局SSL设置（请参阅SSL / TLS支持部分）。每个Flume agent 都必须拥有其客户证书，Kafka经纪人必须单独或通过其签名链来信任。常见示例是由单个根CA签署每个客户端证书，而后者又由Kafka经纪人信任

# optional, the global keystore can be used alternatively
a1.sinks.sink1.kafka.producer.ssl.keystore.location = /path/to/client.keystore.jks
a1.sinks.sink1.kafka.producer.ssl.keystore.password = <password to access the keystore>

如果密钥库和密钥使用不同的密码保护，则ssl.key.password属性将为生产者密钥库提供所需的额外密钥

a1.sinks.sink1.kafka.producer.ssl.key.password = <password to access the key>

Kerberos 和Kafka Sink

要将Kafkasink与使用Kerberos保护的Kafka集群一起使用，请为生产者设置上面提到的producer.security.protocol属性。与Kafka agent 一起使用的Kerberos密钥表和主体在JAAS文件的“KafkaClient”部分中指定。“客户端”部分描述了Zookeeper连接（如果需要）。有关 JAAS文件内容的信息，请参阅Kafka doc。可以通过flume-env.sh中的JAVA_OPTS指定此JAAS文件的位置以及可选的系统范围的kerberos配置:

JAVA_OPTS="$JAVA_OPTS -Djava.security.krb5.conf=/path/to/krb5.conf"
JAVA_OPTS="$JAVA_OPTS -Djava.security.auth.login.config=/path/to/flume_jaas.conf"

使用SASL_PLAINTEXT的示例安全配置：

a1.sinks.sink1.type = org.apache.flume.sink.kafka.KafkaSink
a1.sinks.sink1.kafka.bootstrap.servers = kafka-1:9093,kafka-2:9093,kafka-3:9093
a1.sinks.sink1.kafka.topic = mytopic
a1.sinks.sink1.kafka.producer.security.protocol = SASL_PLAINTEXT
a1.sinks.sink1.kafka.producer.sasl.mechanism = GSSAPI
a1.sinks.sink1.kafka.producer.sasl.kerberos.service.name = kafka

使用SASL_SSL的安全配置示例：

a1.sinks.sink1.type = org.apache.flume.sink.kafka.KafkaSink
a1.sinks.sink1.kafka.bootstrap.servers = kafka-1:9093,kafka-2:9093,kafka-3:9093
a1.sinks.sink1.kafka.topic = mytopic
a1.sinks.sink1.kafka.producer.security.protocol = SASL_SSL
a1.sinks.sink1.kafka.producer.sasl.mechanism = GSSAPI
a1.sinks.sink1.kafka.producer.sasl.kerberos.service.name = kafka
# optional, the global truststore can be used alternatively
a1.sinks.sink1.kafka.producer.ssl.truststore.location = /path/to/truststore.jks
a1.sinks.sink1.kafka.producer.ssl.truststore.password = <password to access the truststore>

示例JAAS文件。有关其内容的参考，请参阅SASL配置的 Kafka文档中所需认证机制（GSSAPI / PLAIN）的客户端配置部分。与Kafka Source或Kafka Channel不同，不需要“Client”部分，除非其他连接组件需要它。另外，请确保Flume进程的操作系统用户对jaas和keytab文件具有读权限。

KafkaClient {
com.sun.security.auth.module.Krb5LoginModule required
useKeyTab=true
storeKey=true
keyTab="/path/to/keytabs/flume.keytab"
principal="flume/flumehost1.example.com@YOURKERBEROSREALM";
};

HTTP Sink

此sink的行为是它将从channel获取event ，并使用HTTP POST请求将这些event 发送到远程服务。event 内容作为POST正文发送

此sink的错误处理行为取决于目标服务器返回的HTTP响应。sink退避/就绪状态是可配置的，事务提交/回滚结果以及event 是否有助于成功的event 排放计数也是可配置的

状态代码不可读的服务器返回的任何格式错误的HTTP响应都将导致退避信号，并且不会从该channel中消耗该event

必需属性以粗体显示

属性名称	默认	描述
channel	-
type	-	组件type名称需要为http。
endpoint	-	POST到的完全限定的URL端点
connectTimeout	5000	套接字connect-timeout（以毫秒为单位）
request-timeout	5000	最大请求处理时间（以毫秒为单位）
contentTypeHeader	text/plain	HTTP Content-Type标头
acceptHeader	text/plain	HTTP Accept标头值
defaultBackoff	true	是否在接收所有HTTP状态代码时默认退避
defaultRollback	true	是否在接收所有HTTP状态代码时默认回滚
defaultIncrementMetrics	false	是否在接收所有HTTP状态代码时默认增加指标
backoff.CODE	-	为个人（即200）代码或组（即2XX）代码配置特定退避
rollback.CODE	-	为单个（即200）代码或组（即2XX）代码配置特定回滚
incrementMetrics.CODE	-	配置单个（即200）代码或组（即2XX）代码的特定度量增量

请注意，最具体的HTTP状态代码匹配用于backoff，rollback和incrementMetrics配置选项。如果存在2XX和200状态代码的配置值，则200个HTTP代码将使用200值，而201-299范围内的所有其他HTTP代码将使用2XX值。

消耗任何空或空event 而不向HTTP端点发出任何请求。

Example for agent named a1:

a1.channels = c1
a1.sinks = k1
a1.sinks.k1.type = http
a1.sinks.k1.channel = c1
a1.sinks.k1.endpoint = http://localhost:8080/someuri
a1.sinks.k1.connectTimeout = 2000
a1.sinks.k1.requestTimeout = 2000
a1.sinks.k1.acceptHeader = application/json
a1.sinks.k1.contentTypeHeader = application/json
a1.sinks.k1.defaultBackoff = true
a1.sinks.k1.defaultRollback = true
a1.sinks.k1.defaultIncrementMetrics = false
a1.sinks.k1.backoff.4XX = false
a1.sinks.k1.rollback.4XX = false
a1.sinks.k1.incrementMetrics.4XX = true
a1.sinks.k1.backoff.200 = false
a1.sinks.k1.rollback.200 = false
a1.sinks.k1.incrementMetrics.200 = true

Custom Sink

自定义sink是您自己的Sink接口实现。启动Flume agent 程序时，必须在 agent 程序的类路径中包含自定义sink的类及其依赖项。自定义sink的type是其FQCN。必需属性以粗体显示

属性名称	默认	描述
channel	-
type	-	组件type名称，需要是您的FQCN

Example for agent named a1:

a1.channels = c1
a1.sinks = k1
a1.sinks.k1.type = org.example.MySink
a1.sinks.k1.channel = c1

Flume Channels

channel是event 在 agent 上暂存的存储库。Source添加event ，Sink删除它。

Memory Channel

event 存储在具有可配置最大大小的内存中队列中。它非常适合需要更高吞吐量的流量，并且在 agent 发生故障时准备丢失分阶段数据。必需属性以粗体显示

属性名称	默认	描述
type	-	组件type名称，需要是 memory
capacity	100	channel中存储的最大event 数
transactionCapacity	100	每个事务channel从source或提供给sink的最大event 数
keep-alive	3	添加或删除event 的超时（以秒为单位）
byteCapacityBufferPercentage	20	定义byteCapacity与channel中所有event 的估计总大小之间的缓冲区百分比，以计算标头中的数据。见下文。
byteCapacity	见说明	允许的最大内存总字节数，作为此channel中所有event 的总和。该实现仅计算Event 主体，这也是提供byteCapacityBufferPercentage配置参数的原因。默认值为计算值，等于JVM可用的最大内存的80％（即命令行传递的-Xmx值的80％）。请注意，如果在单个JVM上有多个内存channel，并且它们碰巧保持相同的物理event （即，如果您使用来自单个source的复制channel选择器），那么这些event 大小可能会被重复计算以用于channelbyteCapacity目的。将此值设置为0将导致此值回退到大约200 GB的内部硬限制。

Example for agent named a1:

a1.channels = c1
a1.channels.c1.type = memory
a1.channels.c1.capacity = 10000
a1.channels.c1.transactionCapacity = 10000
a1.channels.c1.byteCapacityBufferPercentage = 20
a1.channels.c1.byteCapacity = 800000

JDBC Channel

event 存储在由数据库支持的持久存储中。JDBC Channel当前支持嵌入式Derby。这是一个持久的channel，非常适合可恢复性很重要的流程。必需属性以粗体显示

属性名称	默认	描述
type	-	组件type名称，需要是   jdbc
db.type	DERBY	数据库供应商需要是DERBY。
driver.class	org.apache.derby.jdbc.EmbeddedDriver	供应商的JDBC驱动程序的类
driver.url	（由其他属性建造）	JDBC连接URL
db.username	“sa”	数据库连接的用户标识
db.password	-	数据库连接的密码
connection.properties.file	-	JDBC连接属性文件路径
create.schema	true	如果为true，则创建db模式（如果不存在）
create.index	true	创建索引以加快查找速度
create.foreignkey	true
transaction.isolation	“READ_COMMITTED”	db会话的隔离级别READ_UNCOMMITTED，READ_COMMITTED，SERIALIZABLE，REPEATABLE_READ
maximum.connections	10	允许db的最大连接数
最大容量	0（无限制）	channel中的最大event 数
sysprop。*		数据库供应商特定属性
sysprop.user.home		存储嵌入式Derby数据库的主路径

Example for agent named a1:

a1.channels = c1
a1.channels.c1.type = jdbc

Kafka Channel

event 存储在Kafka群集中（必须单独安装）。Kafka提供高可用性和复制，因此如果 agent 或kafka agent 崩溃，event 可立即用于其他sinks

Kafka频道可用于多种场景：

1. 使用Flume source和sink - 它为event 提供了可靠且高度可用的channel
2. 使用Flume source和拦截器但没有sink - 它允许将Flumeevent 写入Kafka主题，供其他应用程序使用
3. 使用Flume sink，但没有source - 它是一种低延迟，容错的方式将event 从Kafka发送到Flumesink，如HDFS，HBase或Solr

这目前支持Kafka服务器版本0.10.1.0或更高版本。测试完成了2.0.1，这是发布时最高的可用版本。

配置参数组织如下：

1. 通常与channel相关的配置值应用于channel配置级别，例如：a1.channel.k1.type =
2. 与Kafka相关的配置值或Channel运行的前缀以“kafka。”为前缀（这对CommonClient Configs是有效的），例如：a1.channel.k1.kafka.topic和a1.channel.k1.kafka.bootstrap.servers。这与hdfssink的运行方式没有什么不同
3. 特定于生产者/消费者的属性以kafka.producer或kafka.consumer为前缀
4. 在可能的情况下，使用Kafka参数名称，例如：bootstrap.servers和acks

此版本的flume与以前的版本向后兼容，但是下表中显示了已弃用的属性，并且在配置文件中存在时会在启动时记录警告消息。

必需属性以粗体显示

属性名称	默认	描述
type	-	组件type名称，需要是org.apache.flume.channel.kafka.KafkaChannel
kafka.bootstrap.servers	-	channel使用的Kafka集群中的经纪商列表这可以是经纪人的部分列表，但我们建议至少两个用于HA。格式为逗号分隔的hostname：port列表
kafka.topic	水槽沟道	频道将使用的Kafka主题
kafka.consumer.group.id	水槽	channel用于向Kafka注册的消费者群组ID。多个channel必须使用相同的主题和组，以确保当一个 agent 程序发生故障时，另一个 agent 程序可以获取数据请注意，具有相同ID的非channel使用者可能会导致数据丢失。
parseAsFlumeEvent	真正	期望在频道中使用FlumeEvent架构的Avro基准。如果Flume source写入channel，则应该为true;如果其他生成器正在写入channel正在使用的主题，则应为false。通过使用flume-ng-sdk工件提供的org.apache.flume.source.avro.AvroFlumeEvent，可以在Flume之外解析到Kafka的Flume source消息
的pollTimeout	500	在消费者的“poll（）”调用中等待的时间量（以毫秒为单位）。https://kafka.apache.org/090/javadoc/org/apache/kafka/clients/consumer/KafkaConsumer.html#poll(long）
defaultPartitionId	-	指定要发送到此channel中的所有event 的Kafka分区ID（整数），除非被partitionIdHeader覆盖。默认情况下，如果未设置此属性，则event 将由Kafka Producer的分区程序分发 - 包括按键（如果指定）（或由kafka.partitioner.class指定的分区程序）。
partitionIdHeader	-	设置时，生产者将从event 头中获取使用此属性的值命名的字段的值，并将消息发送到主题的指定分区。如果该值表示无效分区，则该event 将不被接受。如果存在标头值，则此设置将覆盖defaultPartitionId。
kafka.consumer.auto.offset.reset	最新	当Kafka中没有初始偏移量或服务器上当前偏移量不再存在时（例如因为该数据已被删除）该怎么办：最早：自动将偏移量重置为最早的最新偏移量：自动重置偏移量到最新的偏移量无：如果没有为消费者的组找到任何其他偏移量，则向消费者抛出异常：向消费者抛出异常。
kafka.producer.security.protocol	纯文本	如果使用某种级别的安全性写入Kafka，则设置为SASL_PLAINTEXT，SASL_SSL或SSL。有关安全设置的其他信息，请参见下文。
kafka.consumer.security.protocol	纯文本	与kafka.producer.security.protocol相同，但是用于从Kafka阅读/消费。
更多生产者/消费者安全道具		如果使用SASL_PLAINTEXT，则SASL_SSL或SSL会引用Kafka安全性以获取需要在生产者/消费者上设置的其他属性。

不推荐使用的属性:

属性名称	默认	描述
brokerList	-	channel使用的Kafka集群中的经纪商列表这可以是经纪人的部分列表，但我们建议至少两个用于HA。格式为逗号分隔的hostname：port列表
话题	水槽沟道	使用kafka.topic
的groupId	水槽	使用kafka.consumer.group.id
readSmallestOffset	false	使用kafka.consumer.auto.offset.reset
migrateZookeeperOffsets	真正	如果找不到Kafka存储的偏移量，请在Zookeeper中查找偏移量并将它们提交给Kafka。这应该是支持从旧版本的Flume无缝Kafka客户端迁移。迁移后，可以将其设置为false，但通常不需要这样做。如果未找到Zookeeper偏移量，则kafka.consumer.auto.offset.reset配置定义如何处理偏移量。

注意

Example for agent named a1:

a1.channels.channel1.type = org.apache.flume.channel.kafka.KafkaChannel
a1.channels.channel1.kafka.bootstrap.servers = kafka-1:9092,kafka-2:9092,kafka-3:9092
a1.channels.channel1.kafka.topic = channel1
a1.channels.channel1.kafka.consumer.group.id = flume-consumer

安全和Kafka频道：

Flume和Kafka之间的通信channel支持安全认证和数据加密。对于安全身份验证，可以使用Kafka 0.9.0版中的SASL / GSSAPI（Kerberos V5）或SSL（即使该参数名为SSL，实际协议是TLS实现）

截至目前，数据加密仅由SSL / TLS提供

将kafka.producer | consumer.security.protocol设置为以下任何值意味着：

• SASL_PLAINTEXT - 无数据加密的Kerberos或纯文本身份验证
• SASL_SSL - 使用数据加密的Kerberos或纯文本身份验证
• SSL - 基于TLS的加密，带有可选的身份验证。

警告

启用S​​SL时性能会下降，其大小取决于CPUtype和JVM实现。参考：Kafka安全概述 和跟踪此问题的jira： KAFKA-2561

** TLS 和Kafka频道：**

请阅读配置Kafka客户端SSL中描述的步骤 以了解用于微调的其他配置设置，例如以下任何一项：安全提供程序，密码套件，启用的协议，信任库或密钥库type。

配置服务器端身份验证和数据加密的示例。

a1.channels.channel1.type = org.apache.flume.channel.kafka.KafkaChannel
a1.channels.channel1.kafka.bootstrap.servers = kafka-1:9093,kafka-2:9093,kafka-3:9093
a1.channels.channel1.kafka.topic = channel1
a1.channels.channel1.kafka.consumer.group.id = flume-consumer
a1.channels.channel1.kafka.producer.security.protocol = SSL
# optional, the global truststore can be used alternatively
a1.channels.channel1.kafka.producer.ssl.truststore.location = /path/to/truststore.jks
a1.channels.channel1.kafka.producer.ssl.truststore.password = <password to access the truststore>
a1.channels.channel1.kafka.consumer.security.protocol = SSL
# optional, the global truststore can be used alternatively
a1.channels.channel1.kafka.consumer.ssl.truststore.location = /path/to/truststore.jks
a1.channels.channel1.kafka.consumer.ssl.truststore.password = <password to access the truststore>

在此处指定信任库是可选的，可以使用全局信任库。有关全局SSL设置的更多详细信息，请参阅SSL / TLS支持部分。

注意：默认情况下， 未定义属性ssl.endpoint.identification.algorithm，因此不会执行hostname验证。要启用hostname验证，请设置以下属性

a1.channels.channel1.kafka.producer.ssl.endpoint.identification.algorithm = HTTPS
a1.channels.channel1.kafka.consumer.ssl.endpoint.identification.algorithm = HTTPS

启用后，客户端将根据以下两个字段之一验证服务器的完全限定域名（FQDN）：

1. 通用名称（CN）https://tools.ietf.org/html/rfc6125#section-2.3
2. 主题备选名称（SAN）https://tools.ietf.org/html/rfc5280#section-4.2.1.6

如果还需要客户端身份验证，则还需要将以下内容添加到Flume agent 配置中，或者可以使用全局SSL设置（请参阅SSL / TLS支持部分）。每个Flume agent 都必须拥有其客户证书，Kafka经纪人必须单独或通过其签名链来信任。常见示例是由单个根CA签署每个客户端证书，而后者又由Kafka经纪人信任。

# optional, the global keystore can be used alternatively
a1.channels.channel1.kafka.producer.ssl.keystore.location = /path/to/client.keystore.jks
a1.channels.channel1.kafka.producer.ssl.keystore.password = <password to access the keystore>
# optional, the global keystore can be used alternatively
a1.channels.channel1.kafka.consumer.ssl.keystore.location = /path/to/client.keystore.jks
a1.channels.channel1.kafka.consumer.ssl.keystore.password = <password to access the keystore>

如果密钥库和密钥使用不同的密码保护，则ssl.key.password属性将为使用者和生产者密钥库提供所需的额外密钥：

a1.channels.channel1.kafka.producer.ssl.key.password = <password to access the key>
a1.channels.channel1.kafka.consumer.ssl.key.password = <password to access the key>

** Kerberos 和Kafka频道：**

要将Kafkachannel与使用Kerberos保护的Kafka群集一起使用，请为生产者和/或使用者设置上面提到的producer / consumer.security.protocol属性。与Kafka agent 一起使用的Kerberos密钥表和主体在JAAS文件的“KafkaClient”部分中指定。“客户端”部分描述了Zookeeper连接（如果需要）。有关 JAAS文件内容的信息，请参阅Kafka doc。可以通过flume-env.sh中的JAVA_OPTS指定此JAAS文件的位置以及可选的系统范围的kerberos配置：

JAVA_OPTS="$JAVA_OPTS -Djava.security.krb5.conf=/path/to/krb5.conf"
JAVA_OPTS="$JAVA_OPTS -Djava.security.auth.login.config=/path/to/flume_jaas.conf"

使用SASL_PLAINTEXT的示例安全配置：

a1.channels.channel1.type = org.apache.flume.channel.kafka.KafkaChannel
a1.channels.channel1.kafka.bootstrap.servers = kafka-1:9093,kafka-2:9093,kafka-3:9093
a1.channels.channel1.kafka.topic = channel1
a1.channels.channel1.kafka.consumer.group.id = flume-consumer
a1.channels.channel1.kafka.producer.security.protocol = SASL_PLAINTEXT
a1.channels.channel1.kafka.producer.sasl.mechanism = GSSAPI
a1.channels.channel1.kafka.producer.sasl.kerberos.service.name = kafka
a1.channels.channel1.kafka.consumer.security.protocol = SASL_PLAINTEXT
a1.channels.channel1.kafka.consumer.sasl.mechanism = GSSAPI
a1.channels.channel1.kafka.consumer.sasl.kerberos.service.name = kafka

使用SASL_SSL的安全配置示例：

a1.channels.channel1.type = org.apache.flume.channel.kafka.KafkaChannel
a1.channels.channel1.kafka.bootstrap.servers = kafka-1:9093,kafka-2:9093,kafka-3:9093
a1.channels.channel1.kafka.topic = channel1
a1.channels.channel1.kafka.consumer.group.id = flume-consumer
a1.channels.channel1.kafka.producer.security.protocol = SASL_SSL
a1.channels.channel1.kafka.producer.sasl.mechanism = GSSAPI
a1.channels.channel1.kafka.producer.sasl.kerberos.service.name = kafka
# optional, the global truststore can be used alternatively
a1.channels.channel1.kafka.producer.ssl.truststore.location = /path/to/truststore.jks
a1.channels.channel1.kafka.producer.ssl.truststore.password = <password to access the truststore>
a1.channels.channel1.kafka.consumer.security.protocol = SASL_SSL
a1.channels.channel1.kafka.consumer.sasl.mechanism = GSSAPI
a1.channels.channel1.kafka.consumer.sasl.kerberos.service.name = kafka
# optional, the global truststore can be used alternatively
a1.channels.channel1.kafka.consumer.ssl.truststore.location = /path/to/truststore.jks
a1.channels.channel1.kafka.consumer.ssl.truststore.password = <password to access the truststore>

示例JAAS文件。有关其内容的参考，请参阅SASL配置的 Kafka文档中所需认证机制（GSSAPI / PLAIN）的客户端配置部分。由于Kafka Source也可能连接到Zookeeper以进行偏移迁移，因此“Client”部分也添加到此示例中。除非您需要偏移迁移，否则不需要这样做，或者您需要此部分用于其他安全组件。另外，请确保Flume进程的操作系统用户对jaas和keytab文件具有读权限。

Client {
  com.sun.security.auth.module.Krb5LoginModule required
  useKeyTab=true
  storeKey=true
  keyTab="/path/to/keytabs/flume.keytab"
  principal="flume/flumehost1.example.com@YOURKERBEROSREALM";
};
 
KafkaClient {
  com.sun.security.auth.module.Krb5LoginModule required
  useKeyTab=true
  storeKey=true
  keyTab="/path/to/keytabs/flume.keytab"
  principal="flume/flumehost1.example.com@YOURKERBEROSREALM";
};

File Channel

必需属性以粗体显示

属性名称默认值	描述
type	-	组件type名称，需要是  file 。
checkpointDir	~/.flume/file-channel/checkpoint	将存储检查点文件的目录
useDualCheckpoints	false	备份检查点。如果将其设置为true，则 必须设置backupCheckpointDir
backupCheckpointDir	-	备份检查点的目录。此目录不能与数据目录或检查点目录相同
dataDirs	~/.flume/file-channel/data	逗号分隔的目录列表，用于存储日志文件。在不同磁盘上使用多个目录可以提高文件channel的性能
transactionCapacity	10000	channel支持的最大事务大小
checkpointInterval	30000	检查点之间的时间量（以毫秒为单位）
maxFileSize为	2146435071	单个日志文件的最大大小（以字节为单位）  2G
minimumRequiredSpace	524288000	最小所需可用空间（以字节为单位）。为避免数据损坏，当可用空间低于此值时，文件channel将停止接受接收/放置请求 500M
capacity	1000000	channel的最大容量   100万
keep-alive	3	等待放置操作的时间量（以秒为单位）
use-log-replay-v1	false	推荐：使用原有的重播逻辑
use-fast-replay	false	推荐：不使用队列重播
checkpointOnClose	true	控制是否在关闭channel时创建检查点。通过避免重放，在关闭时创建检查点可以提高文件channel的后续启动速度。
encryption.activeKey	-	用于加密新数据的密钥名称
encryption.cipherProvider	-	密码提供程序type，支持的type：AESCTRNOPADDING
encryption.keyProvider	-	密钥提供程序type，支持的type：JCEKSFILE
encryption.keyProvider.keyStoreFile	-	密钥库文件的路径
encrpytion.keyProvider.keyStorePasswordFile	-	密钥库密码文件的路径
encryption.keyProvider.keys	-	所有键的列表（例如activeKey设置的历史记录）
encyption.keyProvider.keys.*.passwordFile	-	可选密钥密码文件的路径

注意

默认情况下，文件channel使用上面指定的用户主目录内的检查点和数据目录的路径。因此，如果 agent 中有多个活动的文件channel实例，则只有一个实例可以锁定目录并导致其他channel初始化失败。

因此，有必要为所有已配置的channel提供显式路径，最好是在不同的磁盘上

此外，由于文件channel将在每次提交后同步到磁盘，因此将其与将event 一起批处理的sink/source耦合可能是必要的，以便在多个磁盘不可用于检查点和数据目录时提供良好的性能。

Example for agent named a1:

a1.channels = c1
a1.channels.c1.type = file
a1.channels.c1.checkpointDir = /mnt/flume/checkpoint
a1.channels.c1.dataDirs = /mnt/flume/data

加密

以下是一些示例配置：

使用密钥存储密码分隔生成密码密钥：

keytool -genseckey -alias key-0 -keypass keyPassword -keyalg AES \
  -keysize 128 -validity 9000 -keystore test.keystore \
  -storetype jceks -storepass keyStorePassword

使用与密钥库密码相同的密码生成密钥：

keytool -genseckey -alias key-1 -keyalg AES -keysize 128 -validity 9000 \
  -keystore src/test/resources/test.keystore -storetype jceks \
  -storepass keyStorePassword

a1.channels.c1.encryption.activeKey = key-0
a1.channels.c1.encryption.cipherProvider = AESCTRNOPADDING
a1.channels.c1.encryption.keyProvider = key-provider-0
a1.channels.c1.encryption.keyProvider = JCEKSFILE
a1.channels.c1.encryption.keyProvider.keyStoreFile = /path/to/my.keystore
a1.channels.c1.encryption.keyProvider.keyStorePasswordFile = /path/to/my.keystore.password
a1.channels.c1.encryption.keyProvider.keys = key-0

false设您已使用密钥0输出密钥，并且应使用密钥1加密新文件：

a1.channels.c1.encryption.activeKey = key-1
a1.channels.c1.encryption.cipherProvider = AESCTRNOPADDING
a1.channels.c1.encryption.keyProvider = JCEKSFILE
a1.channels.c1.encryption.keyProvider.keyStoreFile = /path/to/my.keystore
a1.channels.c1.encryption.keyProvider.keyStorePasswordFile = /path/to/my.keystore.password
a1.channels.c1.encryption.keyProvider.keys = key-0 key-1

与上面相同的场景，但key-0有自己的密码：

a1.channels.c1.encryption.activeKey = key-1
a1.channels.c1.encryption.cipherProvider = AESCTRNOPADDING
a1.channels.c1.encryption.keyProvider = JCEKSFILE
a1.channels.c1.encryption.keyProvider.keyStoreFile = /path/to/my.keystore
a1.channels.c1.encryption.keyProvider.keyStorePasswordFile = /path/to/my.keystore.password
a1.channels.c1.encryption.keyProvider.keys = key-0 key-1
a1.channels.c1.encryption.keyProvider.keys.key-0.passwordFile = /path/to/key-0.password

Custom Channel

自定义channel是您自己的Channel接口实现。启动Flume agent 程序时，必须在 agent 程序的类路径中包含自定义channel的类及其依赖项。自定义channel的type是其FQCN。必需属性以粗体显示

属性名称	默认	描述
type	-	组件type名称需要是FQCN

Example for agent named a1:

a1.channels = c1
a1.channels.c1.type = org.example.MyChannel

Flume Channel Selectors

如果未指定type，则默认为“replicating”

Replicating Channel Selector (default)

必需属性以粗体显示

属性名称	默认	描述
selector.type	replicating	组件type名称需要   replicating
selector.optional	-	要标记为可选的channel集

Example for agent named a1 and it’s source called r1:

a1.sources = r1
a1.channels = c1 c2 c3
a1.sources.r1.selector.type = replicating
a1.sources.r1.channels = c1 c2 c3
a1.sources.r1.selector.optional = c3

在上面的配置中，c3是可选的channel。

无法写入c3只是被忽略了。由于c1和c2未标记为可选，因此无法写入这些channel将导致事务失败。

Multiplexing Channel Selector (多路复用)

必需属性以粗体显示

属性名称	默认	描述
selector.type	replicating	组件type名称需要进行多路复用(multiplexing)
selector.header	flume.selector.header
selector.default	-
selector.mapping。*	-

Example for agent named a1 and it’s source called r1:

a1.sources = r1
a1.channels = c1 c2 c3 c4
a1.sources.r1.selector.type = multiplexing
a1.sources.r1.selector.header = state
a1.sources.r1.selector.mapping.CZ = c1
a1.sources.r1.selector.mapping.US = c2 c3
a1.sources.r1.selector.default = c4

Custom Channel Selector

自定义channel选择器是您自己的Channelelector接口实现。启动Flume agent 程序时，自定义channel选择器的类及其依赖项必须包含在 agent 程序的类路径中。自定义channel选择器的type是其FQCN。

属性名称	默认	描述
selector.type	-	组件type名称，需要是您的FQCN

Example for agent named a1 and its source called r1:

a1.sources = r1
a1.channels = c1
a1.sources.r1.selector.type = org.example.MyChannelSelector

Flume Sink Processors

接收组允许用户将多个sink分组到一个实体中。sink处理器可用于在组内的所有sink上提供负载平衡功能，或在时间故障的情况下实现从一个sink到另一个sink的故障转移。

必需属性以粗体显示

属性名称	默认	描述
sinks	-	以空格分隔的参与组的sink列表
processor.type	default	组件type名称需要是default，failover或load_balance

Example for agent named a1:

a1.sinkgroups = g1
a1.sinkgroups.g1.sinks = k1 k2
a1.sinkgroups.g1.processor.type = load_balance

Default Sink Processor

默认sink只接受一个sink。用户不必为单个sink创建处理器（sink组）。相反，用户可以遵循本用户指南中上面解释的source - channel - sink模式

Failover Sink Processor

故障转移sink维护一个优先级的sink列表，保证只要有一个可用的event 将被处理（传递）

故障转移机制的工作原理是将故障sink降级到池中，在池中为它们分配一个冷却期，在重试之前随顺序故障而增加。sink成功发送event 后，它将恢复到实时池。sink具有与之相关的优先级，数量越大，优先级越高。如果在发送event 时sink发生故障，则接下来将尝试下一个具有最高优先级的sink以发送event 。例如，在优先级为80的sink之前激活优先级为100的sink。如果未指定优先级，则根据配置中指定sink的顺序确定Sinks 优先级。

要进行配置，请将sink组处理器设置为故障转移并为所有单个sink设置优先级。所有指定的优先级必须是唯一的 此外，可以使用maxpenalty属性设置故障转移时间的上限（以毫秒为单位）

必需属性以粗体显示

属性名称	默认	描述
sinks	-	以空格分隔的参与组的sink列表
processor.type	default	组件type名称需要进行故障转移   failover
processor.priority	-	优先价值。必须是与当前sink组关联的sink实例之一。较高优先级值Sink较早被激活。绝对值越大表示优先级越高
processor.maxpenalty	30000	失败的sink的最大退避时间（以毫秒为单位）

Example for agent named a1:

a1.sinkgroups = g1
a1.sinkgroups.g1.sinks = k1 k2
a1.sinkgroups.g1.processor.type = failover
a1.sinkgroups.g1.processor.priority.k1 = 5
a1.sinkgroups.g1.processor.priority.k2 = 10
a1.sinkgroups.g1.processor.maxpenalty = 10000

Load balancing Sink Processor(负载均衡接收处理器)

负载平衡sink处理器提供了在多个sink上进行负载均衡流量的功能。它维护一个索引的活动sink列表，必须在其上分配负载。实现支持使用round_robin或 random 机制分配负载。选择机制的选择默认为round_robin 类型，但可以通过配置覆盖。通过从AbstractSinkSelector 继承的自定义类支持自定义选择机制。

调用时，此选择器使用其配置的选择机制选择下一个sink并调用它。对于round_robin和random如果所选的sink无法传递event ，则处理器通过其配置的选择机制选择下一个可用的sink。此实现不会将失败的sink列入黑名单，而是继续乐观地尝试每个可用的sink。如果所有sink调用都导致失败，则选择器将故障传播到sink运行器。

如果启用了 backoff ，则sink处理器会将失败的sink列入黑名单，将其删除以供给定超时的选择。当超时结束时，如果sink仍然没有响应，则超时会以指数方式增加，以避免在无响应的sink上长时间等待时卡住。在禁用此功能的情况下，在循环中，所有失败的sink负载将被传递到下一个sink，因此不均衡

必需属性以粗体显示

属性名称	默认	描述
processor.sink	-	以空格分隔的参与组的sink列表
processor.type	default	组件type名称需要是load_balance
processor.backoff	false	失败的sink是否会以指数方式退回。
processor.selector	round_robin	选择机制。必须是round_robin，random 或自定义类的FQCN，它继承自AbstractSinkelector
processor.selector.maxTimeOut	30000	由退避选择器用于限制指数backoff （以毫秒为单位）

Example for agent named a1:

a1.sinkgroups = g1
a1.sinkgroups.g1.sinks = k1 k2
a1.sinkgroups.g1.processor.type = load_balance
a1.sinkgroups.g1.processor.backoff = true
a1.sinkgroups.g1.processor.selector = random

Custom Sink Processor

目前不支持自定义sink处理器

Event Serializers

该 file_roll sink 和HDFS  sink 都支持 EventSerializer接口。下面提供了随Flume一起提供的Event  Serializer的详细信息。

Body Text Serializer

别名：text 。此拦截器将 event 的主体写入输出流，而不进行任何转换或修改。event 标题将被忽略。配置选项如下：

属性名称	默认	描述
appendNewline	真正	是否在写入时将换行符附加到每个event 。由于遗留原因，默认值为truefalse定event 不包含换行符。

Example for agent named a1:

a1.sinks = k1
a1.sinks.k1.type = file_roll
a1.sinks.k1.channel = c1
a1.sinks.k1.sink.directory = /var/log/flume
a1.sinks.k1.sink.serializer = text
a1.sinks.k1.sink.serializer.appendNewline = false

“Flume Event” Avro Event Serializer

Alias:  avro_event.

此拦截器将Flumeevent 序列化为Avro容器文件。使用的模式与Avro RPC机制中用于Flumeevent 的模式相同。

此序列化程序继承自AbstractAvroEventSerializer类

配置选项如下：

属性名称	默认	描述
syncIntervalBytes	2048000	Avro同步间隔，大约为字节。  2M ???
compressionCodec	null	Avro压缩编解码器。有关受支持的编解码器，请参阅Avro的CodecFactory文档。

Example for agent named a1:

a1.sinks.k1.type = hdfs
a1.sinks.k1.channel = c1
a1.sinks.k1.hdfs.path = /flume/events/%y-%m-%d/%H%M/%S
a1.sinks.k1.serializer = avro_event
a1.sinks.k1.serializer.compressionCodec = snappy

Avro event 序列化器

别名：此序列化程序没有别名，必须使用完全限定的类名类名指定。

这将Flume event 序列化为Avro容器文件，如 “Flume Event” Avro Event Serializer，但记录模式是可配置的。记录模式可以指定为Flume配置属性，也可以在event 头中传递。

要将记录模式作为Flume配置的一部分传递，请使用下面列出的属性 schemaURL。

要在event 标头中传递记录模式，请指定 包含模式的JSON格式表示的event 标头flume.avro.schema.literal或包含可以找到模式的URL的flume.avro.schema.url（ hdfs:/... URIs are supported I）

此序列化程序继承自AbstractAvroEventSerializer类。

配置选项如下：

属性名称	默认	描述
syncIntervalBytes	2048000	Avro同步间隔，大约为字节。
compressionCodec	null	Avro压缩编解码器。有关受支持的编解码器，请参阅Avro的CodecFactory文档。
schemaURL		Avro架构URL。标题中指定的模式ovverride此选项。

Example for agent named a1:

a1.sinks.k1.type = hdfs
a1.sinks.k1.channel = c1
a1.sinks.k1.hdfs.path = /flume/events/%y-%m-%d/%H%M/%S
a1.sinks.k1.serializer = org.apache.flume.sink.hdfs.AvroEventSerializer$Builder
a1.sinks.k1.serializer.compressionCodec = snappy
a1.sinks.k1.serializer.schemaURL = hdfs://namenode/path/to/schema.avsc

Flume Interceptors

Flume具有在运行中修改/删除 event 的能力。这是在拦截器的帮助下完成的。拦截器是实现org.apache.flume.interceptor.Interceptor的类接口。拦截器可以根据拦截器开发者选择的任何标准修改甚至删除event 。Flume支持拦截器的链接。通过在配置中指定拦截器构建器类名列表，可以实现此目的。拦截器在source配置中指定为以空格分隔的列表。指定拦截器的顺序是它们被调用的顺序。一个拦截器返回的event 列表将传递给链中的下一个拦截器。拦截器可以修改或删除event 。如果拦截器需要删除event ，它就不会在它返回的列表中返回该event 。如果要删除所有event ，则只返回一个空列表。拦截器是命名组件，下面是它们如何通过配置创建的示例：

a1.sources = r1
a1.sinks = k1
a1.channels = c1
a1.sources.r1.interceptors = i1 i2
a1.sources.r1.interceptors.i1.type = org.apache.flume.interceptor.HostInterceptor$Builder
a1.sources.r1.interceptors.i1.preserveExisting = false
a1.sources.r1.interceptors.i1.hostHeader = hostname
a1.sources.r1.interceptors.i2.type = org.apache.flume.interceptor.TimestampInterceptor$Builder
a1.sinks.k1.filePrefix = FlumeData.%{CollectorHost}.%Y-%m-%d
a1.sinks.k1.channel = c1

请注意，拦截器构建器将传递给type config参数。拦截器本身是可配置的，可以传递配置值，就像传递给任何其他可配置组件一样。在上面的示例中，event 首先传递给HostInterceptor，然后HostInterceptor返回的event 传递给TimestampInterceptor。您可以指定完全限定的类名（FQCN）或别名时间戳。如果您有多个收集器写入相同的HDFS路径，那么您也可以使用HostInterceptor

时间戳拦截器 (Timestamp Interceptor)

此拦截器将event 标头插入到event 标头中，以毫秒为单位处理event 。此拦截器插入带有键时间戳（或由header属性指定）的标头，其值为相关时间戳。如果已在配置中存在，则此拦截器可以保留现有时间戳

属性名称	默认	描述
type	-	组件type名称必须是时间戳或FQCN
headerName	timestamp	用于放置生成的时间戳的标头的名称。
preserveExisting	false	如果时间戳已存在，是否应保留 - true或false

Example for agent named a1:

a1.sources = r1
a1.channels = c1
a1.sources.r1.channels =  c1
a1.sources.r1.type = seq
a1.sources.r1.interceptors = i1
a1.sources.r1.interceptors.i1.type = timestamp

主机拦截器(Host Interceptor)

此拦截器插入运行此 agent 程序的主机的hostname或IP地址。它根据配置插入带有密钥主机或已配置密钥的标头，其值为主机的hostname或IP地址。

属性名称	默认	描述
type	-	组件type名称必须是 host
preserveExisting	false	如果主机头已存在，是否应保留 - true或false
useIP	true	如果为true，请使用IP地址，否则使用hostname。
hostHeader	host	要使用的标头密钥。

Example for agent named a1:

a1.sources = r1
a1.channels = c1
a1.sources.r1.interceptors = i1
a1.sources.r1.interceptors.i1.type = host

静态拦截器 (Static Interceptor)

静态拦截器允许用户将具有静态值的静态头附加到所有event

当前实现不允许一次指定多个标头。相反，用户可能会链接多个静态拦截器，每个静态拦截器定义一个

属性名称	默认	描述
type	-	组件type名称必须是 static
preserveExisting	true	如果已配置的标头已存在，则应保留它 - true或false
key	key	应创建的标头的名称
value	value	应该创建的静态值

Example for agent named a1:

a1.sources = r1
a1.channels = c1
a1.sources.r1.channels =  c1
a1.sources.r1.type = seq
a1.sources.r1.interceptors = i1
a1.sources.r1.interceptors.i1.type = static
a1.sources.r1.interceptors.i1.key = datacenter
a1.sources.r1.interceptors.i1.value = NEW_YORK

Remove Header Interceptor (删除标题拦截器)

此拦截器通过删除一个或多个headers来操纵Flume event headers。它可以删除静态定义的headers、基于正则表达式的headers或列表中的headers。如果这些都没有定义，或者没有符合条件的headers，则不会修改Flume事件。

请注意，如果只需要删除一个headers，则按名称指指定 header 可提供相对于其他两种方法的性能优势。

属性名称	默认	描述
type	-	组件type名称必须是 remove_header
withName	-	要删除的header的名称
fromList	-	要删除的header列表，使用fromListSeparator指定的分隔符分隔
fromListSeparator	\ S * \ S *	正则表达式，用于分隔fromList指定的列表中的多个header名称。默认值是由任意数量的空白字符包围的逗号
matching	-	将删除名称与此正则表达式匹配的所有header

UUID拦截器 (UUID Interceptor)

此拦截器在所有截获的event 上设置通用唯一标识符。示例UUID是b5755073-77a9-43c1-8fad-b7a586fc1b97，表示128位值。

如果event 的应用程序级别唯一键不可用，请考虑使用UUIDInterceptor自动为event 分配UUID。一旦UUID进入Flume网络就将其分配给event 非常重要; 也就是说，在流量的第一个Flume Source中。这使得在Flume网络中面对复制和重新发送时event 的后续重复数据删除可以实现高可用性和高性能。如果应用程序级别密钥可用，则优于自动生成的UUID，因为它使用所述公知的应用程序级别密钥在数据存储中启用后续更新和event 删除。

属性名称	默认	描述
type	-	组件type名称必须是org.apache.flume.sink.solr.morphline.UUIDInterceptor $ Builder
headerName	id	要修改的Flume header 的名称
preserveExisting	true	如果UUID标头已存在，是否应保留 - true或false
prefix	“”	前缀字符串常量，用于预先添加到每个生成的UUID

Morphline Interceptor (形态拦截器)

此拦截器通过morphline配置文件过滤event ，该文件定义了一系列转换命令，用于将记录从一个命令传递到另一个命令。例如，morphline可以忽略某些event 或通过基于正则表达式的模式匹配来更改或插入某些event 头，或者它可以通过Apache Tika在截获的event 上自动检测和设置MIMEtype。例如，这种数据包嗅探可用于Flume拓扑中基于内容的动态路由。MorphlineInterceptor还可以帮助实现到多个Apache Solr集合的动态路由（例如，用于多租户）

目前，存在一个限制，即拦截器的形态线不能为每个输入event 生成多个输出记录。此拦截器不适用于重型ETL处理 - 如果需要，请考虑将ETL处理从Flume Source移至Flume Sink，例如移至MorphlineSolrSink。

必需属性以粗体显示

属性名称	默认	描述
type	-	组件type名称必须是org.apache.flume.sink.solr.morphline.MorphlineInterceptor $ Builder
morphlineFile	-	本地文件系统与morphline配置文件的相对或绝对路径。示例：/etc/flume-ng/conf/morphline.conf
morphlineId	null	如果morphline配置文件中有多个morphlines，则用于标识morphline的可选名称

Sample flume.conf file:

a1.sources.avroSrc.interceptors = morphlineinterceptor
a1.sources.avroSrc.interceptors.morphlineinterceptor.type = org.apache.flume.sink.solr.morphline.MorphlineInterceptor$Builder
a1.sources.avroSrc.interceptors.morphlineinterceptor.morphlineFile = /etc/flume-ng/conf/morphline.conf
a1.sources.avroSrc.interceptors.morphlineinterceptor.morphlineId = morphline1

搜索和替换拦截器 (Search and Replace Interceptor)

此拦截器基于Java正则表达式提供简单的基于字符串的搜索和替换功能。还可以进行回溯/群组捕捉。此拦截器使用与Java Matcher.replaceAll（）方法中相同的规则

属性名称	默认	描述
type	-	组件type名称必须是search_replace
searchPattern	-	要搜索和替换的模式。
replaceString	-	替换字符串。
charset	UTF-8	event 正文的字符集。默认false设为UTF-8。

Example configuration:

a1.sources.avroSrc.interceptors = search-replace
a1.sources.avroSrc.interceptors.search-replace.type = search_replace
 
# Remove leading alphanumeric characters in an event body.
a1.sources.avroSrc.interceptors.search-replace.searchPattern = ^[A-Za-z0-9_]+
a1.sources.avroSrc.interceptors.search-replace.replaceString =

Another example:

a1.sources.avroSrc.interceptors = search-replace
a1.sources.avroSrc.interceptors.search-replace.type = search_replace
 
# Use grouping operators to reorder and munge words on a line.
a1.sources.avroSrc.interceptors.search-replace.searchPattern = The quick brown ([a-z]+) jumped over the lazy ([a-z]+)
a1.sources.avroSrc.interceptors.search-replace.replaceString = The hungry $2 ate the careless $1

正则表达式过滤拦截器 (Regex Filtering Interceptor)

此拦截器通过将event 主体解释为文本并将文本与配置的正则表达式进行匹配来有选择地过滤event 。提供的正则表达式可用于包括event 或排除event

属性名称	默认	描述
type	-	组件type名称必须是regex_filter
regex	" .* "	用于匹配event 的正则表达式
excludeEvents	false	如果为true，则regex确定要排除的event ，否则regex确定要包括的event 。

正则表达式提取器拦截器(Regex Extractor Interceptor)

此拦截器使用指定的正则表达式提取正则表达式匹配组，并将匹配组作为标题附加到event 上。它还支持可插入序列化程序，用于在将匹配组添加为event 标头之前对其进行格式化。

属性名称	默认	描述
type	-	组件type名称必须是regex_extractor
regex	-	用于匹配event 的正则表达式
serializer	-	以空格分隔的序列化程序列表，用于映射与标题名称匹配并序列化其值。（参见下面的示例）Flume为以下序列化程序提供内置支持： org.apache.flume.interceptor.RegexExtractorInterceptorPassThroughSerializer org.apache.flume.interceptor.RegexExtractorInterceptorMillisSerializer
serializer器。 .TYPE	default	必须是default （org.apache.flume.interceptor.RegexExtractorInterceptorPassThroughSerializer），org.apache.flume.interceptor.RegexExtractorInterceptorMillisSerializer，或实现org.apache.flume.interceptor.RegexExtractorInterceptorSerializer的自定义类的FQCN
serializers..name	-
serializers.*	-	Serializer-specific properties

序列化器用于将匹配映射到标题名称和格式化标题值; 默认情况下，您只需指定标题名称，将使用默认的org.apache.flume.interceptor.RegexExtractorInterceptorPassThroughSerializer。此序列化程序只是将匹配映射到指定的标题名称，并在正则表达式提取时传递值。您可以使用完全限定的类名（FQCN）将自定义序列化程序实现插入到提取器中，以便以您喜欢的方式格式化匹配。

例1：

如果Flumeevent 主体包含 1:2:3.4foobar5 ，则使用以下配置

a1.sources.r1.interceptors.i1.regex = (\\d):(\\d):(\\d)
a1.sources.r1.interceptors.i1.serializers = s1 s2 s3
a1.sources.r1.interceptors.i1.serializers.s1.name = one
a1.sources.r1.interceptors.i1.serializers.s2.name = two
a1.sources.r1.interceptors.i1.serializers.s3.name = three

提取的event 将包含相同的主体，但后面的标题将添加一个=> 1， 两个=> 2， 三个=> 3

例2：

如果Flumeevent 正文包含2012-10-18 18:47:57,614  某些 日志 行，则使用以下配置

a1.sources.r1.interceptors.i1.regex = ^(?:\\n)?(\\d\\d\\d\\d-\\d\\d-\\d\\d\\s\\d\\d:\\d\\d)
a1.sources.r1.interceptors.i1.serializers = s1
a1.sources.r1.interceptors.i1.serializers.s1.type = org.apache.flume.interceptor.RegexExtractorInterceptorMillisSerializer
a1.sources.r1.interceptors.i1.serializers.s1.name = timestamp
a1.sources.r1.interceptors.i1.serializers.s1.pattern = yyyy-MM-dd HH:mm

提取的event 将包含相同的主体，但后面的标题将添加timestamp => 1350611220000

Flume属性

属性名称	默认	描述
flume.called.from.service	-	如果指定了此属性，则Flume agent 将继续轮询配置文件，即使在预期位置找不到配置文件也是如此。否则，如果配置在预期位置不存在，Flume agent 将终止。设置此属性时不需要属性值（例如，只需指定-Dflume.called.from.service即可）

属性：flume.called.from.service

Flume每隔30秒定期轮询一次指定配置文件的更改。如果首次轮询现有文件，或者自上次轮询以来现有文件的修改日期发生更改，Flume agent 将从配置文件加载新配置。重命名或移动文件不会更改其修改时间。当Flume agent 轮询一个不存在的文件时，会发生以下两种情况之一：

1. 当 agent 首次轮询不存在的配置文件时， agent 将根据flume.called.from.service属性执行操作。如果设置了属性，则 agent 将继续轮询（始终在同一时间 - 每30秒）。如果未设置该属性，则 agent 会立即终止
2. 当 agent 轮询一个不存在的配置文件并且这不是第一次轮询文件时， agent 不会对此轮询周期进行配置更改。 agent 继续轮询而不是终止。

配置过滤器

Flume提供了一种工具，用于以配置过滤器的形式将敏感或生成的数据注入配置。配置密钥可以设置为配置属性的值，它将由配置过滤器替换为它所代表的值

配置过滤器的常见用法

格式类似于Java表达式语言，但它目前不是一个完全有效的EL表达式解析器，只是一种看起来像它的格式

<agent_name>.configfilters = <filter_name>
<agent_name>.configfilters.<filter_name>.type = <filter_type>
 
<agent_name>.sources.<source_name>.parameter = ${<filter_name>['<key_for_sensitive_or_generated_data>']}
<agent_name>.sinks.<sink_name>.parameter = ${<filter_name>['<key_for_sensitive_or_generated_data>']}
<agent_name>.<component_type>.<component_name>.parameter = ${<filter_name>['<key_for_sensitive_or_generated_data>']}
#or
<agent_name>.<component_type>.<component_name>.parameter = ${<filter_name>["<key_for_sensitive_or_generated_data>"]}
#or
<agent_name>.<component_type>.<component_name>.parameter = ${<filter_name>[<key_for_sensitive_or_generated_data>]}
#or
<agent_name>.<component_type>.<component_name>.parameter = some_constant_data${<filter_name>[<key_for_sensitive_or_generated_data>]}

环境变量配置过滤器

属性名称	默认	描述
type	-	组件type名称必须是env

示例，要在配置中隐藏密码，请设置其值，如以下示例所示

a1.sources = r1
a1.channels = c1
a1.configfilters = f1
 
a1.configfilters.f1.type = env
 
a1.sources.r1.channels =  c1
a1.sources.r1.type = http
a1.sources.r1.keystorePassword = ${f1['my_keystore_password']} 

这里a1.source.r1.keystorePassword配置属性将获取my_keystore_password 环境变量的值。设置环境变量的一种方法是运行如下所示的flume agent：

$ my_keystore_password = Secret123 bin / flume -ng agent --conf conf --conf-file example.conf ...

外部处理配置过滤器(External Process Config Filter)

属性名称	默认	描述
type	-	组件type名称必须是外部的
command	-	将执行以获取给定键的值的命令。该命令将被调用为： 并且预期返回单行值，退出代码为0。
charset	UTF-8	返回字符串的字符集。

示例，要在配置中隐藏密码，请设置其值，如以下示例所示：

a1.sources = r1
a1.channels = c1
a1.configfilters = f1
 
a1.configfilters.f1.type = external
a1.configfilters.f1.command = /usr/bin/passwordResolver.sh
a1.configfilters.f1.charset = UTF-8
 
a1.sources.r1.channels =  c1
a1.sources.r1.type = http
a1.sources.r1.keystorePassword = ${f1['my_keystore_password']} 

在此示例中，flume将运行以下命令以获取值

$ /usr/bin/passwordResolver.sh my_keystore_password

该 passwordResolver.sh 将返回Secret123与退出代码0。

示例，要生成滚动文件sink的目录的一部分，请设置其值，如以下示例所示：

a1.sources = r1
a1.channels = c1
a1.configfilters = f1
 
a1.configfilters.f1.type = external
a1.configfilters.f1.command = /usr/bin/generateUniqId.sh
a1.configfilters.f1.charset = UTF-8
 
a1.sinks = k1
a1.sinks.k1.type = file_roll
a1.sinks.k1.channel = c1
a1.sinks.k1.sink.directory = /var/log/flume/agent_${f1['agent_name']} 

在此示例中，flume将运行以下命令以获取值

$ /usr/bin/generateUniqId.sh agent_name

该generateUniqId.sh将返回1234与退出代码0。

Hadoop 凭据存储配置过滤器

此功能的类路径上需要一个hadoop-common库（2.6+版本）。如果安装了hadoop，则 agent 会自动将其添加到类路径中

属性名称	默认	描述
type	-	组件type名称必须是hadoop
credential.provider.path	-	提供者路径。请参阅hadoop文档_here：https：//hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-common/CredentialProviderAPI.html#Configuring_the_Provider_Path
credstore.java-keystore-provider.password-file	-	如果文件用于存储密码，则为密码文件的名称。该文件必须在类路径上。可以使用HADOOP_CREDSTORE_PASSWORD环境变量设置提供程序密码，也可以将其设置为空。

示例，要在配置中隐藏密码，请设置其值，如以下示例所示：

a1.sources = r1
a1.channels = c1
a1.configfilters = f1
 
a1.configfilters.f1.type = hadoop
a1.configfilters.f1.credential.provider.path = jceks://file/<path_to_jceks file>
 
a1.sources.r1.channels =  c1
a1.sources.r1.type = http
a1.sources.r1.keystorePassword = ${f1['my_keystore_password']} 

Log4j追加 (Log4J Appender）

将Log4jevent 附加到flume agent 的avrosource。使用此appender的客户端必须在类路径中包含flume-ng-sdk（例如，flume-ng-sdk-1.9.0.jar）。必需属性以粗体显示

属性名称	默认	描述
hostname	-	使用avrosource运行远程Flume agent 的hostname。
port	-	远程Flume agent 的avrosource正在侦听的端口。
UnsafeMode	false	如果为true，则appender将不会在发送event 失败时抛出异常。
AvroReflectionEnabled	false	使用Avro Reflection来序列化Log4jevent 。（当用户记录字符串时不要使用）
AvroSchemaUrl	-	可从中检索Avro架构的URL。

示例log4j.properties文件：

#...
log4j.appender.flume = org.apache.flume.clients.log4jappender.Log4jAppender
log4j.appender.flume.Hostname = example.com
log4j.appender.flume.Port = 41414
log4j.appender.flume.UnsafeMode = true
 
# configure a class's logger to output to the flume appender
log4j.logger.org.example.MyClass = DEBUG,flume
#...

默认情况下，通过调用toString（）或使用Log4j布局（如果指定）将每个event 转换为字符串。

如果event 是org.apache.avro.generic.GenericRecord，org.apache.avro.specific.SpecificRecord的实例 ，或者属性AvroReflectionEnabled设置为true，则将使用Avro序列化序列化event 。

使用Avro架构序列化每个event 效率很低，因此最好提供一个架构URL，下游sink（通常是HDFSsink）可以从该架构URL检索架构。如果未指定AvroSchemaUrl，则架构将作为Flume标头包含在内。

示例log4j.properties文件配置为使用Avro序列化：

#...
log4j.appender.flume = org.apache.flume.clients.log4jappender.Log4jAppender
log4j.appender.flume.Hostname = example.com
log4j.appender.flume.Port = 41414
log4j.appender.flume.AvroReflectionEnabled = true
log4j.appender.flume.AvroSchemaUrl = hdfs://namenode/path/to/schema.avsc
 
# configure a class's logger to output to the flume appender
log4j.logger.org.example.MyClass = DEBUG,flume
#...

负载均衡Log4j追加 (Load Balancing Log4J Appender)

将Log4jevent 追加到flume agent的avrosource列表中。使用此appender的客户端必须在类路径中包含flume-ng-sdk（例如，flume-ng-sdk-1.9.0.jar）。该appender支持循环和随机方案，用于执行负载平衡。它还支持可配置的退避超时，以便从主机集临时删除向下 agent 。必需属性以粗体显示

属性名称	默认	描述
Hosts	-	一个以空格分隔的host：port列表，Flume（通过AvroSource）正在侦听event
Selector	ROUND_ROBIN	选择机制。必须是ROUND_ROBIN，RANDOM或自定义FQDN到继承自LoadBalancingSelector的类。
MaxBackoff	-	一个long值，表示负载平衡客户端将从无法使用event 的节点退回的最长时间（以毫秒为单位）。默认为无退避
UnsafeMode	false	如果为true，则appender将不会在发送event 失败时抛出异常。
AvroReflectionEnabled	false	使用Avro Reflection来序列化Log4jevent 。
AvroSchemaUrl	-	可从中检索Avro架构的URL。

使用默认值配置的示例log4j.properties文件：

#...
log4j.appender.out2 = org.apache.flume.clients.log4jappender.LoadBalancingLog4jAppender
log4j.appender.out2.Hosts = localhost:25430 localhost:25431
 
# configure a class's logger to output to the flume appender
log4j.logger.org.example.MyClass = DEBUG,flume
#...

使用RANDOM负载平衡配置的示例log4j.properties文件：

#...
log4j.appender.out2 = org.apache.flume.clients.log4jappender.LoadBalancingLog4jAppender
log4j.appender.out2.Hosts = localhost:25430 localhost:25431
log4j.appender.out2.Selector = RANDOM
 
# configure a class's logger to output to the flume appender
log4j.logger.org.example.MyClass = DEBUG,flume
#...

使用退避配置的示例log4j.properties文件：

#...
log4j.appender.out2 = org.apache.flume.clients.log4jappender.LoadBalancingLog4jAppender
log4j.appender.out2.Hosts = localhost:25430 localhost:25431 localhost:25432
log4j.appender.out2.Selector = ROUND_ROBIN
log4j.appender.out2.MaxBackoff = 30000
 
# configure a class's logger to output to the flume appender
log4j.logger.org.example.MyClass = DEBUG,flume
#...

安全

HDFSsink，HBasesink，Thriftsource，Thriftsink和Kite Datasetsink都支持Kerberos身份验证。请参阅相应的部分以配置与Kerberos相关的选项。

Flume agent 将作为单个主体对kerberos KDC进行身份验证，这将由需要进行kerberos身份验证的不同组件使用。为Thriftsource，Thriftsink，HDFSsink，HBasesink和DataSetsink配置的主体和keytab应该相同，否则组件将无法启动。

监控

Flume中的监控仍在进行中。变化可能经常发生。几个Flume组件向JMX平台MBean服务器报告度量标准。可以使用Jconsole查询这些指标。

可用的组件指标

下表显示了可用于组件的度量标准。每个组件仅维护一组度量，由“x”表示，未维护的值显示默认值，即0.这些表告诉您可以在何处获得有意义的数据。度量标准的名称应该足够描述，有关更多信息，您必须深入了解组件的source代码。

Sources1

	Avro	EXEC	HTTP	JMS	Kafka	MultiportSyslogTCP	Scribe
AppendAcceptedCount	X
AppendBatchAcceptedCount	X		X	X
AppendBatchReceivedCount	X		X	X
AppendReceivedCount	X
ChannelWriteFail	X		X	X	X	X	X
EventAcceptedCount	X	X	X	X	X	X	X
EventReadFail			X	X	X	X	X
EventReceivedCount	X	X	X	X	X	X	X
GenericProcessingFail			X			X
KafkaCommitTimer					X
KafkaEmptyCount					X
KafkaEventGetTimer					X
OpenConnectionCount	X

Sources 2

	SequenceGenerator	SpoolDirectory	SyslogTcp	SyslogUDP	Taildir	Thrift
AppendAcceptedCount						X
AppendBatchAcceptedCount	X	X			X	X
AppendBatchReceivedCount		X			X	X
AppendReceivedCount						X
ChannelWriteFail	X	X	X	X	X	X
EventAcceptedCount	X	X	X	X	X	X
EventReadFail		X	X	X	X
EventReceivedCount		X	X	X	X	X
GenericProcessingFail		X			X
KafkaCommitTimer
KafkaEmptyCount
KafkaEventGetTimer
OpenConnectionCount

Sinks 1

	Avro/Thrift	AsyncHBase	ElasticSearch	HBase的	HBase2
BatchCompleteCount	X	X	X	X	X
BatchEmptyCount	X	X	X	X	X
BatchUnderflowCount	X	X	X	X	X
ChannelReadFail	X				X
ConnectionClosedCount	X	X	X	X	X
ConnectionCreatedCount	X	X	X	X	X
ConnectionFailedCount	X	X	X	X	X
EventDrainAttemptCount	X	X	X	X	X
EventDrainSuccessCount	X	X	X	X	X
EventWriteFail	X				X
KafkaEventSendTimer
RollbackCount

Sinks 2

	HDFSEvent	Hive	HTTP	Kafka	Morphline	RollingFile
BatchCompleteCount	X	X			X
BatchEmptyCount	X	X		X	X
BatchUnderflowCount	X	X		X	X
ChannelReadFail	X	X	X	X	X	X
ConnectionClosedCount	X	X				X
ConnectionCreatedCount	X	X				X
ConnectionFailedCount	X	X				X
EventDrainAttemptCount	X	X	X		X	X
EventDrainSuccessCount	X	X	X	X	X	X
EventWriteFail	X	X	X	X	X	X
KafkaEventSendTimer				X
RollbackCount				X

Channels

	File	Kafka	Memory	PseudoTxnMemory	SpillableMemory
ChannelCapacity	X		X		X
Channelize	X		X	X	X
CheckpointBackupWriteErrorCount	X
CheckpointWriteErrorCount	X
EventPutAttemptCount	X	X	X	X	X
EventPutErrorCount	X
EventPutSuccessCount	X	X	X	X	X
EventTakeAttemptCount	X	X	X	X	X
EventTakeErrorCount	X
EventTakeSuccessCount	X	X	X	X	X
KafkaCommitTimer		X
KafkaEventGetTimer		X
KafkaEventSendTimer		X
Open	X
RollbackCounter		X
Unhealthy	X

JMX 报告

可以通过使用flume-env.sh在JAVA_OPTS环境变量中指定JMX参数来启用JMX报告，如

export JAVA_OPTS =“ - Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port = 5445 -Dcom.sun.management.jmxremote.authenticate = false -Dcom.sun.management.jmxremote.ssl = false”

注意：上面的示例禁用安全性。要启用安全性，请参阅http://docs.oracle.com/javase/6/docs/technotes/guides/management/agent.html

Ganglia 报告

Flume还可以将这些指标报告给Ganglia 3或Ganglia 3.1元节点。要向Ganglia报告指标，必须使用此支持启动水槽 agent 。必须通过传递以下参数来启动Flume agent ，作为以flume.monitoring为前缀的系统属性。，可以在flume-env.sh中指定：

属性名称	默认	描述
type	-	组件type名称必须是ganglia
hosts	-	逗号分隔的hostname列表： Ganglia服务器的端口
pollFrequency	60	连续向Ganglia服务器报告之间的时间（以秒为单位）
isGanglia3	false	Ganglia服务器版本为3.默认情况下，Flume以Ganglia 3.1格式发送

我们可以通过Ganglia支持启动Flume，如下所示：

$ bin/flume-ng agent --conf-file example.conf --name a1 -Dflume.monitoring.type=ganglia -Dflume.monitoring.hosts=com.example:1234,com.example2:5455

JSON 报告

Flume还可以以JSON格式报告指标。为了以JSON格式启用报告，Flume在可配置端口上托管Web服务器。Flume以以下JSON格式报告指标：

{
"typeName1.componentName1" : {"metric1" : "metricValue1", "metric2" : "metricValue2"},
"typeName2.componentName2" : {"metric3" : "metricValue3", "metric4" : "metricValue4"}
}

这是一个例子：

{
"CHANNEL.fileChannel":{"EventPutSuccessCount":"468085",
                      "Type":"CHANNEL",
                      "StopTime":"0",
                      "EventPutAttemptCount":"468086",
                      "ChannelSize":"233428",
                      "StartTime":"1344882233070",
                      "EventTakeSuccessCount":"458200",
                      "ChannelCapacity":"600000",
                      "EventTakeAttemptCount":"458288"},
"CHANNEL.memChannel":{"EventPutSuccessCount":"22948908",
                   "Type":"CHANNEL",
                   "StopTime":"0",
                   "EventPutAttemptCount":"22948908",
                   "ChannelSize":"5",
                   "StartTime":"1344882209413",
                   "EventTakeSuccessCount":"22948900",
                   "ChannelCapacity":"100",
                   "EventTakeAttemptCount":"22948908"}
}

属性名称	默认	描述
type	-	组件type名称必须是http
port	41414	启动服务器的端口。

$ bin/flume-ng agent --conf-file example.conf --name a1 -Dflume.monitoring.type=http -Dflume.monitoring.port=34545

然后，可以在 http://<hostname>:<port>/metrics 网页上获得度量标准。自定义组件可以报告上面Ganglia部分中提到的指标。

自定义报告

可以通过编写执行报告的服务器向其他系统报告指标。任何报告类都必须实现org.apache.flume.instrumentation.MonitorService接口 。这样的类可以与GangliaServer用于报告的方式相同。他们可以轮询平台mbean服务器以轮询mbeans以获取指标。例如，如果可以使用名为HTTPReporting的HTTP监视服务，如下所示：

$ bin/flume-ng agent --conf-file example.conf --name a1 -Dflume.monitoring.type=com.example.reporting.HTTPReporting -Dflume.monitoring.node=com.example:332

属性名称	默认	描述
type	-	组件type名称必须是FQCN

从自定义组件报告指标

任何自定义flume组件都应继承自 org.apache.flume.instrumentation.MonitoredCounterGroup类。然后，该类应为其公开的每个度量标准提供getter方法。请参阅下面的代码。MonitoredCounterGroup需要一个属性列表，其度量由此类公开。截至目前，此类仅支持将度量标准公开为长值。

public class SinkCounter extends MonitoredCounterGroup implements
    SinkCounterMBean {
 
  private static final String COUNTER_CONNECTION_CREATED =
    "sink.connection.creation.count";
 
  private static final String COUNTER_CONNECTION_CLOSED =
    "sink.connection.closed.count";
 
  private static final String COUNTER_CONNECTION_FAILED =
    "sink.connection.failed.count";
 
  private static final String COUNTER_BATCH_EMPTY =
    "sink.batch.empty";
 
  private static final String COUNTER_BATCH_UNDERFLOW =
      "sink.batch.underflow";
 
  private static final String COUNTER_BATCH_COMPLETE =
    "sink.batch.complete";
 
  private static final String COUNTER_EVENT_DRAIN_ATTEMPT =
    "sink.event.drain.attempt";
 
  private static final String COUNTER_EVENT_DRAIN_SUCCESS =
    "sink.event.drain.sucess";
 
  private static final String[] ATTRIBUTES = {
    COUNTER_CONNECTION_CREATED, COUNTER_CONNECTION_CLOSED,
    COUNTER_CONNECTION_FAILED, COUNTER_BATCH_EMPTY,
    COUNTER_BATCH_UNDERFLOW, COUNTER_BATCH_COMPLETE,
    COUNTER_EVENT_DRAIN_ATTEMPT, COUNTER_EVENT_DRAIN_SUCCESS
  };
 
 
  public SinkCounter(String name) {
    super(MonitoredCounterGroup.Type.SINK, name, ATTRIBUTES);
  }
 
  @Override
  public long getConnectionCreatedCount() {
    return get(COUNTER_CONNECTION_CREATED);
  }
 
  public long incrementConnectionCreatedCount() {
    return increment(COUNTER_CONNECTION_CREATED);
  }
 
}

工具

文件channel完整性工具

文件channel完整性工具可验证文件channel中各个event 的完整性，并删除损坏的event

这些工具可以按如下方式运行：

$bin/flume-ng tool --conf ./conf FCINTEGRITYTOOL -l ./datadir -e org.apache.flume.MyEventValidator -DmaxSize 2000

其中datadir是要验证的数据目录的逗号分隔列表。

以下是可用选项

选项名称	描述
h/help	显示帮助
l/dataDirs	以逗号分隔的工具必须验证的数据目录列表

event 验证工具

event 验证器工具可用于以特定于应用程序的方式验证文件channelevent 。该工具在每个event 上应用用户提供程序验证登录，并删除未向逻辑确认的event

这些工具可以按如下方式运行：

$bin/flume-ng tool --conf ./conf FCINTEGRITYTOOL -l ./datadir -e org.apache.flume.MyEventValidator -DmaxSize 2000

其中datadir是要验证的数据目录的逗号分隔列表。

以下是可用选项

选项名称	描述
h/help	显示帮助
l/dataDirs	以逗号分隔的工具必须验证的数据目录列表
e/eventValidator	完全合格的event 验证器实现名称。jar必须在Flume类路径上

Event验证器实现必须实现EventValidator接口。建议不要从实现中抛出任何异常，因为它们被视为无效event 。其他参数可以通过-D选项传递给EventValitor实现。

让我们看一个基于简单大小的event 验证器的示例，它将拒绝大于指定的最大大小的event

public static class MyEventValidator implements EventValidator {
 
  private int value = 0;
 
  private MyEventValidator(int val) {
    value = val;
  }
 
  @Override
  public boolean validateEvent(Event event) {
    return event.getBody() <= value;
  }
  public static class Builder implements EventValidator.Builder {
    private int sizeValidator = 0;
    @Override
    public EventValidator build() {
      return new DummyEventVerifier(sizeValidator);
    }
    @Override
    public void configure(Context context) {
      binaryValidator = context.getInteger("maxSize");
    }
  }
}

拓扑设计注意事项

Flume非常灵活，允许大量可能的部署方案。如果您计划在大型生产部署中使用Flume，那么花一些时间考虑如何根据Flume拓扑来表达您的问题是明智的。本节介绍一些注意事项

Flume 是否适合您的问题？

如果您需要将文本日志数据提取到Hadoop / HDFS中，那么Flume最适合您的问题，完全停止。对于其他用例，以下是一些指导原则：

Flume旨在通过相对稳定，可能复杂的拓扑来传输和摄取定期生成的event 数据。“event 数据”的概念定义非常广泛。对Flume来说，event 只是一个普通的字节。event 的大小有一些限制 - 例如，它不能大于您可以存储在内存中或单个机器上的磁盘上 - 但实际上，水槽event 可以是从文本日志条目到图像文件的所有内容。event 的关键属性是它们以连续的流式方式生成。如果您的数据没有定期生成（即您尝试将大量数据批量加载到Hadoop集群中），那么Flume仍然可以正常工作，但对您的情况来说可能有点过头了。Flume喜欢相对稳定的拓扑结构。您的拓扑不需要是不可变的，因为Flume可以处理拓扑中的更改而不会丢失数据，并且还可以容忍由于故障转移或配置而定期重新配置。如果您每天都要更改拓扑结构，那么它可能无法正常工作，因为重新配置需要一些思考和开销。

Flume 中的流量可靠性

Flume流的可靠性取决于几个因素。通过调整这些因素，您可以使用Flume实现各种可靠性选项。

您使用什么type的channel 。Flume具有持久的channel（将数据保存到磁盘的channel）和非持久channel（如果机器出现故障将丢失数据）。持久channel使用基于磁盘的存储，存储在此类channel中的数据将在机器重启或非磁盘相关故障中持续存在。

您的channel是否已为工作量充分配置。Flume中的channel充当各种跳跃的缓冲区。这些缓冲区具有固定容量，一旦该容量已满，您将在流中的早期点创建背压。如果此压力传播到流量source，Flume将变得不可用并可能丢失数据。

您是否使用冗余拓扑。Flume让你在冗余拓扑中复制流。这可以提供非常容易的容错source，并且可以克服磁盘或机器故障。

考虑Flume拓扑结构中可靠性的最佳方法是考虑各种故障情况及其结果。如果磁盘发生故障会怎么样？如果机器出现故障会怎样？如果您的终端sink（例如HDFS）停机一段时间并且您有背压，会发生什么？可能的设计空间巨大，但您需要提出的基本问题只是极少数。

Flow 拓扑设计

设计Flume拓扑的第一步是枚举数据的所有source和目标（终端sink）。这些将定义拓扑的边缘点。下一个考虑因素是是否引入中间聚合层或event 路由。如果要从大量source中收集数据，则聚合数据以简化终端sink的提取可能会有所帮助。聚合层还可以通过充当缓冲区来消除source的突发性或sink的不可用性。如果要在不同位置之间路由数据，您可能还希望在不同点分割流：这会创建可能本身包含聚合点的子拓扑。

调整Flume部署的大小

一旦了解了拓扑的外观，下一个问题就是需要多少硬件和网络容量。首先，量化您生成的数据量。这并不总是一项简单的任务！大多数数据流是突发性的（例如，由于昼夜模式）并且可能是不可预测的。一个好的起点是考虑每个拓扑层中的最大吞吐量，包括每秒event 数和每秒字节数。一旦知道给定层的所需吞吐量，就可以计算该层所需节点数的下限。要确定可达到的吞吐量，最好使用合成或采样event 数据在硬件上试验Flume。通常，基于磁盘的channel应该获得10的MB / s，而基于内存的channel应该达到100的MB / s或更多。但性能会有很大差异，具体取决于硬件和操作环境。

调整聚合吞吐量可以为每层提供所需节点数量的下限。有几个原因需要额外的节点，例如增加冗余和更好地吸收负载中的突发。

故障排除

处理 agent 失败

如果Flume agent 程序关闭，则该 agent 程序上托管的所有流程都将中止。重新启动 agent 后，将恢复流程。使用文件channel或其他稳定channel的流将从中断处继续处理event 。如果无法在同一硬件上重新启动 agent ，则可以选择将数据库迁移到另一个硬件并设置新的Flume agent ，该 agent 可以继续处理db中保存的event 。可以利用数据库HA期货将Flume agent 移动到另一个主机。

兼容性

HDFS

目前Flume支持HDFS 0.20.2和0.23。

组件摘要

Component Interface	Type Alias	Implementation Class
org.apache.flume.Channel	memory	org.apache.flume.channel.MemoryChannel
org.apache.flume.Channel	jdbc	org.apache.flume.channel.jdbc.JdbcChannel
org.apache.flume.Channel	file	org.apache.flume.channel.file.FileChannel
org.apache.flume.Channel	–	org.apache.flume.channel.PseudoTxnMemoryChannel
org.apache.flume.Channel	–	org.example.MyChannel
org.apache.flume.Source	avro	org.apache.flume.source.AvroSource
org.apache.flume.Source	netcat	org.apache.flume.source.NetcatSource
org.apache.flume.Source	seq	org.apache.flume.source.SequenceGeneratorSource
org.apache.flume.Source	exec	org.apache.flume.source.ExecSource
org.apache.flume.Source	syslogtcp	org.apache.flume.source.SyslogTcpSource
org.apache.flume.Source	multiport_syslogtcp	org.apache.flume.source.MultiportSyslogTCPSource
org.apache.flume.Source	syslogudp	org.apache.flume.source.SyslogUDPSource
org.apache.flume.Source	spooldir	org.apache.flume.source.SpoolDirectorySource
org.apache.flume.Source	http	org.apache.flume.source.http.HTTPSource
org.apache.flume.Source	thrift	org.apache.flume.source.ThriftSource
org.apache.flume.Source	jms	org.apache.flume.source.jms.JMSSource
org.apache.flume.Source	–	org.apache.flume.source.avroLegacy.AvroLegacySource
org.apache.flume.Source	–	org.apache.flume.source.thriftLegacy.ThriftLegacySource
org.apache.flume.Source	–	org.example.MySource
org.apache.flume.Sink	null	org.apache.flume.sink.NullSink
org.apache.flume.Sink	logger	org.apache.flume.sink.LoggerSink
org.apache.flume.Sink	avro	org.apache.flume.sink.AvroSink
org.apache.flume.Sink	hdfs	org.apache.flume.sink.hdfs.HDFSEventSink
org.apache.flume.Sink	hbase	org.apache.flume.sink.hbase.HBaseSink
org.apache.flume.Sink	hbase2	org.apache.flume.sink.hbase2.HBase2Sink
org.apache.flume.Sink	asynchbase	org.apache.flume.sink.hbase.AsyncHBaseSink
org.apache.flume.Sink	elasticsearch	org.apache.flume.sink.elasticsearch.ElasticSearchSink
org.apache.flume.Sink	file_roll	org.apache.flume.sink.RollingFileSink
org.apache.flume.Sink	irc	org.apache.flume.sink.irc.IRCSink
org.apache.flume.Sink	thrift	org.apache.flume.sink.ThriftSink
org.apache.flume.Sink	–	org.example.MySink
org.apache.flume.ChannelSelector	replicating	org.apache.flume.channel.ReplicatingChannelSelector
org.apache.flume.ChannelSelector	multiplexing	org.apache.flume.channel.MultiplexingChannelSelector
org.apache.flume.ChannelSelector	–	org.example.MyChannelSelector
org.apache.flume.SinkProcessor	default	org.apache.flume.sink.DefaultSinkProcessor
org.apache.flume.SinkProcessor	failover	org.apache.flume.sink.FailoverSinkProcessor
org.apache.flume.SinkProcessor	load_balance	org.apache.flume.sink.LoadBalancingSinkProcessor
org.apache.flume.SinkProcessor	–
org.apache.flume.interceptor.Interceptor	timestamp	org.apache.flume.interceptor.TimestampInterceptor$Builder
org.apache.flume.interceptor.Interceptor	host	org.apache.flume.interceptor.HostInterceptor$Builder
org.apache.flume.interceptor.Interceptor	static	org.apache.flume.interceptor.StaticInterceptor$Builder
org.apache.flume.interceptor.Interceptor	regex_filter	org.apache.flume.interceptor.RegexFilteringInterceptor$Builder
org.apache.flume.interceptor.Interceptor	regex_extractor	org.apache.flume.interceptor.RegexFilteringInterceptor$Builder
org.apache.flume.channel.file.encryption.KeyProvider$Builder	jceksfile	org.apache.flume.channel.file.encryption.JCEFileKeyProvider
org.apache.flume.channel.file.encryption.KeyProvider$Builder	–	org.example.MyKeyProvider
org.apache.flume.channel.file.encryption.CipherProvider	aesctrnopadding	org.apache.flume.channel.file.encryption.AESCTRNoPaddingProvider
org.apache.flume.channel.file.encryption.CipherProvider	–	org.example.MyCipherProvider
org.apache.flume.serialization.EventSerializer$Builder	text	org.apache.flume.serialization.BodyTextEventSerializer$Builder
org.apache.flume.serialization.EventSerializer$Builder	avro_event	org.apache.flume.serialization.FlumeEventAvroEventSerializer$Builder
org.apache.flume.serialization.EventSerializer$Builder	–	org.example.MyEventSerializer$Builder

别名约定

这些别名的约定在上面的组件特定示例中使用，以使所有示例中的名称保持简短和一致。

Alias Name	Alias Type
a	agent
c	channel
r	source
k	sink
g	sink group
i	interceptor
y	key
h	host
s	serializer

原文链接：

1. https://blog.csdn.net/zhanglong_4444/article/details/88525489