Fume 1.9.0 用户指南_flume1.9.0用户指南-CSDN博客

本文链接：https://blog.csdn.net/weixin_44328257/article/details/126433093

FlFume 1.9.0 用户指南

介绍

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

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

Apache Flume是Apache软件基金会的顶级项目。

系统要求

Java 运行时环境 - Java 1.8 或更高版本
内存 - 足够的内存用于源、通道或接收器使用的配置
磁盘空间 - 足够的磁盘空间用于通道或接收器使用的配置
目录权限 - 代理使用的目录的读/写权限

建筑

数据流模型

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

Flume 源使用由外部源（如 Web 服务器）传递给它的事件。外部源以目标 Flume 源识别的格式将事件发送到 Flume。例如，Avro Flume 源可用于从 Avro 客户端或流中从 Avro 接收器发送事件的流中的其他 Flume 代理接收 Avro 事件。可以使用节俭水槽源定义类似的流，以从节俭汇或 Flume 节俭 Rpc 客户端或用从 Flume 节俭协议生成的任何语言编写的节俭客户端接收事件。当 Flume 源接收到事件时，它会将其存储到一个或多个通道中。通道是一个被动存储，它保留事件，直到它被 Flume 接收器消耗。文件通道就是一个例子 - 它由本地文件系统支持。接收器从通道中删除事件，并将其放入 HDFS 等外部存储库（通过 Flume HDFS 接收器），或将其转发到流中下一个 Flume 代理（下一跃点）的 Flume 源。给定代理中的源和接收器与通道中暂存的事件异步运行。

复杂流程

Flume允许用户构建多跳流，其中事件在到达最终目的地之前通过多个代理。它还允许扇入和扇出流、上下文路由和故障跃点的备份路由（故障转移）。

可靠性

事件在每个代理上的通道中暂存。然后，事件将传递到流中的下一个代理或终端存储库（如 HDFS）。只有在将事件存储在下一个代理的通道或终端存储库中后，才会从通道中删除这些事件。这就是 Flume 中的单跳消息传递语义如何提供流的端到端可靠性。

Flume使用事务性方法来保证事件的可靠交付。源和接收器分别在事务中封装了通道提供的事务中放置的事件或由通道提供的事务提供的事件的存储/检索。这可确保在流中可靠地将事件集从一个点传递到另一个点。在多跃点流的情况下，来自上一跃点的接收器和来自下一跃点的源都运行其事务，以确保数据安全地存储在下一跃点的通道中。

可恢复性

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

设置

设置代理

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

配置单个组件

流中的每个组件（源、接收器或通道）都有一个特定于类型和实例化的名称、类型和一组属性。例如，Avro 源需要主机名（或 IP 地址）和端口号才能从中接收数据。内存通道可以具有最大队列大小（“容量”），HDFS接收器需要知道文件系统URI，创建文件的路径，文件旋转的频率（“hdfs.rollInterval”）等。组件的所有此类属性都需要在宿主 Flume 代理的属性文件中进行设置。

将各个部分连接在一起

代理需要知道要加载哪些单个组件以及它们如何连接以构成流。这是通过列出代理中每个源、接收器和通道的名称，然后为每个接收器和源指定连接通道来完成的。例如，代理通过称为 file-channel 的文件通道将事件从名为 avroWeb 的 Avro 源流向 HDFS 接收器 hdfs-cluster1。配置文件将包含这些组件的名称和文件通道，作为 avroWeb 源和 hdfs-cluster1 接收器的共享通道。

启动代理

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

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

现在，代理将开始运行在给定属性文件中配置的源和接收器。

一个简单的例子

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

# 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 的代理。a1 具有侦听端口 44444 上数据的源、在内存中缓冲事件数据的通道以及将事件数据记录到控制台的接收器。配置文件命名各种组件，然后描述其类型和配置参数。给定的配置文件可能定义多个命名代理;当一个给定的Flume进程启动时，传递一个标志，告诉它要显示哪个命名代理。

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

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

请注意，在完整部署中，我们通常会再包含一个选项：--conf=<conf-dir>。<conf-dir>目录将包含一个 shell 脚本 flume-env.sh，并可能包含一个 log4j 属性文件。在此示例中，我们传递一个 Java 选项来强制 Flume 登录到控制台，并且我们没有自定义环境脚本。

然后，我们可以从单独的终端远程登录到端口 44444 并向 Flume 发送一个事件：

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

原始 Flume 终端将在日志消息中输出事件。

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 代理！后续部分将更详细地介绍代理配置。

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

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

注意：它目前仅适用于值，不适用于键。（即仅在配置行的= 标记的“右侧”上。

这可以通过代理调用上的Java系统属性启用，方法是设置属性实现= org.apache.flume.node.EnvVarResolverProperties。

例如：：

$ 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 中设置。

记录原始数据

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

调试事件管道问题的一种方法是设置连接到记录器接收器的附加内存通道，该通道将所有事件数据输出到 Flume 日志。然而，在某些情况下，这种方法是不够的。

为了启用与事件和配置相关的数据的日志记录，除了 log4j 属性之外，还必须设置一些 Java 系统属性。

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

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

基于动物园管理员的配置

Flume通过Zookeeper支持Agent配置。这是一项实验性功能。配置文件需要上传到 Zookeeper 中，使用可配置的前缀。配置文件存储在 Zookeeper 节点数据中。以下是 Zookeeper Node 树对于代理 a1 和 a2 的外观

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

上传配置文件后，使用以下选项启动代理

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

参数名称	违约	描述
z	–	动物园管理员连接字符串。以逗号分隔的主机名列表：端口
p	/水槽	Zookeeper 中用于存储代理配置的基本路径

安装第三方插件

Flume具有完全基于插件的架构。虽然Flume附带了许多开箱即用的源，通道，接收器，序列化程序等，但存在许多与Flume分开的实现。

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

插件.d 目录

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

插件的目录布局

Each plugin (subdirectory) within plugins.d can have up to three sub-directories:

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

Example of two plugins within the plugins.d directory:

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支持多种机制从外部来源摄取数据。

断续器

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

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

上述命令会将 /usr/logs/log.10 的内容发送到侦听该端口的 Flume 源。

执行命令

有一个执行给定命令并使用输出的 exec 源。输出的单个“行”，即。文本后跟回车符（'\r'）和/或换行符（'\n'）。

网络流

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

阿夫罗
节俭
系统日志
网猫

设置多代理流

为了在多个代理或跃点之间流动数据，前一个代理的接收器和当前跃点的源必须是 avro 类型，接收器指向源的主机名（或 IP 地址）和端口。

固结

日志收集中一个非常常见的方案是大量生成日志的客户端将数据发送到附加到存储子系统的一些使用者代理。例如，从数百个Web服务器收集的日志发送到写入HDFS集群的十几个代理。

这可以在Flume中通过配置许多具有avro接收器的第一层代理来实现，所有这些代理都指向单个代理的avro源（同样，在这种情况下可以使用节俭源/接收器/客户端）。第二层代理上的此源将收到的事件合并到单个通道中，该通道由接收器使用到其最终目标。

多路复用流

Flume 支持将事件流多路复用到一个或多个目标。这是通过定义一个流多路复用器来实现的，该多路复用器可以将事件复制或有选择地路由到一个或多个通道。

上面的示例显示了来自代理“foo”的源，该源将流扇出到三个不同的通道。此扇出可以是复制或多路复用。在复制流的情况下，每个事件都发送到所有三个通道。对于多路复用情况，当事件的属性与预配置的值匹配时，事件将传递到可用通道的子集。例如，如果名为“txnType”的事件属性设置为“客户”，那么它应该转到channel1和channel3，如果它是“供应商”，那么它应该转到channel2，否则是channel3。可以在代理的配置文件中设置映射。

配置

如前面一节所述，从类似于具有分层属性设置的 Java 属性文件格式的文件中读取 Flume 代理配置。

定义流

要在单个代理中定义流，您需要通过通道链接源和接收器。您需要列出给定代理的源、接收器和通道，然后将源和接收器指向通道。源实例可以指定多个通道，但接收器实例只能指定一个通道。格式如下：

# 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 的代理正在从外部 avro 客户端读取数据，并通过内存通道将其发送到 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

这将使事件通过内存通道 mem-channel-1 从 avro-AppSrv-source 流向 hdfs-Cluster1-sink。当使用 weblog.config 作为其配置文件启动代理时，它将实例化该流。

配置单个组件

定义流后，需要设置每个源、接收器和通道的属性。这是以相同的分层命名空间方式完成的，您可以在其中为特定于每个组件的属性设置组件类型和其他值：

# properties for sources
<Agent>.sources.<Source>.<someProperty> = <someValue>

# properties for channels
<Agent>.channel.<Channel>.<someProperty> = <someValue>

# properties for sinks
<Agent>.sources.<Sink>.<someProperty> = <someValue>

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

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

#...

在代理中添加多个流

单个 Flume 试剂可以包含几个独立的水流。您可以在配置中列出多个源、接收器和通道。这些组件可以链接以形成多个流：

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

然后，可以将源和接收器链接到其相应的通道（对于源）的通道（对于接收器），以设置两个不同的流。例如，如果您需要在代理中设置两个流，一个从外部avro客户端到外部HDFS，另一个从尾部输出到avro接收器，那么这里有一个配置来做到这一点：

# 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

配置多代理流

若要设置多层流，需要有一个第一跃点的 avro/thrift 接收器，指向下一跃点的 avro/节俭源。这将导致第一个 Flume 代理将事件转发到下一个 Flume 代理。例如，如果您使用 avro 客户端定期将文件（每个事件 1 个文件）发送到本地 Flume 代理，则此本地代理可以将其转发到已装载以进行存储的另一个代理。

博客代理配置：

# 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 代理配置：

# 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
#...

在这里，我们将来自博客代理的avro-forward-sink链接到hdfs代理的avro-collection-source。这将导致来自外部应用程序服务器源的事件最终存储在HDFS中。

扇出流量

如上一节所述，Flume 支持将流从一个源扇出到多个通道。扇出有两种模式，复制和多路复用。在复制流中，事件将发送到所有已配置的通道。在多路复用的情况下，事件仅发送到合格通道的子集。要扇出流，需要为源指定通道列表以及将其扇出的策略。这是通过添加可以复制或多路复用的通道“选择器”来完成的。然后进一步指定选择规则（如果它是多路复用器）。如果未指定选择器，则默认情况下，它会复制：

# 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

多路复用选择具有进一步的属性集，用于对流进行分叉。这需要指定事件属性到通道集的映射。选择器检查事件标头中的每个已配置属性。如果它与指定的值匹配，则该事件将发送到映射到该值的所有通道。如果没有匹配项，则将事件发送到配置为默认值的通道集：

# 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>

该映射允许重叠每个值的通道。

以下示例具有多路复用到两条路径的单个流。名为 agent_foo 的代理具有一个 avro 源和两个链接到两个接收器的通道：

# 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”则将其发送到file-channel-2，或者如果其“NY”则两者兼而有之。如果未设置“State”标头或与这三者中的任何一个都不匹配，则它将转到mem-channel-1，该标头被指定为“默认”。

选择器还支持可选通道。要为标头指定可选通道，请按以下方式使用配置参数“可选”：

# 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

选择器将首先尝试写入所需的通道，如果这些通道中的一个通道无法使用事件，则事务将失败。在所有通道上重新尝试事务。一旦所有必需的通道都消耗了事件，则选择器将尝试写入可选通道。任何可选通道使用事件的失败将被忽略，并且不会重试。

如果特定标头的可选通道和所需通道之间存在重叠，则认为该通道是必需的，并且通道中的故障将导致重试整个所需通道集。例如，在上面的示例中，对于标头，“CA”mem-channel-1 被视为必需通道，即使它同时标记为必需和可选，并且未能写入此通道将导致在为选择器配置的所有通道上重试该事件。

请注意，如果标头没有任何必需的通道，则事件将写入默认通道，并尝试写入该标头的可选通道。如果未指定必需的通道，则指定可选通道仍会导致将事件写入默认通道。如果没有通道被指定为默认值，并且没有必需通道，则选择器将尝试将事件写入可选通道。在这种情况下，任何故障都会被忽略。

SSL/TLS 支持

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

元件	SSL 服务器或客户端
阿夫罗来源	服务器
阿夫罗水槽	客户
节俭源	服务器
节俭水槽	客户
卡夫卡来源	客户
卡夫卡海峡	客户
卡夫卡水槽	客户
源码	服务器
JMS 源	客户
系统日志 TCP 源	服务器
多端口系统日志 TCP 源	服务器

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

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

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

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

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

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

系统属性	环境变量	描述
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 系统属性。

The SSL environment variables can either be set in the shell environment before starting Flume or in conf/flume-env.sh. (Although, using the command line is inadvisable because the commands including the passwords will be saved to the command history.)

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

Please note:

SSL must be enabled at component level. Specifying the global SSL parameters alone will not have any effect.
If the global SSL parameters are specified at multiple levels, the priority is the following (from higher to lower):
- component parameters in agent config
- system properties
- environment variables
如果为组件启用了 SSL，但未以上述任何方式指定 SSL 参数，则
- 在密钥库的情况下：配置错误
- 在信任库的情况下：将使用默认信任库（Oracle JDK中的jssecacerts / cacerts）
在所有情况下，信任者密码都是可选的。如果未指定，那么当 JDK 打开信任库时，不会对信任库执行完整性检查。

源和接收器批大小以及通道事务容量

源和接收器可以具有一个批大小参数，该参数确定它们在一个批中处理的最大事件数。这发生在具有称为事务容量上限的通道事务中。批大小必须小于通道的事务容量。有一个显式检查，以防止不兼容的设置。每当读取配置时，都会进行此检查。

水槽源

阿夫罗来源

侦听 Avro 端口并从外部 Avro 客户端流接收事件。当与另一个（上一跃点）Flume 代理上的内置 Avro 接收器配对时，它可以创建分层集合拓扑。必需的属性以粗体显示。

属性名称	违约	描述
渠道	–
类型	–	组件类型名称，需要为 avro
捆	–	要侦听的主机名或 IP 地址
港口	–	要绑定到的端口 #
线程	–	要生成的最大工作线程数
选择器.类型
选择器。
拦截器	–	以空间分隔的拦截器列表
拦截器。
压缩型	没有	这可以是“无”或“放气”。压缩类型必须与匹配的 AvroSource 的压缩类型匹配
断续器	假	将此值设置为 true 可启用 SSL 加密。如果启用了 SSL，那么还必须通过组件级参数（见下文）或全局 SSL 参数（请参阅 SSL/TLS 支持部分）指定“密钥库”和“密钥库密码”。
密钥库	–	这是 Java 密钥库文件的路径。如果未在此处指定，则将使用全局密钥库（如果已定义，否则为配置错误）。
密钥库密码	–	Java 密钥库的密码。如果未在此处指定，则将使用全局密钥库密码（如果已定义，否则为配置错误）。
密钥库类型	断续器	Java 密钥库的类型。这可以是“JKS”或“PKCS12”。如果未在此处指定，则将使用全局密钥库类型（如果已定义，否则缺省值为 JKS）。
排除协议	SSLv3	要排除的 SSL/TLS 协议的空格分隔列表。除了指定的协议之外，SSLv3 将始终被排除在外。
包含协议	–	要包含的 SSL/TLS 协议的空格分隔列表。启用的协议将是包含的协议，但没有排除的协议。如果包含的协议为空，则它包括所有受支持的协议。
排除密码套件	–	要排除的密码套件的空格分隔列表。
包含密码套件	–	要包含的密码套件的空格分隔列表。启用的密码套件将是包含的密码套件，但没有排除的密码套件。如果包含的密码套件为空，则它包括所有受支持的密码套件。
ipFilter	假	将此值设置为 true 可为 netty 启用 ipFiltering
ipFilterRules	–	使用此配置定义 N 个 netty ipFilter 模式规则。

名为 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，用逗号分隔，模式规则必须采用此格式。

<“允许”或“拒绝>：<”ip“或”名称“表示计算机名称>：<模式>或允许/拒绝：ip/名称：模式

example: ipFilterRules=allow:ip:127.*,allow:name:localhost,deny:ip:*

Note that the first rule to match will apply as the example below shows from a client on the localhost

This will Allow the client on localhost be deny clients from any other ip “allow:name:localhost,deny:ip:” This will deny the client on localhost be allow clients from any other ip “deny:name:localhost,allow:ip:“

Thrift Source

Listens on Thrift port and receives events from external Thrift client streams. When paired with the built-in ThriftSink on another (previous hop) Flume agent, it can create tiered collection topologies. Thrift source can be configured to start in secure mode by enabling kerberos authentication. agent-principal and agent-keytab are the properties used by the Thrift source to authenticate to the kerberos KDC. Required properties are in bold.

Property Name	Default	Description
channels	–
type	–	The component type name, needs to be thrift
bind	–	hostname or IP address to listen on
port	–	Port # to bind to
threads	–	Maximum number of worker threads to spawn
selector.type
selector.*
interceptors	–	Space separated list of interceptors
interceptors.*
断续器	假	将此值设置为 true 可启用 SSL 加密。如果启用了 SSL，那么还必须通过组件级参数（见下文）或全局 SSL 参数（请参阅 SSL/TLS 支持部分）指定“密钥库”和“密钥库密码”
密钥库	–	这是 Java 密钥库文件的路径。如果未在此处指定，则将使用全局密钥库（如果已定义，否则为配置错误）。
密钥库密码	–	Java 密钥库的密码。如果未在此处指定，则将使用全局密钥库密码（如果已定义，否则为配置错误）。
密钥库类型	断续器	Java 密钥库的类型。这可以是“JKS”或“PKCS12”。如果未在此处指定，则将使用全局密钥库类型（如果已定义，否则缺省值为 JKS）。
排除协议	SSLv3	要排除的 SSL/TLS 协议的空格分隔列表。除了指定的协议之外，SSLv3 将始终被排除在外。
包含协议	–	要包含的 SSL/TLS 协议的空格分隔列表。启用的协议将是包含的协议，但没有排除的协议。如果包含的协议为空，则它包括所有受支持的协议。
排除密码套件	–	要排除的密码套件的空格分隔列表。
包含密码套件	–	要包含的密码套件的空格分隔列表。启用的密码套件将是包含的密码套件，但没有排除的密码套件。
克贝罗斯	假	设置为 true 可启用 kerberos 身份验证。在 kerberos 模式下，需要代理主体和代理密钥表才能成功进行身份验证。安全模式下的 Thrift 源将仅接受来自已启用 Kerberos 并已成功通过 Kerberos KDC 身份验证的 Thrift 客户端的连接。
代理委托人	–	Thrift Source 用于向 kerberos KDC 进行身份验证的 kerberos 主体。
代理键选项卡	—-	Thrift 源与代理主体结合使用的密钥表位置，用于向 kerberos KDC 进行身份验证。

名为 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 在启动时运行给定的 Unix 命令，并期望该进程在标准输出时持续生成数据（除非属性 logStdErr 设置为 true，否则会简单地丢弃 stderr）。如果进程因任何原因退出，则源也会退出，并且不会生成进一步的数据。这意味着诸如 cat [命名管道] 或 tail -F [文件] 之类的配置将产生所需的结果，而日期可能不会 - 前两个命令生成数据流，而后者生成单个事件并退出。

必需的属性以粗体显示。

属性名称	违约	描述
渠道	–
类型	–	组件类型名称，需要执行
命令	–	要执行的命令
壳	–	用于运行命令的 shell 调用。例如 /bin/sh -c.仅对于依赖于 shell 功能（如通配符、回溯刻度、管道等）的命令是必需的。
重启暴动	10000	尝试重新启动之前要等待的时间（以毫为单位）
重新启动	假	如果执行的cmd死亡，是否应该重新启动
logStdErr	假	是否应记录命令的 stderr
批处理大小	20	一次读取和发送到通道的最大行数
批处理超时	3000	如果未达到缓冲区大小，则在将数据推送到下游之前等待的时间（以毫秒为单位）
选择器.类型	复制	复制或多路复用
选择器。		取决于选择器类型值
拦截器	–	Space-separated list of interceptors
interceptors.*

Warning

The problem with ExecSource and other asynchronous sources is that the source can not guarantee that if there is a failure to put the event into the Channel the client knows about it. In such cases, the data will be lost. As a for instance, one of the most commonly requested features is the tail -F [file]-like use case where an application writes to a log file on disk and Flume tails the file, sending each line as an event. While this is possible, there’s an obvious problem; what happens if the channel fills up and Flume can’t send an event? Flume has no way of indicating to the application writing the log file that it needs to retain the log or that the event hasn’t been sent, for some reason. If this doesn’t make sense, you need only know this: Your application can never guarantee data has been received when using a unidirectional asynchronous interface such as ExecSource! As an extension of this warning - and to be completely clear - there is absolutely zero guarantee of event delivery when using this source. For stronger reliability guarantees, consider the Spooling Directory Source, Taildir Source or direct integration with Flume via the SDK.

Example for agent named 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

The ‘shell’ config is used to invoke the ‘command’ through a command shell (such as Bash or Powershell). The ‘command’ is passed as an argument to ‘shell’ for execution. This allows the ‘command’ to use features from the shell such as wildcards, back ticks, pipes, loops, conditionals etc. In the absence of the ‘shell’ config, the ‘command’ will be invoked directly. Common values for ‘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 reads messages from a JMS destination such as a queue or topic. Being a JMS application it should work with any JMS provider but has only been tested with ActiveMQ. The JMS source provides configurable batch size, message selector, user/pass, and message to flume event converter. Note that the vendor provided JMS jars should be included in the Flume classpath using plugins.d directory (preferred), –classpath on command line, or via FLUME_CLASSPATH variable in flume-env.sh.

Required properties are in bold.

属性名称	违约	描述
渠道	–
类型	–	组件类型名称，需要为 jms
首创语境工厂	–	Inital Context Factory，例如：org.apache.activemq.jndi.ActiveMQInitialContextFactory
连接工厂	–	连接工厂应显示为 JNDI 名称
providerURL	–	JMS 提供程序 URL
目标名称	–	目标名称
目标类型	–	目标类型（队列或主题）
消息选择器	–	创建使用者时要使用的消息选择器
用户名	–	目标/提供商的用户名
密码文件	–	包含目标/提供程序密码的文件
批处理大小	100	一个批处理中要使用的消息数
转换器类型	违约	用于将消息转换为水槽事件的类。见下文。
转换器。	–	转换器属性。
converter.charset	UTF-8	仅限默认转换器。将 JMS 文本消息转换为字节数组时要使用的字符集。
创建持久订阅	假	是否创建持久订阅。持久订阅只能与目标类型主题一起使用。如果为 true，则必须指定“clientId”和“durableSubscriptionName”。
客户端 Id	–	JMS 客户机标识符在创建后立即在连接上设置。对于持久订阅是必需的。
durableSubscriptionName	–	用于标识持久订阅的名称。对于持久订阅是必需的。

JMS 消息转换器

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

字节消息：

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

文本消息：

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

对象消息：

对象被写出到包装在 ObjectOutputStream 中的 ByteArrayOutputStream 中，并将生成的数组复制到 FlumeEvent 的主体中。

名为 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 源

JMS 客户机实现通常支持通过 JSSE（Java 安全套接字扩展）定义的某些 Java 系统属性来配置 SSL/TLS。为Flume的JVM，JMS Source（或者更准确地说是JMS Source使用的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 支持部分。

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

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

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

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

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

在客户机证书认证的情况下，不需要在 Flume 代理配置文件中为 JMS 源指定用户名/密码文件属性。

请注意：

与其他组件不同，JMS Source 没有组件级配置参数。也没有启用 SSL 标志。SSL 设置由 JNDI/提供程序 URL 设置（最终为 JMS 服务器设置）和信任库/密钥库的存在/不存在来控制。

假脱机目录源

此源允许您通过将要引入的文件放入磁盘上的“假脱机”目录中来引入数据。此源将监视新文件的指定目录，并在新文件出现时分析事件。事件解析逻辑是可插入的。在将给定文件完全读入通道后，默认情况下，通过重命名文件来指示完成，或者可以将其删除或使用跟踪器Dir来跟踪已处理的文件。

与Exec源不同，此源是可靠的，即使Flume重新启动或杀死，也不会错过数据。为了换取这种可靠性，只有不可变的唯一名称文件必须放入后台打印目录中。Flume 试图检测这些问题条件，如果违反这些条件，将大声失败：

如果文件在放入假脱机目录后被写入，Flume会将错误打印到其日志文件并停止处理。
如果以后重用文件名，Flume 会将错误打印到其日志文件中并停止处理。

为避免上述问题，在将文件名移动到假脱机目录时，向日志文件名添加唯一标识符（如时间戳）可能很有用。

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

属性名称	违约	描述
渠道	–
类型	–	组件类型名称，需要为后台打印。
线轴目录	–	从中读取文件的目录。
文件后缀	.完成	要追加到完全摄取的文件的后缀
删除政策	从不	何时删除已完成的文件：从不或立即删除
文件标题	假	是否添加存储绝对路径文件名的标头。
文件标题键	文件	将绝对路径文件名追加到事件标头时使用的标头键。
基名标题	假	是否添加存储文件基名的标头。
基名标题键	基名	将文件的基名追加到事件头时使用的标头键。
包含模式	^.*$	指定要包含的文件的正则表达式。它可以与 ignorePattern 一起使用。如果文件同时匹配 ignorePattern 和 includePattern 正则表达式，则忽略该文件。
忽略模式	^$	Regular expression specifying which files to ignore (skip). It can used together with includePattern. If a file matches both ignorePattern and includePattern regex, the file is ignored.
trackerDir	.flumespool	Directory to store metadata related to processing of files. If this path is not an absolute path, then it is interpreted as relative to the spoolDir.
trackingPolicy	rename	The tracking policy defines how file processing is tracked. It can be “rename” or “tracker_dir”. This parameter is only effective if the deletePolicy is “never”. “rename” - After processing files they get renamed according to the fileSuffix parameter. “tracker_dir” - Files are not renamed but a new empty file is created in the trackerDir. The new tracker file name is derived from the ingested one plus the fileSuffix.
consumeOrder	oldest	In which order files in the spooling directory will be consumed oldest, youngest and random. In case of oldest and youngest, the last modified time of the files will be used to compare the files. In case of a tie, the file with smallest lexicographical order will be consumed first. In case of random any file will be picked randomly. When using oldest and youngest the whole directory will be scanned to pick the oldest/youngest file, which might be slow if there are a large number of files, while using random may cause old files to be consumed very late if new files keep coming in the spooling directory.
投票延迟	500	轮询新文件时使用的延迟（以毫秒为单位）。
递归目录搜索	假	是否监视要读取的新文件的子目录。
最大回退	4000	如果通道已满，则在连续尝试写入通道之间等待的最长时间（以 millis 为单位）。源将从低退避开始，并在每次通道抛出 ChannelException 时以指数方式增加，直至达到此参数指定的值。
批处理大小	100	批量传输到通道的粒度
输入字符集	UTF-8	反序列化程序使用的字符集，用于将输入文件视为文本。
解码错误策略	失败	当我们在输入文件中看到不可解码的字符时该怎么办。失败：引发异常，无法解析文件。替换：将不可解析的字符替换为“替换字符”字符，通常是 Unicode U+FFFD。忽略：删除无法解析的字符序列。
反序列化程序	线	指定用于将文件解析为事件的反序列化程序。默认将每行解析为一个事件。指定的类必须实现 EventDeserializer.Builder。
反序列化程序。		因事件反序列化程序而异。
bufferMaxLines	–	（Obselete）此选项现在被忽略。
bufferMaxLineLength	5000	（已弃用）提交缓冲区中行的最大长度。请改用 deserializer.maxLineLength。
选择器.类型	复制	复制或多路复用
选择器。		取决于选择器类型值
拦截器	–	以空间分隔的拦截器列表
拦截器。

名为 agent-1 的代理的示例：

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

事件反序列化器

以下事件反序列化器随Flume一起发货。

线

此反序列化程序每行文本输入生成一个事件。

属性名称	违约	描述
deserializer.maxLineLength	2048	单个事件中要包含的最大字符数。如果某行超过此长度，则该行将被截断，并且该行上的其余字符将显示在后续事件中。
deserializer.outputCharset	UTF-8	用于对放入通道的事件进行编码的字符集。

阿夫罗

此反序列化程序能够读取 Avro 容器文件，并且该文件中的每个 Avro 记录生成一个事件。每个事件都使用指示所用架构的标头进行批注。事件的主体是二进制 Avro 记录数据，不包括架构或容器文件元素的其余部分。

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

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

BlobDeserializer

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

属性名称	Default	Description
deserializer	–	The FQCN of this class: org.apache.flume.sink.solr.morphline.BlobDeserializer$Builder
deserializer.maxBlobLength	100000000	The maximum number of bytes to read and buffer for a given request

Taildir Source

Note

This source is provided as a preview feature. It does not work on Windows.

Watch the specified files, and tail them in nearly real-time once detected new lines appended to the each files. If the new lines are being written, this source will retry reading them in wait for the completion of the write.

This source is reliable and will not miss data even when the tailing files rotate. It periodically writes the last read position of each files on the given position file in JSON format. If Flume is stopped or down for some reason, it can restart tailing from the position written on the existing position file.

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

文件将按其修改时间的顺序使用。修改时间最早的文件将首先被消耗。

此源不会重命名或删除正在尾随的文件，也不会对正在尾随的文件进行任何修改。目前，此源不支持尾随二进制文件。它逐行读取文本文件。

属性名称	违约	描述
渠道	–
类型	–	组件类型名称需要为 TAILDIR。
文件组	–	以空格分隔的文件组列表。每个文件组指示一组要尾随的文件。
文件组。<文件组名称>	–	文件组的绝对路径。正则表达式（而不是文件系统模式）只能用于文件名。
位置文件	~/.flume/taildir_position.json	JSON格式的文件，用于记录每个尾随文件的inode，绝对路径和最后位置。
headers.<filegroupName>.<headerKey>	–	标头值，它是使用标头键集的标头值。可以为一个文件组指定多个标头。
byteOffsetHeader	假	是否将尾部行的字节偏移量添加到名为“字节偏移集”的标头中。
skiptoEnd	假	在位置文件未写入文件的情况下，是否将位置跳过到 EOF。
空闲超时	120000	关闭非活动文件的时间（毫秒）。如果将已关闭的文件追加新行，则此源将自动将其重新打开。
写PosInterval	3000	将每个文件的最后一个位置写入位置文件的间隔时间（ms）。
批处理大小	100	一次读取和发送到通道的最大行数。使用默认值通常很好。
最大流量计数	长.MAX值	控制从同一文件连续读取的批数。如果源尾随多个文件，并且其中一个文件以快速速率写入，则可能会阻止处理其他文件，因为繁忙的文件将在无限循环中读取。在这种情况下，请降低此值。
回退睡眠增量	1000	在上次尝试未找到任何新数据时，重新尝试轮询新数据之前的时间延迟增量。
最大回退睡眠	5000	当上次尝试未找到任何新数据时，每次重新尝试轮询新数据之间的最大时间延迟。
缓存模式匹配	真	列出目录并应用文件名正则表达式模式对于包含数千个文件的目录可能非常耗时。缓存匹配文件的列表可以提高性能。还将缓存文件的使用顺序。要求文件系统以至少 1 秒的粒度跟踪修改时间。
文件标题	假	是否添加存储绝对路径文件名的标头。
文件标题键	文件	将绝对路径文件名追加到事件标头时使用的标头键。

名为 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

推特 1% 消防水带来源（实验性）

警告

此来源具有高度实验性，可能会在 Flume 的次要版本之间更改。使用风险自负。

实验性来源，通过Streaming API连接到1%的样本Twitter firehose，不断下载推文，将其转换为Avro格式，并将Avro事件发送到下游Flume接收器。需要 Twitter 开发人员帐户的使用者和访问令牌和机密。必需的属性以粗体显示。

属性名称	违约	描述
渠道	–
类型	–	组件类型名称需要为 org.apache.flume.source.twitter.TwitterSource
consumerKey	–	OAuth consumer key
consumerSecret	–	OAuth consumer secret
accessToken	–	OAuth access token
accessTokenSecret	–	OAuth token secret
maxBatchSize	1000	Maximum number of twitter messages to put in a single batch
maxBatchDurationMillis	1000	Maximum number of milliseconds to wait before closing a batch

Example for agent named a1:

a1.sources = r1
a1.channels = c1
a1.sources.r1.type = org.apache.flume.source.twitter.TwitterSource
a1.sources.r1.channels = c1
a1.sources.r1.consumerKey = YOUR_TWITTER_CONSUMER_KEY
a1.sources.r1.consumerSecret = YOUR_TWITTER_CONSUMER_SECRET
a1.sources.r1.accessToken = YOUR_TWITTER_ACCESS_TOKEN
a1.sources.r1.accessTokenSecret = YOUR_TWITTER_ACCESS_TOKEN_SECRET
a1.sources.r1.maxBatchSize = 10
a1.sources.r1.maxBatchDurationMillis = 200

Kafka Source

Kafka Source is an Apache Kafka consumer that reads messages from Kafka topics. If you have multiple Kafka sources running, you can configure them with the same Consumer Group so each will read a unique set of partitions for the topics. This currently supports Kafka server releases 0.10.1.0 or higher. Testing was done up to 2.0.1 that was the highest avilable version at the time of the release.

Property Name	Default	Description
channels	–
type	–	The component type name, needs to be org.apache.flume.source.kafka.KafkaSource
kafka.bootstrap.servers	–	List of brokers in the Kafka cluster used by the source
kafka.consumer.group.id	flume	Unique identified of consumer group. Setting the same id in multiple sources or agents indicates that they are part of the same consumer group
kafka.topics	–	Comma-separated list of topics the kafka consumer will read messages from.
kafka.topics.regex	–	Regex that defines set of topics the source is subscribed on. This property has higher priority than kafka.topics and overrides kafka.topics if exists.
batchSize	1000	Maximum number of messages written to Channel in one batch
batchDurationMillis	1000	Maximum time (in ms) before a batch will be written to Channel The batch will be written whenever the first of size and time will be reached.
backoffSleepIncrement	1000	Initial and incremental wait time that is triggered when a Kafka Topic appears to be empty. Wait period will reduce aggressive pinging of an empty Kafka Topic. One second is ideal for ingestion use cases but a lower value may be required for low latency operations with interceptors.
maxBackoffSleep	5000	Maximum wait time that is triggered when a Kafka Topic appears to be empty. Five seconds is ideal for ingestion use cases but a lower value may be required for low latency operations with interceptors.
useFlumeEventFormat	false	By default events are taken as bytes from the Kafka topic directly into the event body. Set to true to read events as the Flume Avro binary format. Used in conjunction with the same property on the KafkaSink or with the parseAsFlumeEvent property on the Kafka Channel this will preserve any Flume headers sent on the producing side.
setTopicHeader	true	When set to true, stores the topic of the retrieved message into a header, defined by the topicHeader property.
topicHeader	topic	Defines the name of the header in which to store the name of the topic the message was received from, if the setTopicHeader property is set to true. Care should be taken if combining with the Kafka Sink topicHeader property so as to avoid sending the message back to the same topic in a loop.
kafka.consumer.security.protocol	PLAINTEXT	Set to SASL_PLAINTEXT, SASL_SSL or SSL if writing to Kafka using some level of security. See below for additional info on secure setup.
more consumer security props		If using SASL_PLAINTEXT, SASL_SSL or SSL refer to Kafka security for additional properties that need to be set on consumer.
Other Kafka Consumer Properties	–	These properties are used to configure the Kafka Consumer. Any consumer property supported by Kafka can be used. The only requirement is to prepend the property name with the prefix kafka.consumer. For example: kafka.consumer.auto.offset.reset

Note

The Kafka Source overrides two Kafka consumer parameters: auto.commit.enable is set to “false” by the source and every batch is committed. Kafka source guarantees at least once strategy of messages retrieval. The duplicates can be present when the source starts. The Kafka Source also provides defaults for the key.deserializer(org.apache.kafka.common.serialization.StringSerializer) and value.deserializer(org.apache.kafka.common.serialization.ByteArraySerializer). Modification of these parameters is not recommended.

Deprecated Properties

Property Name	Default	Description
topic	–	Use kafka.topics
groupId	flume	Use kafka.consumer.group.id
zookeeperConnect	–	Is no longer supported by kafka consumer client since 0.9.x. Use kafka.bootstrap.servers to establish connection with kafka cluster
migrateZookeeperOffsets	true	When no Kafka stored offset is found, look up the offsets in Zookeeper and commit them to Kafka. This should be true to support seamless Kafka client migration from older versions of Flume. Once migrated this can be set to false, though that should generally not be required. If no Zookeeper offset is found, the Kafka configuration kafka.consumer.auto.offset.reset defines how offsets are handled. Check Kafka documentation for details

Example for topic subscription by comma-separated topic list.

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

Example for topic subscription by regex

tier1.sources.source1.type = org.apache.flume.source.kafka.KafkaSource
tier1.sources.source1.channels = channel1
tier1.sources.source1.kafka.bootstrap.servers = localhost:9092
tier1.sources.source1.kafka.topics.regex = ^topic[0-9]$
# the default kafka.consumer.group.id=flume is used

Security and Kafka Source:

Secure authentication as well as data encryption is supported on the communication channel between Flume and Kafka. For secure authentication SASL/GSSAPI (Kerberos V5) or SSL (even though the parameter is named SSL, the actual protocol is a TLS implementation) can be used from Kafka version 0.9.0.

As of now data encryption is solely provided by SSL/TLS.

Setting kafka.consumer.security.protocol to any of the following value means:

SASL_PLAINTEXT - Kerberos or plaintext authentication with no data encryption
SASL_SSL - Kerberos or plaintext authentication with data encryption
SSL - TLS based encryption with optional authentication.

Warning

There is a performance degradation when SSL is enabled, the magnitude of which depends on the CPU type and the JVM implementation. Reference: Kafka security overview and the jira for tracking this issue: KAFKA-2561

TLS and Kafka Source:

Please read the steps described in Configuring Kafka Clients SSL to learn about additional configuration settings for fine tuning for example any of the following: security provider, cipher suites, enabled protocols, truststore or keystore types.

Example configuration with server side authentication and data encryption.

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>

Specyfing the truststore is optional here, the global truststore can be used instead. For more details about the global SSL setup, see the SSL/TLS support section.

Note: By default the property ssl.endpoint.identification.algorithm is not defined, so hostname verification is not performed. In order to enable hostname verification, set the following properties

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

Once enabled, clients will verify the server’s fully qualified domain name (FQDN) against one of the following two fields:

If client side authentication is also required then additionally the following needs to be added to Flume agent configuration or the global SSL setup can be used (see SSL/TLS support section). Each Flume agent has to have its client certificate which has to be trusted by Kafka brokers either individually or by their signature chain. Common example is to sign each client certificate by a single Root CA which in turn is trusted by Kafka brokers.

# 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>

If keystore and key use different password protection then ssl.key.password property will provide the required additional secret for both consumer keystores:

a1.sources.source1.kafka.consumer.ssl.key.password=<password to access the key>

Kerberos and Kafka Source:

To use Kafka source with a Kafka cluster secured with Kerberos, set the consumer.security.protocol properties noted above for consumer. The Kerberos keytab and principal to be used with Kafka brokers is specified in a JAAS file’s “KafkaClient” section. “Client” section describes the Zookeeper connection if needed. See Kafka doc for information on the JAAS file contents. The location of this JAAS file and optionally the system wide kerberos configuration can be specified via JAVA_OPTS in flume-env.sh:

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"

Example secure configuration using 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 源还可以连接到 Zookeeper 进行偏移迁移，因此“客户端”部分也添加到此示例中。除非需要偏移迁移，或者需要此部分用于其他安全组件，否则不需要执行此操作。另外，请确保 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 的源，它侦听给定的端口，并将每行文本转换为事件。行为类似于 nc -k -l [主机] [端口]。换句话说，它打开指定的端口并侦听数据。期望提供的数据是换行符分隔的文本。每行文本都转换为 Flume 事件，并通过连接的通道发送。

必需的属性以粗体显示。

属性名称	违约	描述
渠道	–
类型	–	组件类型名称，需要为 netcat
捆	–	要绑定到的主机名或 IP 地址
港口	–	要绑定到的端口 #
最大线长	512	每个事件正文的最大行长度（以字节为单位）
每次事件	真	对收到的每个事件进行“确定”响应
选择器.类型	复制	复制或多路复用
选择器。		取决于选择器类型值
拦截器	–	以空间分隔的拦截器列表
拦截器。

名为 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）源，此源侦听给定端口并将每行文本转换为事件并通过连接的通道发送。行为类似于 nc -u -k -l [host] [port]。

必需的属性以粗体显示。

属性名称	违约	描述
渠道	–
类型	–	组件类型名称，需要为 netcatudp
捆	–	要绑定到的主机名或 IP 地址
港口	–	要绑定到的端口 #
remoteAddressHeader	–
选择器.类型	复制	复制或多路复用
选择器。		取决于选择器类型值
拦截器	–	以空间分隔的拦截器列表
拦截器。

名为 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

序列生成器源

一个简单的序列生成器，它使用从 0 开始、递增 1 并在 totalEvents 处停止的计数器连续生成事件。在无法将事件发送到频道时重试。主要用于测试。在重试期间，它保持重试消息的正文与以前相同，以便唯一事件的数量（在目标处进行重复数据消除后）应等于指定的事件总数。必需的属性以粗体显示。

属性名称	违约	描述
渠道	–
类型	–	组件类型名称，需要为 seq
选择器.类型		复制或多路复用
选择器。	复制	取决于选择器类型值
拦截器	–	以空间分隔的拦截器列表
拦截器。
批处理大小	1	每个请求循环尝试处理的事件数。
总计事件	长.MAX值	源发送的唯一事件数。

名为 a1 的代理的示例：

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

系统日志源

读取系统日志数据并生成 Flume 事件。UDP 源将整个消息视为单个事件。TCP 源为每个字符串创建一个新事件，这些字符串由换行符（'n'）分隔。

必需的属性以粗体显示。

系统日志 TCP 源

久经考验的原始系统日志 TCP 源。

属性名称	违约	描述
渠道	–
类型	–	组件类型名称，需要为 syslogtcp
主机	–	要绑定到的主机名或 IP 地址
港口	–	要绑定到的端口 #
事件大小	2500	单个事件行的最大大小（以字节为单位）
保持字段	没有	将其设置为“全部”将在事件正文中保留优先级、时间戳和主机名。还允许包含间隔分隔的字段列表。目前，可以包含以下字段：优先级、版本、时间戳、主机名。值“true”和“false”已被弃用，取而代之的是“all”和“none”。
clientIPHeader	–	如果指定，客户端的 IP 地址将使用此处指定的标头名称存储在每个事件的标头中。这允许侦听器和信道选择器根据客户端的 IP 地址自定义路由逻辑。不要在此处使用标准的 Syslog 标头名称（如 _host_），因为在这种情况下，事件标头将被覆盖。
clientHostnameHeader	–	如果指定，客户端的主机名将使用此处指定的标头名称存储在每个事件的标头中。这允许侦听器和通道选择器根据客户端的主机名自定义路由逻辑。检索主机名可能涉及名称服务反向查找，这可能会影响性能。不要在此处使用标准的 Syslog 标头名称（如 _host_），因为在这种情况下，事件标头将被覆盖。
选择器.类型		复制或多路复用
选择器。	复制	取决于选择器类型值
拦截器	–	以空间分隔的拦截器列表
拦截器。
断续器	假	将此值设置为 true 可启用 SSL 加密。如果启用了 SSL，那么还必须通过组件级参数（见下文）或全局 SSL 参数（请参阅 SSL/TLS 支持部分）指定“密钥库”和“密钥库密码”。
密钥库	–	这是 Java 密钥库文件的路径。如果未在此处指定，则将使用全局密钥库（如果已定义，否则为配置错误）。
密钥库密码	–	Java 密钥库的密码。如果未在此处指定，则将使用全局密钥库密码（如果已定义，否则为配置错误）。
密钥库类型	断续器	Java 密钥库的类型。这可以是“JKS”或“PKCS12”。如果未在此处指定，则将使用全局密钥库类型（如果已定义，否则缺省值为 JKS）。
排除协议	SSLv3	要排除的 SSL/TLS 协议的空格分隔列表。除了指定的协议之外，SSLv3 将始终被排除在外。
包含协议	–	要包含的 SSL/TLS 协议的空格分隔列表。启用的协议将是包含的协议，但没有排除的协议。如果包含的协议为空，则它包括所有受支持的协议。
排除密码套件	–	要排除的密码套件的空格分隔列表。
include-cipher-suites	–	Space-separated list of cipher suites to include. The enabled cipher suites will be the included cipher suites without the excluded cipher suites. If included-cipher-suites is empty, it includes every supported 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

Multiport Syslog TCP Source

This is a newer, faster, multi-port capable version of the Syslog TCP source. Note that the ports configuration setting has replaced port. Multi-port capability means that it can listen on many ports at once in an efficient manner. This source uses the Apache Mina library to do that. Provides support for RFC-3164 and many common RFC-5424 formatted messages. Also provides the capability to configure the character set used on a per-port basis.

Property Name	Default	Description
channels	–
type	–	The component type name, needs to be multiport_syslogtcp
host	–	Host name or IP address to bind to.
ports	–	Space-separated list (one or more) of ports to bind to.
eventSize	2500	Maximum size of a single event line, in bytes.
keepFields	none	Setting this to ‘all’ will preserve the Priority, Timestamp and Hostname in the body of the event. A spaced separated list of fields to include is allowed as well. Currently, the following fields can be included: priority, version, timestamp, hostname. The values ‘true’ and ‘false’ have been deprecated in favor of ‘all’ and ‘none’.
portHeader	–	If specified, the port number 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 incoming port.
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.
charset.default	UTF-8	Default character set used while parsing syslog events into strings.
charset.port.<port>	–	Character set is configurable on a per-port basis.
batchSize	100	Maximum number of events to attempt to process per request loop. Using the default is usually fine.
readBufferSize	1024	Size of the internal Mina read buffer. Provided for performance tuning. Using the default is usually fine.
numProcessors	(auto-detected)	Number of processors available on the system for use while processing messages. Default is to auto-detect # of CPUs using the Java Runtime API. Mina will spawn 2 request-processing threads per detected CPU, which is often reasonable.
selector.type	replicating	replicating, multiplexing, or custom
selector.*	–	Depends on the selector.type value
interceptors	–	Space-separated list of interceptors.
interceptors.*
ssl	false	Set this to true to enable SSL encryption. If SSL is enabled, you must also specify a “keystore” and a “keystore-password”, either through component level parameters (see below) or as global SSL parameters (see SSL/TLS support section).
keystore	–	This is the path to a Java keystore file. If not specified here, then the global keystore will be used (if defined, otherwise configuration error).
keystore-password	–	The password for the Java keystore. If not specified here, then the global keystore password will be used (if defined, otherwise configuration error).
keystore-type	JKS	The type of the Java keystore. This can be “JKS” or “PKCS12”. If not specified here, then the global keystore type will be used (if defined, otherwise the default is JKS).
exclude-protocols	SSLv3	Space-separated list of SSL/TLS protocols to exclude. SSLv3 will always be excluded in addition to the protocols specified.
include-protocols	–	Space-separated list of SSL/TLS protocols to include. The enabled protocols will be the included protocols without the excluded protocols. If included-protocols is empty, it includes every supported protocols.
exclude-cipher-suites	–	Space-separated list of cipher suites to exclude.
include-cipher-suites	–	Space-separated list of cipher suites to include. The enabled cipher suites will be the included cipher suites without the excluded cipher suites. If included-cipher-suites is empty, it includes every supported 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 UDP Source

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.*

例如，名为 a1 的代理的系统日志 UDP 源：

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 POST 和 GET 接受 Flume Events 的源。GET 应仅用于实验。HTTP请求由可插入的“处理程序”转换为flume事件，该处理程序必须实现HTTPSourceHandler接口。此处理程序采用 HttpServletRequest 并返回 flume 事件的列表。从一个 Http 请求处理的所有事件都在一个事务中提交到通道，从而可以提高文件通道等通道的效率。如果处理程序引发异常，则此源将返回 HTTP 状态 400。如果通道已满，或者源无法将事件追加到通道，则源将返回“HTTP 503 - 暂时不可用”状态。

在一个 post 请求中发送的所有事件都被视为一个批处理，并在一个事务中插入到通道中。

该源基于 Jetty 9.4，能够设置其他特定于 Jetty 的参数，这些参数将直接传递到 Jetty 组件。

属性名称	违约	描述
类型		组件类型名称，需要为 http
港口	–	源应绑定到的端口。
捆	0.0.0.0	要侦听的主机名或 IP 地址
处理器	org.apache.flume.source.http.JSONHandler	处理程序类的 FQCN。
处理程序。	–	处理程序的配置参数
选择器.类型	复制	复制或多路复用
选择器。		取决于选择器类型值
拦截器	–	以空间分隔的拦截器列表
拦截器。
断续器	假	将属性设置为 true 以启用 SSL。HTTP Source 不支持 SSLv3。
排除协议	SSLv3	要排除的 SSL/TLS 协议的空格分隔列表。除了指定的协议之外，SSLv3 将始终被排除在外。
包含协议	–	要包含的 SSL/TLS 协议的空格分隔列表。启用的协议将是包含的协议，但没有排除的协议。如果包含的协议为空，则它包括所有受支持的协议。
排除密码套件	–	要排除的密码套件的空格分隔列表。
包含密码套件	–	要包含的密码套件的空格分隔列表。启用的密码套件将是包含的密码套件，但没有排除的密码套件。
密钥库		密钥库的位置，包括密钥库文件名。如果启用了 SSL 但此处未指定密钥库，那么将使用全局密钥库（如果已定义，否则为配置错误）。
密钥库密码		密钥库密码。如果启用了 SSL，但此处未指定密钥库密码，那么将使用全局密钥库密码（如果已定义，否则为配置错误）。
密钥库类型	断续器	密钥库类型。这可以是“JKS”或“PKCS12”。
QueuedThreadPool.*		要在 org.eclipse.jetty.util.thread.QueuedThreadPool 上设置的特定于 Jetty 的设置。注意：仅当至少设置了此类的一个属性时，才会使用 QueuedThreadPool。
HttpConfiguration.*		要在 org.eclipse.jetty.server.HttpConfiguration 上设置的特定于 Jetty 的设置
SslContextFactory.*		要在 org.eclipse.jetty.util.ssl.SslContextFactory 上设置的特定于 Jetty 的设置（仅当 ssl 设置为 true 时才适用）。
服务器连接器。		要在 org.eclipse.jetty.server.ServerConnector 上设置的特定于 Jetty 的设置

已弃用的属性

属性名称	违约	描述
密钥库密码	–	使用密钥库密码。已弃用的值将被新值覆盖。
排除协议	SSLv3	使用排除协议。已弃用的值将被新值覆盖。
使能	假	Use ssl. Deprecated value will be overwritten with the new one.

N.B. Jetty-specific settings are set using the setter-methods on the objects listed above. For full details see the Javadoc for these classes (QueuedThreadPool, HttpConfiguration, SslContextFactory and ServerConnector).

When using Jetty-specific setings, named properites above will take precedence (for example excludeProtocols will take precedence over SslContextFactory.ExcludeProtocols). All properties will be inital lower case.

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 格式表示的事件，并支持 UTF-8、UTF-16 和 UTF-32 字符集。处理程序接受一个事件数组（即使只有一个事件，该事件也必须在数组中发送），并根据请求中指定的编码将它们转换为 Flume 事件。如果未指定编码，则假定为 UTF-8。JSON 处理程序支持 UTF-8、UTF-16 和 UTF-32。事件表示如下。

[{
  "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"
  }]

若要设置字符集，请求必须将内容类型指定为 application/json;charset=UTF-8（根据需要将 UTF-8 替换为 UTF-16 或 UTF-32）。

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

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

BlobHandler

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

属性名称	违约	描述
处理器	–	这个类的FQCN：org.apache.flume.sink.solr.morphline.BlobHandler
handler.maxBlobLength	100000000	给定请求要读取和缓冲的最大字节数

压力源

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

必需的属性以粗体显示。

属性名称	违约	描述
类型	–	组件类型名称需要为 org.apache.flume.source.StressSource
大小	500	每个事件的有效负载大小。单位：字节
maxTotalEvents	-1	要发送的最大事件数
最大成功事件	-1	成功发送的最大事件数
批处理大小	1	一个批次发送的事件数
最大事件每秒	0	设置为大于零的整数时，对源强制实施速率限制器。

名为 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

旧源

旧源允许 Flume 1.x 代理从 Flume 0.9.4 代理接收事件。它接受 Flume 0.9.4 格式的事件，将它们转换为 Flume 1.0 格式，并将它们存储在连接的通道中。0.9.4 事件属性（如时间戳、pri、主机、nanos 等）将转换为 1.x 事件标头属性。旧源支持 Avro 和 Thrift RPC 连接。要在两个 Flume 版本之间使用此桥接器，您需要使用 avroLegacy 或 thriftLegacy 源启动 Flume 1.x 代理。0.9.4 代理应使代理接收器指向 1.x 代理的主机/端口。

注意 Flume

1.x 的可靠性语义与 Flume 0.9.x 的可靠性语义不同。旧源将不支持 Flume 0.9.x 代理的 E2E 或 DFO 模式。唯一受支持的 0.9.x 模式是尽力而为，尽管 1.x 流的可靠性设置在旧源保存到 Flume 1.x 通道后将适用于事件。

必需的属性以粗体显示。

阿夫罗遗产源

属性名称	违约	描述
渠道	–
类型	–	组件类型名称，需要是 org.apache.flume.source.avroLegacy.AvroLegacySource
主机	–	要绑定到的主机名或 IP 地址
港口	–	要侦听的端口 #
选择器.类型		复制或多路复用
选择器。	复制	取决于选择器类型值
拦截器	–	以空间分隔的拦截器列表
拦截器。

名为 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

节俭遗产源

属性名称	违约	描述
渠道	–
类型	–	组件类型名称，需要是 org.apache.flume.source.thriftLegacy.ThriftLegacySource
主机	–	要绑定到的主机名或 IP 地址
港口	–	要侦听的端口 #
选择器.类型		复制或多路复用
选择器。	复制	取决于选择器类型值
拦截器	–	以空间分隔的拦截器列表
拦截器。

名为 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

自定义源

自定义源是你自己的源接口实现。启动 Flume 代理时，自定义源的类及其依赖项必须包含在代理的类路径中。自定义源的类型是其 FQCN。

属性名称	违约	描述
渠道	–
类型	–	组件类型名称，需要是您的 FQCN
选择器.类型		复制或多路复用
选择器。	复制	取决于选择器类型值
拦截器	–	以空间分隔的拦截器列表
拦截器。

名为 a1 的代理的示例：

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

抄写员来源

抄写员是另一种类型的摄取系统。要采用现有的Scribe摄取系统，Flume应该使用基于Thrift的ScribeSource和兼容的传输协议。要部署Scribe，请按照Facebook的指南进行操作。必需的属性以粗体显示。

属性名称	违约	描述
类型	–	组件类型名称，需要是 org.apache.flume.source.scribe.ScribeSource
港口	1499	抄写员应连接的端口
最大读取缓冲区字节数	16384000	节俭默认帧缓冲区大小
工人线程	5	节俭中的处理线数
选择器.类型
选择器。

名为 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

水槽水槽

HDFS 接收器

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

以下是支持的转义序列：

别名	描述
%{主机}	替换名为“host”的事件标头的值。支持任意标头名称。
%t	Unix 时间（以毫秒为单位）
%a	区域设置的简短工作日名称（星期一、星期二等）
%A	区域设置的全工作日名称（星期一、星期二等）
%b	区域设置的短月份名称（1 月、2 月等）
%B	区域设置的长月份名称（一月、二月等）
%c	区域设置的日期和时间（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	区域设置相当于 am 或 pm
%s	自 1970-01-01 00：00：00 UTC 以来的秒数
%S	秒（00..59）
%y	年份的最后两位数字（00..99）
%Y	年份（2010）
%z	+hhmm 数字时区（例如，-0400）
%[本地主机]	替换运行代理的主机的主机名
%[IP]	替换运行代理的主机的 IP 地址
%[FQDN]	替换运行代理的主机的规范主机名

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

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

注意对于

所有与时间相关的转义序列，事件的标头中必须存在具有键“时间戳”的标头（除非 hdfs.useLocalTimeStamp 设置为 true）。自动添加此内容的一种方法是使用时间戳接收器。

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

已弃用的属性

名称默认说明 ============ ========================================================================= hdfs.callTimeout 30000 HDFS 操作允许的毫秒数，如打开、写入、刷新、关闭。如果发生许多 HDFS 超时操作，则应增加此数字。====================== ============ ======================================================================

名为 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 分钟。例如，时间戳为 11：54：34 AM，2012 年 6 月 12 日的事件将导致 hdfs 路径变为 /flume/events/2012-06-12/1150/00。

蜂巢水槽

此接收器将包含分隔文本或 JSON 数据的事件直接流式传输到 Hive 表或分区中。事件是使用 Hive 事务编写的。一旦将一组事件提交到 Hive，Hive 查询就会立即看到这些事件。Flume 将流向的分区可以预先创建，也可以选择在缺少分区时创建它们。来自传入事件数据的字段将映射到 Hive 表中的相应列。

名字	违约	描述
渠道	–
类型	–	组件类型名称，需要为 hive
hive.metastore	–	Hive metastore URI （例如 thrift://a.b.com:9083 ）
hive.database	–	Hive 数据库名称
hive.table	–	配置单元表名称
hive.partition	–	以逗号分隔的分区值列表，用于标识要写入的分区。可能包含转义序列。例如：如果表格按（大洲：字符串，国家：字符串，时间：字符串）分区，则“亚洲，印度，2014-02-26-01-21”将指示大陆=亚洲，国家=印度，时间=2014-02-26-01-21
hive.txnsPerBatchAsk	100	Hive 向 Flume 等流式处理客户端授予一批事务，而不是单个事务。此设置配置每个事务批处理所需的事务数。来自单个批处理中所有事务的数据最终位于单个文件中。Flume 将在批处理中的每个事务中写入最多 batchSize 事件。此设置与 batchSize 结合使用，可以控制每个文件的大小。请注意，Hive 最终会以透明方式将这些文件压缩为更大的文件。
心跳间隔	240	（以秒为单位）发送到 Hive 的连续检测信号之间的间隔，以防止未使用的事务过期。将此值设置为 0 可禁用检测信号。
自动创建分区	真	Flume 将自动创建必要的 Hive 分区以流式传输到
批处理大小	15000	单个 Hive 事务中写入 Hive 的事件数上限
最大打开连接	500	仅允许此数量的打开连接。如果超过此数字，将关闭最近最少使用的连接。
呼叫超时	10000	（以毫秒为单位）Hive和HDFS I /O操作的超时，例如openTxn，write，commit，abort。
序列化程序		序列化程序负责从事件中分析字段，并将其映射到配置单元表中的列。序列化程序的选择取决于事件中数据的格式。支持的序列化程序：分隔和 JSON
圆形单位	分钟	向下舍入值的单位 - 秒、分钟或小时。
圆值	1	向下舍入到此值的最高倍数（在使用 hive.roundUnit 配置的单元中），小于当前时间
时区	当地时间	应用于解析分区中转义序列的时区的名称，例如 America/Los_Angeles。
useLocalTimeStamp	假	使用本地时间（而不是事件标头中的时间戳），同时替换转义序列。

为 Hive 接收器提供了以下序列化程序：

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

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

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

以下是支持的转义序列：

别名	描述
%{主机}	替换名为“host”的事件标头的值。支持任意标头名称。
%t	Unix time in milliseconds
%a	locale’s short weekday name (Mon, Tue, ...)
%A	locale’s full weekday name (Monday, Tuesday, ...)
%b	locale’s short month name (Jan, Feb, ...)
%B	locale’s long month name (January, February, ...)
%c	locale’s date and time (Thu Mar 3 23:05:25 2005)
%d	day of month (01)
%D	date; same as %m/%d/%y
%H	hour (00..23)
%I	hour (01..12)
%j	day of year (001..366)
%k	hour ( 0..23)
%m	month (01..12)
%M	minute (00..59)
%p	locale’s equivalent of am or pm
%s	seconds since 1970-01-01 00:00:00 UTC
%S	second (00..59)
%y	last two digits of year (00..99)
%Y	year (2010)
%z	+hhmm numeric timezone (for example, -0400)

Note

For all of the time related escape sequences, a header with the key “timestamp” must exist among the headers of the event (unless useLocalTimeStamp is set to true). One way to add this automatically is to use the TimestampInterceptor.

Example Hive table :

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

The above configuration will round down the timestamp to the last 10th minute. For example, an event with timestamp header set to 11:54:34 AM, June 12, 2012 and ‘country’ header set to ‘india’ will evaluate to the partition (continent=’asia’,country=’india’,time=‘2012-06-12-11-50’. The serializer is configured to accept tab separated input containing three fields and to skip the second field.

Logger Sink

Logs event at INFO level. Typically useful for testing/debugging purpose. Required properties are in bold. This sink is the only exception which doesn’t require the extra configuration explained in the Logging raw data section.

Property Name	Default	Description
channel	–
type	–	The component type name, needs to be logger
maxBytesToLog	16	Maximum number of bytes of the Event body to log

Example for agent named a1:

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

阿夫罗水槽

该水槽构成了Flume分层收集支持的一半。发送到此接收器的 Flume 事件将转换为 Avro 事件，并发送到配置的主机名/端口对。这些事件按配置的批大小从配置的通道中分批获取。必需的属性以粗体显示。

属性名称	违约	描述
渠道	–
类型	–	组件类型名称，需要为 avro。
主机名	–	要绑定到的主机名或 IP 地址。
港口	–	要侦听的端口 # 。
批大小	100	要一起批处理以进行发送的事件数。
连接超时	20000	允许第一个（握手）请求的时间量（毫秒）。
请求超时	20000	允许第一个请求之后的请求的时间量（毫秒）。
重置连接间隔	没有	重置与下一跃点的连接之前的时间量。这将强制 Avro 接收器重新连接到下一跃点。这将允许在添加新闻主机时将接收器连接到硬件负载平衡器后面的主机，而无需重新启动代理。
压缩型	没有	这可以是“无”或“放气”。压缩类型必须与匹配的 AvroSource 的压缩类型匹配
压缩级别	6	要压缩事件的压缩级别。0 = 无压缩，1-9 表示压缩。数字越大，压缩率越高
断续器	假	设置为 true 可为此 AvroSink 启用 SSL。配置 SSL 时，您可以选择设置“信任库”、“信任库密码”、“信任库类型”，并指定是否“信任所有证书”。
信任所有证书	假	如果此值设置为 true，则不会检查远程服务器（Avro 源）的 SSL 服务器证书。这不应该在生产中使用，因为它使攻击者更容易执行中间人攻击并在加密连接上“侦听”。
信任库	–	定制 Java 信任库文件的路径。Flume 使用此文件中的证书颁发机构信息来确定是否应信任远程 Avro 源的 SSL 身份验证凭据。如果未指定，则将使用全局密钥库。如果未指定全局密钥库，那么将使用缺省的 Java JSSE 证书颁发机构文件（通常是 Oracle JRE 中的“jssecacerts”或“cacerts”）。
信任库密码	–	信任库的密码。如果未指定，则将使用全局密钥库密码（如果已定义）。
信任库类型	断续器	Java 信任库的类型。这可以是“JKS”或其他受支持的 Java 信任库类型。如果未指定，则将使用全局密钥库类型（如果已定义，否则 defautl 为 JKS）。
排除协议	SSLv3	要排除的 SSL/TLS 协议的空格分隔列表。除了指定的协议之外，SSLv3 将始终被排除在外。
最大IoWorkers	2 * 机器中可用处理器的数量	I/O 工作线程的最大数目。这是在NettyAvroRpcClient NioClientSocketChannelFactory上配置的。

名为 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

节俭水槽

该水槽构成了Flume分层收集支持的一半。发送到此接收器的 Flume 事件将转换为 Thrift 事件，并发送到配置的主机名/端口对。这些事件按配置的批大小从配置的通道中分批获取。

可以通过启用 Kerberos 身份验证，将 Thrift 接收器配置为在安全模式下启动。要与以安全模式启动的节俭源进行通信，节俭接收器也应在安全模式下运行。客户端主体和客户端密钥表是 Thrift 接收器用于向 kerberos KDC 进行身份验证的属性。服务器主体表示此接收器配置为在安全模式下连接到的 Thrift 源的主体。必需的属性以粗体显示。

Property Name	Default	Description
channel	–
type	–	The component type name, needs to be thrift.
主机名	–	要绑定到的主机名或 IP 地址。
港口	–	要侦听的端口 # 。
批大小	100	要一起批处理以进行发送的事件数。
连接超时	20000	允许第一个（握手）请求的时间量（毫秒）。
请求超时	20000	允许第一个请求之后的请求的时间量（毫秒）。
连接重置间隔	没有	重置与下一跃点的连接之前的时间量。这将强制 Thrift Sink 重新连接到下一跃点。这将允许在添加新闻主机时将接收器连接到硬件负载平衡器后面的主机，而无需重新启动代理。
断续器	假	设置为 true 可为此 ThriftSink 启用 SSL。配置 SSL 时，您可以选择设置“信任库”、“信任库密码”和“信任库类型”
信任库	–	定制 Java 信任库文件的路径。Flume 使用此文件中的证书颁发机构信息来确定是否应信任远程 Thrift 源的 SSL 身份验证凭据。如果未指定，则将使用全局密钥库。如果未指定全局密钥库，那么将使用缺省的 Java JSSE 证书颁发机构文件（通常是 Oracle JRE 中的“jssecacerts”或“cacerts”）。
信任库密码	–	信任库的密码。如果未指定，则将使用全局密钥库密码（如果已定义）。
信任库类型	断续器	Java 信任库的类型。这可以是“JKS”或其他受支持的 Java 信任库类型。如果未指定，则将使用全局密钥库类型（如果已定义，否则 defautl 为 JKS）。
排除协议	SSLv3	要排除的 SSL/TLS 协议的空格分隔列表
克贝罗斯	假	设置为 true 可启用 kerberos 身份验证。在 kerberos 模式下，客户端主体、客户端密钥表和服务器主体是成功进行身份验证并与启用了 Kerberos 的 Thrift 源进行通信所必需的。
客户端-委托人	—-	Thrift Sink 用于向 kerberos KDC 进行身份验证的 kerberos 主体。
客户端密钥表	—-	Thrift 接收器与客户端主体结合使用的密钥表位置，用于向 Kerberos KDC 进行身份验证。
服务器主体	–	Thrift Sink 配置为连接到的 Thrift 源的 kerberos 主体。

名为 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 水槽

IRC 接收器从连接的通道获取消息，并将这些消息中继到配置的 IRC 目标。必需的属性以粗体显示。

属性名称	违约	描述
渠道	–
类型	–	组件类型名称，需要为 irc
主机名	–	要连接到的主机名或 IP 地址
港口	6667	要连接的远程主机的端口号
缺口	–	昵称
用户	–	用户名
密码	–	用户密码
禅	–	渠道
名字
拆分线	–	（布尔值）
拆分字符	n	行分隔符（如果要在配置文件中输入默认值，则需要对反斜杠进行转义，如下所示：“\n”）

名为 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.directory	–	将存储文件的目录
sink.pathManager	违约	要使用的 PathManager 实现。
sink.pathManager.extension	–	文件扩展名（如果使用默认路径管理器）。
sink.pathManager.prefix	–	要添加到文件名开头的字符串（如果使用默认 PathManager）
sink.rollInterval	30	每 30 秒滚动一次文件。指定 0 将禁用滚动，并导致所有事件写入单个文件。
sink.serializer	发短信	其他可能的选项包括avro_event或 EventSerializer.Builder 接口实现的 FQCN。
sink.batchSize	100

名为 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

空接收器

放弃从通道接收的所有事件。必需的属性以粗体显示。

属性名称	违约	描述
渠道	–
类型	–	组件类型名称需要为空。
批处理大小	100

名为 a1 的代理的示例：

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

HBaseSinks

HBaseSink

此接收器将数据写入 HBase。Hbase 配置是从类路径中遇到的第一个 hbase 站点获取.xml。实现由配置指定的 HbaseEventSerializer 的类用于将事件转换为 HBase 放置和/或增量。然后将这些看跌期权和增量写入 HBase。此接收器提供与 HBase 相同的一致性保证，HBase 当前是按行的原子性。如果 Hbase 无法写入某些事件，接收器将重播该事务中的所有事件。

HBaseSink支持写入数据以保护HBase。若要写入以保护 HBase，代理运行的用户必须对接收器配置为写入的表具有写入权限。可以在配置中指定用于对 KDC 进行身份验证的主体和密钥选项卡。Flume 代理的类路径中的 hbase-site.xml必须将身份验证设置为 kerberos（有关如何执行此操作的详细信息，请参阅 HBase 文档）。

为方便起见，Flume 提供了两个序列化程序。SimpleHbaseEventSerializer （org.apache.flume.sink.hbase.SimpleHbaseEventSerializer）按原样将事件正文写入 HBase，并选择性地递增 Hbase 中的列。这主要是一个示例实现。RegexHbaseEventSerializer （org.apache.flume.sink.hbase.RegexHbaseEventSerializer）根据给定的正则表达式分解事件正文，并将每个部分写入不同的列。

类型是FQCN：org.apache.flume.sink.hbase.HBaseSink。

必需的属性以粗体显示。

属性名称	违约	描述
渠道	–
类型	–	组件类型名称，需要为 hbase
桌子	–	Hbase 中要写入的表的名称。
专栏家族	–	Hbase 中要写入的列系列。
动物园管理员法定人数	–	仲裁规范。这是 hbase-site 中属性 hbase.zookeeper.quorum 的值.xml
znodeParent	/hbase	-ROOT- 区域的 znode 的基本路径。zookeeper.znode.parent 在 hbase-site 中的价值.xml
批处理大小	100	每个 txn 要写入的事件数。
合并增量	假	接收器是否应将多个增量合并到每个批次的一个单元。如果有限数量的单元格有多个增量，这可能会提供更好的性能。
序列化程序	org.apache.flume.sink.hbase.SimpleHbaseEventSerializer	默认增量列 = “iCol”，有效负载列 = “pCol”。
序列化程序。	–	要传递给序列化程序的属性。
kerberosPrincipal	–	用于访问安全 HBase 的 Kerberos 用户主体
kerberosKeytab	–	用于访问安全 HBase 的 Kerberos 密钥选项卡

名为 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

HBase2Sink

HBase2Sink 相当于 HBase 版本 2 的 HBaseSink。提供的功能和配置参数与 HBaseSink 相同（接收器类型中的 hbase2 标记和包/类名称除外）。

类型是FQCN：org.apache.flume.sink.hbase2.HBase2Sink。

必需的属性以粗体显示。

属性名称	违约	描述
渠道	–
类型	–	组件类型名称，需要为 hbase2
桌子	–	HBase 中要写入的表的名称。
专栏家族	–	HBase 中要写入的列系列。
动物园管理员法定人数	–	仲裁规范。这是 hbase-site 中属性 hbase.zookeeper.quorum 的值.xml
znodeParent	/hbase	-ROOT- 区域的 znode 的基本路径。zookeeper.znode.parent 在 hbase-site 中的价值.xml
批处理大小	100	每个 txn 要写入的事件数。
合并增量	假	接收器是否应将多个增量合并到每个批次的一个单元。如果有限数量的单元格有多个增量，这可能会提供更好的性能。
序列化程序	org.apache.flume.sink.hbase2.SimpleHBase2EventSerializer	默认增量列 = “iCol”，有效负载列 = “pCol”。
序列化程序。	–	要传递给序列化程序的属性。
kerberosPrincipal	–	用于访问安全 HBase 的 Kerberos 用户主体
kerberosKeytab	–	用于访问安全 HBase 的 Kerberos 密钥选项卡

名为 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

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

属性名称	违约	描述
渠道	–
类型	–	组件类型名称，需要为异步基础
桌子	–	Hbase 中要写入的表的名称。
动物园管理员法定人数	–	仲裁规范。这是 hbase-site 中属性 hbase.zookeeper.quorum 的值.xml
znodeParent	/hbase	-ROOT- 区域的 znode 的基本路径。zookeeper.znode.parent 在 hbase-site 中的价值.xml
专栏家族	–	Hbase 中要写入的列系列。
批处理大小	100	每个 txn 要写入的事件数。
合并增量	假	接收器是否应将多个增量合并到每个批次的一个单元。如果有限数量的单元格有多个增量，这可能会提供更好的性能。
超时	60000	接收器等待来自 hbase 的 acks 的时间长度（以毫秒为单位）用于事务中的所有事件。
序列化程序	org.apache.flume.sink.hbase.SimpleAsyncHbaseEventSerializer
序列化程序。	–	要传递给序列化程序的属性。
异步。	–	要传递给异步数据库库的属性。这些属性优先于旧的 zookeeperQuorum 和 znodeParent 值。您可以在 AsyncHBase 的文档页面上找到可用属性的列表。

请注意，此接收器采用配置中的 Zookeeper 仲裁和父 znode 信息。Zookeeper Quorum 和父节点配置可以在 flume 配置文件中指定。或者，这些配置值取自类路径中的第一个 hbase 站点.xml文件。

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

名为 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

该接收器从Flume事件中提取数据，对其进行转换，并将其近乎实时地加载到Apache Solr服务器中，这些服务器又为最终用户或搜索应用程序提供查询。

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

ETL 功能可使用形态线配置文件进行自定义，该文件定义了一系列转换命令，这些命令将事件记录从一个命令传送到另一个命令。

Morphlines可以看作是Unix管道的演变，其中数据模型被推广为与通用记录流一起工作，包括任意二进制有效负载。形态线命令有点像 Flume Interceptor。Morphlines可以嵌入到Hadoop组件中，例如Flume。

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

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

此接收器将 Flume 事件的正文填充到形态线记录的 _attachment_body 字段中，并将 Flume 事件的标题复制到同名的记录字段中。然后，这些命令可以对此数据执行操作。

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

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

类型是FQCN：org.apache.flume.sink.solr.morphline.MorphlineSolrSink

必需的属性以粗体显示。

属性名称	违约	描述
渠道	–
类型	–	组件类型名称需要为 org.apache.flume.sink.solr.morphline.MorphlineSolrSink
形态线文件	–	本地文件系统上到形态线配置文件的相对路径或绝对路径。示例：/etc/flume-ng/conf/morphline.conf
形态线Id	零	用于标识形态线（如果形态线配置文件中有多个形态线）的可选名称
批处理大小	1000	每个水槽事务要执行的最大事件数。
batchDurationMillis	1000	每个水槽事务的最大持续时间（毫秒）。事务在此持续时间之后或超过 batchSize 时提交，以先到者为准。
处理程序类	org.apache.flume.sink.solr.morphline.MorphlineHandlerImpl	实现 org.apache.flume.sink.solr.morphline.MorphlineHandler 的类的 FQCN
是生产模式	假	应为任务关键型大规模在线生产系统启用此标志，这些系统需要在发生不可恢复的异常时在不停机的情况下取得进展。解析器输入数据损坏或格式不正确、解析器错误以及与未知 Solr 架构字段相关的错误会产生不可恢复的异常。
可恢复异常类	org.apache.solr.client.solrj.SolrServerException	以逗号分隔的可恢复异常列表，这些异常往往是暂时性的，在这种情况下，可以重试相应的任务。示例包括网络连接错误、超时等。当生产模式标志设置为 true 时，使用此参数配置的可恢复异常将不会被忽略，因此将导致重试。
isIgnoring可恢复的异常	假	如果不可恢复的异常意外地被错误地分类为可恢复，则应启用此标志。这使接收器能够取得进展，并避免永远重试事件。

名为 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

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

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

事件将每天写入新索引。该名称将为<indexName>-yyyy-MM-dd，其中<indexName>是 indexName 参数。接收器将在 UTC 午夜开始写入新索引。

默认情况下，事件由 ElasticSearchLogStashEventSerializer 序列化以进行 elasticsearch。可以使用序列化程序参数覆盖此行为。此参数接受 org.apache.flume.sink.elasticsearch.ElasticSearchEventSerializer 或 org.apache.flume.sink.elasticsearch.ElasticSearchIndexRequestBuilderFactory 的实现。实现ElasticSearchEventSerializer已被弃用，取而代之的是功能更强大的ElasticSearchIndexRequestBuilderFactory。

类型是FQCN：org.apache.flume.sink.elasticsearch.ElasticSearchSink。

必需的属性以粗体显示。

属性名称	违约	描述
渠道	–
类型	–	组件类型名称需要为 org.apache.flume.sink.elasticsearch.ElasticSearchSink
主机名	–	以逗号分隔的主机名：端口列表，如果端口不存在，将使用默认端口“9300”
索引名称	水槽	日期将追加到的索引的名称。示例 'flume' -> 'flume-yyyy-MM-dd' 支持任意标头替换，例如。%{标头} 替换为命名事件标头的值
索引类型	原木	索引文档的类型，默认为“log”，支持任意标头替换，例如。%{标头} 替换为命名事件标头的值
集群名称	弹性搜索	要连接到的弹性搜索集群的名称
批处理大小	100	每个 txn 要写入的事件数。
ttl	–	TTL以天为单位，设置时会导致过期的文档被自动删除，如果不设置文档将永远不会自动删除。TTL仅以早期形式的整数接受，例如a1.sinks.k1.ttl = 5，并且还具有限定符ms（毫秒），s（秒），m（分钟），h（小时），d（天）和w（周）。示例 a1.sinks.k1.ttl = 5d 会将 TTL 设置为 5 天。有关详细信息，请遵循 http://www.elasticsearch.org/guide/reference/mapping/ttl-field/。
序列化程序	org.apache.flume.sink.elasticsearch.ElasticSearchLogStashEventSerializer	要使用的 ElasticSearchIndexRequestBuilderFactory 或 ElasticSearchEventSerializer。任何一个类的实现都是可以接受的，但ElasticSearchIndexRequestBuilderFactory是首选。
序列化程序。	–	要传递给序列化程序的属性。

注意

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

名为 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

风筝数据集接收器

将事件写入风筝数据集的实验性接收器。此接收器将反序列化每个传入事件的正文，并将结果记录存储在风筝数据集中。它通过按 URI 加载数据集来确定目标数据集。

唯一受支持的序列化是 avro，并且必须在事件标头中传递记录架构，使用带有 JSON 架构表示形式的 flume.avro.schema.literal 或带有可以找到架构的 URL 的 flume.avro.schema.url （hdfs：/...支持 URI）。这与Log4jAppender flume客户端和假脱机目录源的Avro deserializer使用deserializer.schemaType = LITERAL兼容。

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

属性名称	违约	描述
渠道	–
类型	–	必须是 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	每批要处理的记录数
风筝.rollInterval	30	释放数据文件之前的最长等待时间（秒）
kite.flushable.commitOnBatch	真	如果为 true，则将提交 Flume 事务，并在每批 kite.batchSize 记录上刷新编写器。此设置仅适用于可刷新数据集。如果为 true，则包含已提交数据的临时文件可能会保留在数据集目录中。这些文件需要手动恢复，以便数据集读取器可以看到数据。
kite.syncable.syncOnBatch	真	控制接收器在提交事务时是否也将同步数据。此设置仅适用于可同步的数据集。同步 gaurente，数据将写入远程系统上的稳定存储，同时仅刷新数据已离开 Flume 客户端缓冲区的 gaurente。当 kite.flushable.commitOnBatch 属性设置为 false 时，此属性也必须设置为 false。
kite.entityParser	阿夫罗	将Flume Events转换为Kite实体的解析器。有效值是 avro 和 EntityParser.Builder 接口实现的完全限定类名。
风筝.故障政策	重试	处理不可恢复的错误（如事件标头中缺少架构）的策略。默认值“重试”将使当前批处理失败，然后重试与旧行为匹配的重试。其他有效值是 save，这会将原始 Event 写入 kite.error.dataset.uri 数据集，以及 FailurePolicy.Builder 接口实现的完全限定类名。
kite.error.dataset.uri	–	当 kite.failurePolicy 设置为 save 时，将保存失败事件的数据集的 URI。当 kite.failurePolicy 设置为 save 时是必需的。
auth.kerberosPrincipal	–	Kerberos 用户主体，用于对 HDFS 进行安全身份验证
auth.kerberosKeytab	–	主体的 Kerberos 密钥表位置（本地 FS）
auth.proxyUser	–	HDFS 操作的有效用户（如果与 kerberos 主体不同）

卡夫卡水槽

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

这当前支持 Kafka 服务器版本 0.10.1.0 或更高版本。测试是在2.0.1之前完成的，这是发布时最高的版本。

必需的属性以粗体标记。

属性名称	违约	描述
类型	–	必须设置为 org.apache.flume.sink.kafka.KafkaSink
kafka.bootstrap.servers	–	Kafka-Sink 将连接到的代理列表，以获取主题分区列表这可以是代理的部分列表，但我们建议 HA 至少两个。格式为逗号分隔的主机名列表：端口
kafka.topic	默认水槽主题	卡夫卡中消息将发布到的主题。如果配置了此参数，则消息将发布到本主题。如果事件标头包含“主题”字段，则事件将发布到该主题，并覆盖此处配置的主题。支持任意标头替换，例如。%{header} 将替换为名为“header”的事件标头的值。（如果使用替换，建议将 Kafka 代理的“auto.create.topics.enable”属性设置为 true。
flumeBatchSize	100	一个批处理中要处理的消息数。较大的批次可提高吞吐量，同时增加延迟。
kafka.producer.acks	1	在认为消息成功写入之前，必须确认多少个副本。接受的值为 0（从不等待确认）、1（仅等待领导）、-1（等待所有副本）将此值设置为 -1 以避免在某些领导失败的情况下丢失数据。
useFlumeEventFormat	假	默认情况下，事件直接从事件正文作为字节放入 Kafka 主题。设置为 true 可将事件存储为 Flume Avro 二进制格式。与 KafkaSource 上的相同属性或 Kafka 通道上的 parseAsFlumeEvent 属性结合使用，这将保留生产方的任何 Flume 标头。
默认分区 Id	–	指定此通道中要发送到的所有事件的 Kafka 分区 ID（整数），除非被 partitionIdHeader 覆盖。默认情况下，如果未设置此属性，则事件将由 Kafka Producer 的分区程序分发 - 包括按键（如果已指定）（或由 kafka.partitioner 指定的分区程序.class）。
partitionIdHeader	–	设置后，接收器将从事件标头中获取使用此属性的值命名的字段的值，并将消息发送到主题的指定分区。如果该值表示无效分区，则将引发 EventDeliveryException。如果标头值存在，则此设置将覆盖默认分区 Id。
allowTopicOverride	真	设置后，接收器将允许将消息生成到由 topicHeader 属性（如果提供）指定的主题中。
主题标题	主题	当与 allowTopicOverride 一起设置时，将生成一条消息，该消息将转换为使用此属性的值命名的标头的值。与 Kafka Source 主题Header 属性结合使用时应格外小心，以避免创建环回。
kafka.producer.security.protocol	明文	设置为 SASL_PLAINTEXT、SASL_SSL 或 SSL（如果使用某种安全级别写入 Kafka）。有关安全设置的其他信息，请参阅下文。
更多生产者安全道具		如果使用SASL_PLAINTEXT，SASL_SSL或 SSL 请参阅 Kafka 安全性，了解需要在生产者上设置的其他属性。
其他卡夫卡生产商属性	–	这些属性用于配置 Kafka Producer。可以使用 Kafka 支持的任何生产者属性。唯一的要求是在属性名称前面加上前缀 kafka.producer。例如：kafka.producer.linger.ms

注意

Kafka 接收器使用 FlumeEvent 标头中的主题和关键属性将事件发送到 Kafka。如果标头中存在主题，则事件将发送到该特定主题，并覆盖为接收器配置的主题。如果标头中存在键，则 Kafka 将使用该键在主题分区之间对数据进行分区。具有相同键的事件将被发送到同一分区。如果该键为 null，则事件将发送到随机分区。

Kafka 接收器还为 key.serializer（org.apache.kafka.common.serialization.StringSerializer）和 value.serializer（org.apache.kafka.common.serialization.ByteArraySerializer）提供了默认值。不建议修改这些参数。

已弃用的属性

属性名称	违约	描述
经纪人列表	–	Use kafka.bootstrap.servers
主题	默认水槽主题	使用 kafka.topic
批处理大小	100	Use kafka.flumeBatchSize
必需的堆栈	1	使用 kafka.producer.acks

下面给出了 Kafka 接收器的示例配置。以前缀 kafka.producer 开头的属性 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

安全和卡夫卡水槽：

Flume和Kafka之间的通信通道支持安全身份验证和数据加密。对于安全身份验证，可以从 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 的加密，具有可选身份验证。

警告

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

TLS 和 Kafka Sink：

请阅读配置 Kafka 客户端 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 = SSL
# 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>

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

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

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

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

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

# 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：

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

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 源或 Kafka 通道不同，除非其他连接组件需要“客户端”部分，否则不需要“客户端”部分。另外，请确保 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 接收器

此接收器的行为是，它将从通道中获取事件，并使用 HTTP POST 请求将这些事件发送到远程服务。事件内容作为 POST 正文发送。

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

如果状态代码不可读，则服务器返回的任何格式错误的 HTTP 响应都将导致退避信号，并且不会从通道中消耗事件。

必需的属性以粗体显示。

属性名称	违约	描述
渠道	–
类型	–	组件类型名称，需要为 http。
端点	–	要 POST 到的完全限定的 URL 终结点
连接超时	5000	套接字连接超时（以毫秒为单位）
请求超时	5000	最大请求处理时间（以毫秒为单位）
contentTypeHeader	文本/纯文本	HTTP 内容类型标头
接受标题	文本/纯文本	HTTP 接受标头值
默认回退	真	是否在接收所有 HTTP 状态代码时默认退出
默认回滚	真	是否在接收所有 HTTP 状态代码时默认回滚
defaultIncrementMetrics	假	是否在接收所有 HTTP 状态代码时默认递增指标
退避。法典	–	为单个（即 200）代码或组（即 2XX）代码配置特定的回退
反转。法典	–	为单个（即 200）代码或组（即 2XX）代码配置特定的回滚
incrementMetrics.CODE	–	为单个（即 200）代码或组（即 2XX）代码配置特定指标增量

请注意，最具体的 HTTP 状态代码匹配用于回退、回滚和增量度量配置选项。如果 2XX 和 200 状态代码都有配置值，则 200 个 HTTP 代码将使用 200 值，而 201-299 范围内的所有其他 HTTP 代码都将使用 2XX 值。

任何空事件或 null 事件都将被使用，而无需向 HTTP 终结点发出任何请求。

名为 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

自定义水槽

自定义接收器是你自己的接收器接口实现。启动 Flume 代理时，自定义接收器的类及其依赖项必须包含在代理的类路径中。自定义接收器的类型是其 FQCN。必需的属性以粗体显示。

属性名称	违约	描述
渠道	–
类型	–	组件类型名称，需要是您的 FQCN

名为 a1 的代理的示例：

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

水槽通道

通道是在代理上暂存事件的存储库。源添加事件，接收器将其删除。

内存通道

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

属性名称	违约	描述
类型	–	组件类型名称，需要内存
能力	100	通道中存储的最大事件数
交易能力	100	通道将从源获取或提供给每个事务的接收器的最大事件数
保持活动状态	3	添加或删除事件的超时（以秒为单位）
字节容量缓冲区	20	定义字节容量与通道中所有事件的估计总大小之间的缓冲区百分比，以考虑标头中的数据。见下文。
字节容量	查看说明	允许的最大内存总字节数作为此通道中所有事件的总和。该实现仅计算事件正文，这也是提供字节容量缓冲区百分比配置参数的原因。默认值为计算值等于 JVM 可用最大内存的 80%（即命令行上传递的 -Xmx 值的 80%）。请注意，如果单个 JVM 上有多个内存通道，并且它们碰巧包含相同的物理事件（即，如果您使用的是来自单个源的复制通道选择器），则出于通道字节容量的目的，这些事件大小可能会被重复计算。将此值设置为 0 将导致此值回退到大约 200 GB 的硬内部限制。

名为 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 频道

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

属性名称	违约	描述
类型	–	组件类型名称，需要为 jdbc
数据库类型	德比	数据库供应商，需要是德比。
驱动程序.class	org.apache.derby.jdbc.EmbeddedDriver	供应商的 JDBC 驱动程序的类
driver.url	（从其他属性构造）	JDBC 连接 URL
db.username	“sa”	数据库连接的用户标识
db.password	–	数据库连接的密码
连接.属性.文件	–	JDBC 连接属性文件路径
create.schema	真	如果为 true，则创建 db 架构（如果不存在）
创建索引	真	创建索引以加快查找速度
create.foreignkey	真
事务.隔离	“READ_COMMITTED”	数据库会话READ_UNCOMMITTED、READ_COMMITTED、可序列化REPEATABLE_READ的隔离级别
最大连接数	10	允许与 db 建立的最大连接数
最大容量	0（无限制）	频道中的最大事件数
系统。		数据库供应商特定属性
sysprop.user.home		存储嵌入式 Derby 数据库的主路径

名为 a1 的代理的示例：

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

卡夫卡海峡

事件存储在 Kafka 集群中（必须单独安装）。Kafka 提供高可用性和复制，因此，如果代理或 kafka 代理崩溃，事件将立即可供其他接收器使用

Kafka 通道可用于多种方案：

借助 Flume 源和汇 - 它为事件提供了可靠且高度可用的通道
使用Flume源和拦截器，但没有接收器 - 它允许将Flume事件写入Kafka主题，以供其他应用程序使用
使用Flume接收器，但没有源 - 它是一种低延迟，容错的方式，将事件从Kafka发送到Flume接收器，如HDFS，HBase或Solr

这当前支持 Kafka 服务器版本 0.10.1.0 或更高版本。测试是在2.0.1之前完成的，这是发布时最高的版本。

配置参数的组织结构如下：

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

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

必需的属性以粗体显示。

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

已弃用的属性

属性名称	违约	描述
经纪人列表	–	通道使用的 Kafka 集群中的代理列表这可以是部分代理列表，但我们建议 HA 至少使用两个。格式为逗号分隔的主机名列表：端口
主题	水槽通道	使用 kafka.topic
组 Id	水槽	使用 kafka.consumer.group.id
读取“最严重偏移”	假	Use kafka.consumer.auto.offset.reset
迁移守护者偏移	真	当找不到 Kafka 存储的偏移量时，在 Zookeeper 中查找偏移量并将其提交到 Kafka。这应该是正确的，以支持从旧版本的Flume无缝的Kafka客户端迁移。迁移后，可以将其设置为 false，尽管通常不需要这样做。如果未找到 Zookeeper 偏移量，则 kafka.consumer.auto.offset.reset 配置将定义如何处理偏移量。

注意

由于通道的负载平衡方式，代理首次启动时可能会出现重复事件

名为 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

安全和卡夫卡频道：

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

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

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

Warning

TLS and Kafka Channel:

Example configuration with server side authentication and data encryption.

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>

Specyfing the truststore is optional here, the global truststore can be used instead. For more details about the global SSL setup, see the SSL/TLS support section.

Note: By default the property ssl.endpoint.identification.algorithm is not defined, so hostname verification is not performed. In order to enable hostname verification, set the following properties

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

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

# 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 Channel：

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

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>

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";
};

文件通道

必需的属性以粗体显示。

属性名称默认值	描述
类型	–	组件类型名称，需要为文件。
检查点目录	~/.flume/file-channel/checkpoint	将存储检查点文件的目录
使用双重检查点	假	备份检查点。如果此值设置为 true，则必须将 backupCheckpointDir 设置为
backupCheckpointDir	–	将检查点备份到的目录。此目录不得与数据目录或检查点目录相同
数据目录	~/.flume/file-channel/data	用于存储日志文件的以逗号分隔的目录列表。在单独的磁盘上使用多个目录可以提高文件通道性能
交易能力	10000	通道支持的最大事务大小
检查点间隔	30000	检查点之间的时间量（以毫为单位）
最大文件大小	2146435071	单个日志文件的最大大小（以字节为单位）
最小要求空间	524288000	所需的最小可用空间（以字节为单位）。为避免数据损坏，当可用空间低于此值时，文件通道将停止接受/放置请求
能力	1000000	通道的最大容量
保持活动状态	3	等待看跌操作的时间（以秒为单位）
use-log-replay-v1	假	专家：使用旧的重放逻辑
使用快速重播	假	专家：不使用队列重播
检查点关闭	真	控制在通道关闭时是否创建检查点。在 close 上创建检查点可避免重播，从而加快文件通道的后续启动速度。
加密.活动密钥	–	用于加密新数据的密钥名称
encryption.cipherProvider	–	密码提供程序类型，支持的类型：AESCTRNOPADDING
encryption.keyProvider	–	密钥提供程序类型，支持的类型：JCEKSFILE
encryption.keyProvider.keyStoreFile	–	密钥库文件的路径
encrpytion.keyProvider.keyStorePasswordFile	–	密钥库密码文件的路径
encryption.keyProvider.keys	–	所有键的列表（例如活动键设置的历史记录）
encyption.keyProvider.keys.*.passwordFile	–	可选密钥密码文件的路径

注意：

默认情况下，文件通道使用如上所述的用户主目录中的检查点和数据目录的路径。因此，如果代理中有多个文件通道实例处于活动状态，则只有一个实例能够锁定目录并导致其他通道初始化失败。因此，有必要提供所有已配置通道的显式路径，最好是在不同的磁盘上。此外，由于文件通道将在每次提交后同步到磁盘，因此可能需要将其与将事件分组在一起的接收器/源耦合，以便在多个磁盘不可用于检查点和数据目录的情况下提供良好的性能。

名为 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

假设您已经将 key-0 过期，并且应该使用 key-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

溢出内存通道

事件存储在内存中队列和磁盘上。内存中队列用作主存储，磁盘用作溢出。磁盘存储使用嵌入式文件通道进行管理。当内存中队列已满时，其他传入事件将存储在文件通道中。此通道非常适合在正常操作期间需要高吞吐量内存通道的流，但同时需要更大容量的文件通道，以便更好地容忍间歇性接收器侧中断或消耗率下降。在这种异常情况下，吞吐量将大约降低到文件通道速度。如果代理崩溃或重新启动，则当代理联机时，仅恢复存储在磁盘上的事件。此通道目前处于实验阶段，不建议在生产中使用。

必需的属性以粗体显示。有关其他必需属性，请参阅文件通道。

属性名称	违约	描述
类型	–	组件类型名称，需要为溢出内存
内存容量	10000	内存队列中存储的最大事件数。要禁用内存中队列，请将此值设置为零。
溢出容量	100000000	溢出磁盘中存储的最大事件数（即文件通道）。要禁用溢出，请将此值设置为零。
溢出超时	3	在内存填满时启用磁盘溢出之前要等待的秒数。
字节容量缓冲区	20	定义字节容量与通道中所有事件的估计总大小之间的缓冲区百分比，以考虑标头中的数据。见下文。
字节容量	查看说明	允许的最大内存字节数作为内存队列中所有事件的总和。该实现仅计算事件正文，这也是提供字节容量缓冲区百分比配置参数的原因。默认值为计算值等于 JVM 可用最大内存的 80%（即命令行上传递的 -Xmx 值的 80%）。请注意，如果单个 JVM 上有多个内存通道，并且它们碰巧包含相同的物理事件（即，如果您使用的是来自单个源的复制通道选择器），则出于通道字节容量的目的，这些事件大小可能会被重复计算。将此值设置为 0 将导致此值回退到大约 200 GB 的硬内部限制。
avgEventSize	500	进入通道的事件的估计平均大小（以字节为单位）
<文件通道属性>	查看文件通道	可以使用除“保持活动状态”和“容量”之外的任何文件通道属性。文件通道的保持活动状态由溢出内存通道管理。使用“溢出容量”设置文件通道的容量。

如果达到内存容量或字节容量限制，则认为内存中队列已满。

名为 a1 的代理的示例：

a1.channels = c1
a1.channels.c1.type = SPILLABLEMEMORY
a1.channels.c1.memoryCapacity = 10000
a1.channels.c1.overflowCapacity = 1000000
a1.channels.c1.byteCapacity = 800000
a1.channels.c1.checkpointDir = /mnt/flume/checkpoint
a1.channels.c1.dataDirs = /mnt/flume/data

要禁用内存中队列并像文件通道一样工作，请执行以下操作：

a1.channels = c1
a1.channels.c1.type = SPILLABLEMEMORY
a1.channels.c1.memoryCapacity = 0
a1.channels.c1.overflowCapacity = 1000000
a1.channels.c1.checkpointDir = /mnt/flume/checkpoint
a1.channels.c1.dataDirs = /mnt/flume/data

要禁用溢出磁盘并纯粹用作内存中通道，请执行以下操作：

a1.channels = c1
a1.channels.c1.type = SPILLABLEMEMORY
a1.channels.c1.memoryCapacity = 100000
a1.channels.c1.overflowCapacity = 0

伪交易通道

警告

伪事务通道仅用于单元测试目的，不用于生产用途。

必需的属性以粗体显示。

属性名称	违约	描述
类型	–	组件类型名称，需要为 org.apache.flume.channel.PseudoTxnMemoryChannel
能力	50	通道中存储的最大事件数
保持活动状态	3	添加或删除事件的超时（以秒为单位）

自定义频道

自定义通道是你自己的通道接口实现。启动 Flume 代理时，自定义通道的类及其依赖项必须包含在代理的类路径中。自定义通道的类型是其 FQCN。必需的属性以粗体显示。

属性名称	违约	描述
类型	–	组件类型名称，需要为 FQCN

名为 a1 的代理的示例：

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

水槽通道选择器

如果未指定类型，则默认为“复制”。

复制通道选择器（默认）

必需的属性以粗体显示。

属性名称	违约	描述
选择器.类型	复制	组件类型名称，需要复制
选择器.可选	–	要标记为可选的通道集

名为 a1 的代理示例，其源名为 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 是可选通道。未能写入 c3 将被忽略。由于 c1 和 c2 未标记为可选，因此未能写入这些通道将导致事务失败。

多路复用通道选择器

必需的属性以粗体显示。

属性名称	违约	描述
选择器.类型	复制	组件类型名称，需要多路复用
selector.header	flume.selector.header
selector.default	–
selector.mapping.*	–

名为 a1 的代理示例，其源名为 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

自定义渠道选择器

自定义通道选择器是您自己的通道选择器接口的实现。启动 Flume 代理时，自定义通道选择器的类及其依赖项必须包含在代理的类路径中。自定义通道选择器的类型是其 FQCN。

属性名称	违约	描述
选择器.类型	–	组件类型名称，需要是您的 FQCN

名为 a1 的代理及其源名为 r1 的示例：

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

水槽水槽处理器

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

必需的属性以粗体显示。

属性名称	违约	描述
汇	–	参与该组的以空间分隔的汇列表
处理器类型	违约	组件类型名称需要为默认值、故障转移或load_balance

名为 a1 的代理的示例：

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

默认接收器处理器

默认接收器处理器仅接受单个接收器。不强制用户为单个接收器创建处理器（接收器组）。相反，用户可以遵循本用户指南中上面介绍的源 - 通道 - 接收器模式。

故障转移接收器处理器

故障转移接收器处理器维护一个按优先级排列的接收器列表，保证只要有一个可用，事件就会被处理（传递）。

故障转移机制的工作原理是将故障接收器降级到池中，在池中为它们分配一个冷却期，在重试之前，这些接收器会随着连续故障的增加而增加。接收器成功发送事件后，它将还原到活动池。接收器具有与它们关联的优先级，数字越大，优先级越高。如果接收器在发送事件时失败，则接下来应尝试下一个具有最高优先级的接收器来发送事件。例如，优先级为 100 的接收器在优先级为 80 的接收器之前激活。如果未指定优先级，则根据在配置中指定接收器的顺序确定 thr 优先级。

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

必需的属性以粗体显示。

属性名称	违约	描述
汇	–	参与该组的以空间分隔的汇列表
处理器类型	违约	组件类型名称，需要故障转移
处理器.优先级.<inkName>	–	优先级值。<sinkName>必须是与当前接收器组关联的接收器实例之一优先级较高的值“接收器”较早激活。绝对值越大，表示优先级越高
processor.maxpenalty	30000	失败接收器的最大回退期（以毫为单位）

名为 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

负载平衡接收器处理器

负载平衡接收器处理器提供了在多个接收器上对流进行负载平衡的功能。它维护必须将负载分布到的活动接收器的索引列表。实现支持通过round_robin或随机选择机制来分配负载。选择机制默认为round_robin类型，但可以通过配置进行覆盖。自定义选择机制通过从 AbstractSinkSelector 继承的自定义类得到支持。

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

如果启用了回退，则接收器处理器会将失败的接收器列入黑名单，并删除它们以供给定超时选择。当超时结束时，如果接收器仍然没有响应，则超时将呈指数级增加，以避免在无响应的接收器上陷入长时间等待。禁用此功能后，在轮循机制中，所有失败的接收器负载将按顺序传递到下一个接收器，因此不会均匀平衡

必需的属性以粗体显示。

属性名称	违约	描述
处理器.接收器	–	参与该组的以空间分隔的汇列表
处理器类型	违约	组件类型名称，需要load_balance
处理器.回退	假	故障接收器是否应呈指数级退缩。
处理器.选择器	round_robin	选择机制。必须是从 AbstractSinkSelector 继承的自定义类的round_robin、随机或 FQCN
processor.selector.maxTimeOut	30000	由退避选择器用于限制指数退避（以毫秒为单位）

名为 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

自定义接收器处理器

目前不支持自定义接收器处理器。

事件序列化程序

file_roll接收器和 hdfs 接收器都支持事件序列化程序接口。下面提供了与Flume一起附带的事件序列化器的详细信息。

正文文本序列化程序

别名：文本。此侦听器将事件的正文写入输出流，而无需进行任何转换或修改。将忽略事件标头。配置选项如下：

属性名称	违约	描述
追加新行	真	是否在写入时将换行符追加到每个事件。默认值 true 假定事件不包含换行符，原因为旧原因。

名为 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

别名：avro_event。

此侦听器将 Flume 事件序列化为 Avro 容器文件。使用的架构与 Avro RPC 机制中用于 Flume 事件的架构相同。

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

配置选项如下：

属性名称	违约	描述
syncIntervalBytes	2048000	Avro 同步间隔，以近似字节为单位。
压缩编解码器	零	Avro 压缩编解码器。有关支持的编解码器，请参阅 Avro 的编解码器网站文档。

名为 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 事件序列化程序

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

这会将 Flume 事件序列化为 Avro 容器文件，如“Flume 事件”Avro 事件序列化程序，但记录架构是可配置的。可以将记录架构指定为 Flume 配置属性，也可以在事件标头中传递。

要将记录架构作为 Flume 配置的一部分进行传递，请使用下面列出的属性架构 URL。

若要在事件标头中传递记录架构，请指定包含架构的 JSON 格式表示形式的事件标头 flume.avro.schema.literal 或包含可以找到该架构的 URL 的 flume.avro.schema.url （hdfs：/...支持 URI）。

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

配置选项如下：

属性名称	违约	描述
syncIntervalBytes	2048000	Avro 同步间隔，以近似字节为单位。
压缩编解码器	零	Avro 压缩编解码器。有关支持的编解码器，请参阅 Avro 的编解码器网站文档。
架构网址	零	Avro schema URL.在标头中指定的架构 ovverride 此选项。

名为 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是实现org.apache.flume.interceptor.Interceptor接口的类。拦截器可以根据拦截器开发人员选择的任何条件修改甚至删除事件。Flume支持拦截器的链式连接。这是通过在配置中指定拦截器生成器类名的列表来实现的。拦截器在源配置中指定为空格分隔的列表。指定侦听器的顺序是调用它们的顺序。一个拦截器返回的事件列表将传递到链中的下一个拦截器。侦听器可以修改或删除事件。如果侦听器需要删除事件，它只是不会在它返回的列表中返回该事件。如果要删除所有事件，则它只是返回一个空列表。拦截器是命名的组件，下面是如何通过配置创建它们的一个示例：

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

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

时间戳拦截器

此侦听器在事件标头中插入它处理事件的时间（以毫秒为单位）。此侦听器插入一个标头，该标头具有关键时间戳（或由 header 属性指定），其值为相关时间戳。如果配置中已存在现有时间戳，则此侦听器可以保留该时间戳。

属性名称	违约	描述
类型	–	组件类型名称必须是时间戳或 FQCN
标头名称	时间戳	要在其中放置生成的时间戳的标头的名称。
保留存在	假	如果时间戳已经存在，是否应该保留它 - true 还是 false

名为 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

主机拦截器

此侦听器插入运行此代理的主机的主机名或 IP 地址。它根据配置插入一个包含密钥主机的标头或一个配置的密钥，其值为主机的主机名或 IP 地址。

属性名称	违约	描述
类型	–	组件类型名称，必须是主机
保留存在	假	如果主机标头已存在，应保留它 - true 还是 false
使用IP	真	如果为 true，请使用 IP 地址，否则使用主机名。
主机标题	主机	要使用的标头键。

名为 a1 的代理的示例：

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

静态拦截器

静态拦截器允许用户将具有静态值的静态标头附加到所有事件。

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

属性名称	违约	描述
类型	–	组件类型名称，必须是静态的
保留存在	真	如果已配置的标头已存在，应保留它 - true 还是 false
钥匙	钥匙	应创建的标头的名称
价值	价值	应创建的静态值

名为 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

删除标头拦截器

此侦听器通过删除一个或多个标头来操作 Flume 事件标头。它可以删除静态定义的标头、基于正则表达式的标头或列表中的标头。如果未定义这些事件，或者没有标头与条件匹配，则不会修改 Flume 事件。

请注意，如果只需要删除一个标头，则按名称指定标头可比其他 2 种方法提供性能优势。

属性名称	违约	描述
类型	–	组件类型名称必须remove_header
与名称	–	要删除的标头的名称
来自列表	–	要删除的标头列表，用 fromListSeparator 指定的分隔符分隔
来自列表分离器	\s，\s	用于分隔 fromList 指定的列表中的多个标头名称的正则表达式。默认值为逗号，周围有任意数量的空格字符
匹配	–	名称与此正则表达式匹配的所有标头都将被删除

UUID 拦截器

此侦听器为截获的所有事件设置一个通用唯一标识符。示例 UUID 是 b5755073-77a9-43c1-8fad-b7a586fc1b97，它表示 128 位值。

如果事件的应用程序级别唯一键可用，请考虑使用 UUID 接收器自动将 UUID 分配给事件。在事件进入Flume网络后立即将其分配给事件可能很重要;也就是说，在第一个水槽源的流动。这样，在面向高可用性和高性能的 Flume 网络中，在面对复制和重新交付时，可以对事件进行后续重复数据删除。如果应用程序级密钥可用，则这比自动生成的 UUID 更可取，因为它可以使用所述已知应用程序级密钥对数据存储中的事件进行后续更新和删除。

属性名称	违约	描述
类型	–	组件类型名称必须是 org.apache.flume.sink.solr.morphline.UUIDInterceptor$Builder
标头名称	编号	要修改的 Flume 标头的名称
保留存在	真	如果 UUID 标头已存在，应保留它 - true 还是 false
前缀	""	前缀字符串常量，用于附加到每个生成的 UUID 之前

形态线拦截器

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

目前，有一个限制，即拦截器的形态线不得为每个输入事件生成多个输出记录。此拦截器不适用于重型 ETL 处理 - 如果您需要，请考虑将 ETL 处理从水槽源移动到水槽汇，例如 MorphlineSolrSink。

必需的属性以粗体显示。

属性名称	违约	描述
类型	–	组件类型名称必须是 org.apache.flume.sink.solr.morphline.MorphlineInterceptor$Builder
形态线文件	–	本地文件系统上到形态线配置文件的相对路径或绝对路径。示例：/etc/flume-ng/conf/morphline.conf
形态线Id	零	用于标识形态线（如果形态线配置文件中有多个形态线）的可选名称

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

搜索和替换拦截器

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

属性名称	违约	描述
类型	–	组件类型名称必须search_replace
搜索模式	–	要搜索和替换的模式。
替换字符串	–	替换字符串。
字符集	UTF-8	事件正文的字符集。默认假定为 UTF-8。

配置示例：

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 =

另一个例子：

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_filter
正则表达式	".*"	用于与事件进行匹配的正则表达式
排除事件	假	如果为 true，则正则表达式确定要排除的事件，否则正则表达式确定要包含的事件。

正则表达式提取器拦截器

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

属性名称	违约	描述
类型	–	组件类型名称必须regex_extractor
正则表达式	–	用于与事件进行匹配的正则表达式
序列化程序	–	以空格分隔的序列化程序列表，用于将匹配项映射到标头名称并序列化其值。（请参阅下面的示例）Flume 为以下序列化程序提供内置支持：org.apache.flume.interceptor.RegexExtractorInterceptorPassThroughSerializer org.apache.flume.interceptor.RegexExtractorInterceptorMillisSerializer
序列化程序.<s1>.type	违约	必须是默认值（org.apache.flume.interceptor.RegexExtractorInterceptorPassThroughSerializer）、org.apache.flume.interceptor.RegexExtractorInterceptorMillisSerializer，或实现 org.apache.flume.interceptor.RegexExtractorInterceptorSerializer 的自定义类的 FQCN
序列化程序.<s1>.名字	–
序列化程序。	–	特定于序列化程序的属性

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

示例 1：

如果 Flume 事件正文包含 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

提取的事件将包含相同的正文，但以下标头将添加 1=>1、2=>2、3=>3

示例 2：

如果 Flume 事件正文包含 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

提取的事件将包含相同的正文，但以下标头将被添加时间戳 =>1350611220000

水槽属性

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

属性：flume.called.from.service

Flume 每 30 秒定期轮询一次，以查找对指定配置文件的更改。如果首次轮询现有文件，或者如果现有文件的修改日期自上次轮询以来已更改，则 Flume 代理会从配置文件中加载新配置。重命名或移动文件不会更改其修改时间。当 Flume 代理轮询一个不存在的文件时，将发生以下两种情况之一：1. 当代理首次轮询一个不存在的配置文件时，代理将根据 flume.called.from.service 属性进行操作。如果设置了该属性，则代理将继续轮询（始终在同一时间段 - 每 30 秒一次）。如果未设置该属性，则代理将立即终止。...或。。。2. 当代理轮询不存在的配置文件并且这不是第一次轮询该文件时，则代理在此轮询期间不会进行任何配置更改。代理继续轮询而不是终止。

配置筛选器

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>]}

环境变量配置筛选器

属性名称	违约	描述
类型	–	组件类型名称必须为 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']} #will get the value Secret123

此处，a1.sources.r1.keystorePassword 配置属性将获取my_keystore_password环境变量的值。设置环境变量的一种方法是像这样运行 flume agent：

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

外部进程配置筛选器

属性名称	违约	描述
类型	–	组件类型名称必须是外部的
命令	–	将执行以获取给定键的值的命令。该命令将按如下方式调用：<command> <key> 并且期望返回退出代码为0的单行值。
字符集	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']} #will get the value Secret123

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

$ /usr/bin/passwordResolver.sh my_keystore_password

passwordResolver.sh 将返回退出代码为 0 的 Secret123。

示例 2

若要生成用于滚动文件接收器的目录的一部分，请设置其值，如以下示例所示。

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']} # will be /var/log/flume/agent_1234

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

$ /usr/bin/generateUniqId.sh agent_name

generateUniqId.sh 将返回 1234，退出代码为 0。

Hadoop Credential Store Config Filter

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

属性名称	违约	描述
类型	–	组件类型名称必须为 hadoop
credential.provider.path	–	提供程序路径。请参阅 hadoop 文档_here：Apache Hadoop 3.3.4 – CredentialProvider API Guide
credstore.java-keystore-provider.password-file	–	密码文件的名称（如果文件用于存储密码）。文件必须在类路径上以 e 为单位。提供程序密码可以使用 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']} #will get the value from the credential store

Log4J Appender

将 Log4j 事件附加到水槽代理的 avro 源。使用此追加器的客户端必须在类路径中具有 flume-ng-sdk（例如，flume-ng-sdk-1.9.0.jar）。必需的属性以粗体显示。

属性名称	违约	描述
主机名	–	远程 Flume 代理使用 avro 源运行该代理的主机名。
港口	–	远程 Flume 代理的 avro 源正在侦听的端口。
不安全模式	假	如果为 true，则追加器不会在发送事件失败时引发异常。
AvroReflectionEnabled	假	使用Avro Reflection序列化Log4j事件。（用户记录字符串时不要使用）
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 布局（如果已指定）转换为字符串。

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

使用其 Avro 架构序列化每个事件是低效的，因此最好提供一个架构 URL，下游接收器（通常是 HDFS 接收器）可以从中检索架构。如果未指定 AvroSchemaUrl，则该架构将作为 Flume 标头包含在内。

配置为使用 Avro 序列化的示例 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.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
#...

负载平衡日志4J追加器

将 Log4j 事件附加到 flume agent 的 avro 源列表中。使用此追加器的客户端必须在类路径中具有 flume-ng-sdk（例如，flume-ng-sdk-1.9.0.jar）。此追加器支持用于执行负载平衡的轮循机制和随机方案。它还支持可配置的回退超时，以便从主机集中临时删除关闭代理所需的属性以粗体显示。

属性名称	违约	描述
主机	–	以空格分隔的 host：port 列表，Flume（通过 AvroSource）正在侦听事件
选择器	ROUND_ROBIN	选择机制。必须是ROUND_ROBIN、RANDOM 或自定义 FQDN 到从 LoadBalancingSelector 继承的类。
最大回退	–	一个长整型值，表示负载平衡客户端将从未能使用事件的节点回退的最长时间（以毫秒为单位）。默认为无退避
不安全模式	假	如果为 true，则追加器不会在发送事件失败时引发异常。
AvroReflectionEnabled	假	使用Avro Reflection序列化Log4j事件。
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
#...

安全

HDFS 接收器、HBase 接收器、Thrift 源、Thrift 接收器和 Kite 数据集接收器都支持 Kerberos 身份验证。有关配置 Kerberos 相关选项的相应部分，请参阅这些部分。

Flume 代理将作为单个主体向 kerberos KDC 进行身份验证，该主体将由需要 kerberos 身份验证的不同组件使用。为节俭源、节俭接收器、HDFS 接收器、HBase 接收器和数据集接收器配置的主节点和密钥表应相同，否则组件将无法启动。

监测

Flume的监测工作仍在进行中。更改可能经常发生。几个 Flume 组件向 JMX 平台 MBean 服务器报告指标。可以使用 Jconsole 查询这些指标。

可用组件指标

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

来源 1

	阿夫罗	执行	断续器	断续器	卡夫卡	MultiportSyslogTCP	抄写员
追加接受的帐户	x
追加补丁接受的计数	x		x	x
AppendBatchReceivedCount	x		x	x
附录接收计数	x
ChannelWriteFail	x		x	x	x	x	x
事件接受帐户	x	x	x	x	x	x	x
事件阅读失败			x	x	x	x	x
事件接收计数	x	x	x	x	x	x	x
通用处理失败			x			x
卡夫卡委员会计时器					x
KafkaEmptyCount					x
KafkaEventGetTimer					x
OpenConnectionCount	x

来源 2

	序列生成器	线轴目录	SyslogTcp	系统日志	Taildir	节俭
追加接受的帐户						x
追加补丁接受的计数	x	x			x	x
AppendBatchReceivedCount		x			x	x
附录接收计数						x
ChannelWriteFail	x	x	x	x	x	x
事件接受帐户	x	x	x	x	x	x
事件阅读失败		x	x	x	x
事件接收计数		x	x	x	x	x
通用处理失败		x			x
卡夫卡委员会计时器
KafkaEmptyCount
KafkaEventGetTimer
OpenConnectionCount

水槽 1

	阿夫罗/节俭	AsyncHBase	弹性搜索	HBase	HBase2
批处理完成计数	x	x	x	x	x
BatchEmptyCount	x	x	x	x	x
批次流计数	x	x	x	x	x
ChannelReadFail	x				x
连接关闭计数	x	x	x	x	x
连接创建计数	x	x	x	x	x
连接失败计数	x	x	x	x	x
事件拖曳尝试计数	x	x	x	x	x
事件拖尾成功计数	x	x	x	x	x
事件写失败	x				x
KafkaEventSendTimer
回滚计数

水槽 2

	HDFSEvent	蜂房	网址	卡夫卡	形态线	滚动文件
批处理完成计数	x	x			x
BatchEmptyCount	x	x		x	x
批次流计数	x	x		x	x
ChannelReadFail	x	x	x	x	x	x
连接关闭计数	x	x				x
连接创建计数	x	x				x
连接失败计数	x	x				x
事件拖曳尝试计数	x	x	x		x	x
事件拖尾成功计数	x	x	x	x	x	x
事件写失败	x	x	x	x	x	x
KafkaEventSendTimer				x
回滚计数				x

渠道

	文件	卡夫卡	记忆	PseudoTxnMemory	可溢出内存
通道容量	x		x		x
通道大小	x		x	x	x
检查点备份写入错误计数	x
检查点写入错误计数	x
事件输入尝试计数	x	x	x	x	x
事件错误计数	x
事件命中成功计数	x	x	x	x	x
事件获取尝试计数	x	x	x	x	x
事件获取错误计数	x
事件获取成功计数	x	x	x	x	x
卡夫卡委员会计时器		x
KafkaEventGetTimer		x
KafkaEventSendTimer		x
打开	x
回滚计数器		x
不良	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”

注意：上面的示例禁用了安全性。要启用安全性，请参阅 Monitoring and Management Using JMX Technology - Java SEMonitoring and Management Guide

神经节报告

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

属性名称	违约	描述
类型	–	组件类型名称，必须是神经节
主机	–	以逗号分隔的主机名列表：Ganglia 服务器的端口
投票频率	60	向Ganglia服务器连续报告之间的时间（以秒为单位）
是冈 3	假	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"}
}

属性名称	违约	描述
类型	–	组件类型名称，必须为 http
港口	41414	用于启动服务器的端口。

我们可以启动Flume与JSON报告支持，如下所示：

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

然后，指标将在 http://<hostname>：<port>/metrics网页上提供。自定义组件可以报告上述“神经节”部分中提到的指标。

自定义报告

可以通过编写执行报告的服务器向其他系统报告指标。任何报告类都必须实现接口 org.apache.flume.instrumentation.MonitorService。这样的类可以像使用GangliaServer用于报告一样。他们可以轮询平台 mbean 服务器以轮询 mbean 的指标。例如，如果可以按如下方式使用名为 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

属性名称	违约	描述
类型	–	组件类型名称必须为 FQCN

来自自定义组件的报告指标

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

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);
  }

}

工具

文件通道完整性工具

文件通道完整性工具验证文件通道中各个事件的完整性，并删除损坏的事件。

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

$bin/flume-ng tool --conf ./conf FCINTEGRITYTOOL -l ./datadir

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

以下是可用的选项

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

事件验证器工具

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

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

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

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

以下是可用的选项

选项名称	描述
h/帮助	显示帮助
l/dataDirs	工具必须验证的数据目录的逗号分隔列表
e/eventValidator	事件验证程序实现的完全限定名称。罐子必须在Flume类路径上

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

让我们看一个基于简单大小的事件验证程序的示例，它将拒绝大于指定的最大大小的事件。

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

水槽中的流量可靠性

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

您使用的渠道类型。Flume既有持久通道（将数据保存到磁盘的通道）也有非持久通道（如果机器发生故障会丢失数据的通道）。持久通道使用基于磁盘的存储，存储在此类通道中的数据将在计算机重新启动或与磁盘无关的故障时持续存在。

您的通道是否已针对工作负载进行了充分的预置。Flume 中的通道充当各种跃点处的缓冲区。这些缓冲区具有固定的容量，一旦该容量已满，您将在流中的早期点上产生背压。如果该压力传播到流量源，Flume将变得不可用并可能丢失数据。

是否使用冗余拓扑。Flume 允许您跨冗余拓扑复制流。这可以提供一个非常简单的容错源，并且可以克服磁盘或计算机故障。

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

水槽拓扑设计

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

确定水槽部署的规模

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

通过调整聚合吞吐量的大小，可以降低每层所需的节点数。拥有更多节点有几个原因，例如增加冗余和更好地吸收负载突发的能力。

故障排除

处理代理故障

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

兼容性

高清软件

目前Flume支持HDFS 0.20.2和0.23。

阿夫罗

待定

其他版本要求

待定

组件摘要

组件接口	类型别名	实现类
org.apache.flume.Channel	记忆	org.apache.flume.channel.MemoryChannel
org.apache.flume.Channel	断续器	org.apache.flume.channel.jdbc.JdbcChannel
org.apache.flume.Channel	文件	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	阿夫罗	org.apache.flume.source.AvroSource
org.apache.flume.Source	网猫	org.apache.flume.source.NetcatSource
org.apache.flume.Source	seq	org.apache.flume.source.SequenceGeneratorSource
org.apache.flume.Source	执行官	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	网址	org.apache.flume.source.http.httpSource
org.apache.flume.Source	节俭	org.apache.flume.source.ThriftSource
org.apache.flume.Source	断续器	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	零	org.apache.flume.sink.NullSink
org.apache.flume.sink	记录	org.apache.flume.sink.LoggerSink
org.apache.flume.sink	阿夫罗	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	异步基础	org.apache.flume.sink.hbase.AsyncHBaseSink
org.apache.flume.sink	弹性搜索	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	节俭	org.apache.flume.sink.ThriftSink
org.apache.flume.sink	–	org.example.MySink
org.apache.flume.ChannelSelector	复制	org.apache.flume.channel.ReplicatingChannelSelector
org.apache.flume.ChannelSelector	多路复用	org.apache.flume.channel.MultiplexingChannelSelector
org.apache.flume.ChannelSelector	–	org.example.MyChannelSelector
org.apache.flume.SinkProcessor	违约	org.apache.flume.sink.DefaultSinkProcessor
org.apache.flume.SinkProcessor	故障转移	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	时间戳	org.apache.flume.interceptor.TimestampInterceptor$Builder
org.apache.flume.interceptor.Interceptor	主机	org.apache.flume.interceptor.HostInterceptor$Builder
org.apache.flume.interceptor.Interceptor	静态的	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	无痕剥落	org.apache.flume.channel.file.encryption.AESCTRNoPaddingProvider
org.apache.flume.channel.file.encryption.CipherProvider	–	org.example.MyCipherProvider
org.apache.flume.serialization.EventSerializer$Builder	发短信	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