扇出流量
如上一节所述,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
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:
- Common Name (CN) RFC 6125: Representation and Verification of Domain-Based Application Service Identity within Internet Public Key Infrastructure Using X.509 (PKIX) Certificates in the Context of Transport Layer Security (TLS)
- Subject Alternative Name (SAN) RFC 5280: Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile
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 的加密,具有可选身份验证。
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):
- 公用名 (CN) RFC 6125: Representation and Verification of Domain-Based Application Service Identity within Internet Public Key Infrastructure Using X.509 (PKIX) Certificates in the Context of Transport Layer Security (TLS)
- 使用者备用名称 (SAN) RFC 5280: Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile
如果还需要客户端身份验证,则需要将以下内容添加到 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
安全和卡夫卡频道:
Flume和Kafka之间的通信通道支持安全身份验证和数据加密。对于安全身份验证,可以从 Kafka 版本 0.9.0 使用 SASL/GSSAPI (Kerberos V5) 或 SSL(即使参数名为 SSL,实际协议是 TLS 实现)。
截至目前,数据加密仅由SSL / TLS提供。
将 kafka.producer|consumer.security.protocol 设置为以下任何值意味着:
- SASL_PLAINTEXT - Kerberos 或纯文本身份验证,无需数据加密
- SASL_SSL - Kerberos 或具有数据加密的纯文本身份验证
- SSL - 基于 TLS 的加密,具有可选身份验证。
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 Channel:
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.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):
- 公用名 (CN) RFC 6125: Representation and Verification of Domain-Based Application Service Identity within Internet Public Key Infrastructure Using X.509 (PKIX) Certificates in the Context of Transport Layer Security (TLS)
- 使用者备用名称 (SAN) RFC 5280: Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile
如果还需要客户端身份验证,则需要将以下内容添加到 Flume 代理配置中,或者可以使用全局 SSL 设置(请参阅 SSL/TLS 支持部分)。每个Flume代理都必须有其客户端证书,该证书必须由Kafka经纪人单独或由其签名链信任。常见示例是通过单个根 CA 对每个客户端证书进行签名,而 Kafka 代理又信任该根 CA。
# 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>
示例 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";
};
文件通道
必需的属性以粗体显示。
属性名称默认值 | 描述 | |
---|
类型 | – | 组件类型名称,需要为文件。 |
检查点目录 | ~/.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
水槽拦截器
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
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,则正则表达式确定要排除的事件,否则正则表达式确定要包含的事件。 |
示例 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