配置参考

本页面记录了每种 Druid 服务类型的所有配置属性。

推荐的配置文件组织结构

推荐的 Druid 配置文件组织方式可以在 Druid 包根目录下的 conf 目录中看到，如下所示：

$ ls -R conf
druid

conf/druid:
_common       broker        coordinator   historical    middleManager overlord

conf/druid/_common:
common.runtime.properties log4j2.xml

conf/druid/broker:
jvm.config         runtime.properties

conf/druid/coordinator:
jvm.config         runtime.properties

conf/druid/historical:
jvm.config         runtime.properties

conf/druid/middleManager:
jvm.config         runtime.properties

conf/druid/overlord:
jvm.config         runtime.properties

每个目录都有一个 runtime.properties 文件，其中包含对应于该目录的特定 Druid 服务（例如 historical）的配置属性。

jvm.config 文件包含每个服务的 JVM 参数，例如堆大小配置属性。

所有服务共享的通用属性放置在 _common/common.runtime.properties 中。

配置插值

配置值可以从系统属性、环境变量或本地文件中进行插值。下面是其用法示例：

druid.metadata.storage.type=${env:METADATA_STORAGE_TYPE}
druid.processing.tmpDir=${sys:java.io.tmpdir}
druid.segmentCache.locations=${file:UTF-8:/config/segment-cache-def.json}

插值也是递归的，因此您可以执行以下操作：

druid.segmentCache.locations=${file:UTF-8:${env:SEGMENT_DEF_LOCATION}}

如果未设置该属性，启动时将抛出异常，但如果需要，可以提供默认值。使用文件插值时设置默认值无效，因为如果文件不存在，将抛出异常。

druid.metadata.storage.type=${env:METADATA_STORAGE_TYPE:-mysql}
druid.processing.tmpDir=${sys:java.io.tmpdir:-/tmp}

如果您需要设置一个由 ${...} 包裹的变量，但不希望它被插值，可以通过添加另一个 $ 来对其进行转义。例如：

config.name=$${value}

通用配置

本节下的属性是应在集群中所有 Druid 服务之间共享的通用配置。

JVM 配置最佳实践

我们在所有服务上设置了四个 JVM 参数：

• -Duser.timezone=UTC：这会将 JVM 的默认时区设置为 UTC。我们始终设置此项，并且不会使用其他默认时区进行测试，因此本地时区可能会起作用，但也可能会暴露出奇怪且有趣的错误。要在非 UTC 时区发出查询，请参阅 查询粒度。

• -Dfile.encoding=UTF-8：这与时区类似，我们假设以 UTF-8 进行测试。本地编码可能有效，但也可能导致奇怪且有趣的错误。

• -Djava.io.tmpdir=<a path>：Druid 的各个部分使用临时文件与文件系统交互。这些文件可能会变得非常大。这意味着 /tmp 目录较小的系统可能会给 Druid 带来问题。因此，请将 JVM 临时目录设置在空间充足的位置。

  配置 JVM 临时目录时还要考虑以下几点：

  • 临时目录不应是易失性的 tmpfs。
  • 此目录还应具有良好的读写速度。
  • 避免使用 NFS 挂载。
  • org.apache.druid.java.util.metrics.SysMonitor 需要 java.io.tmpdir 中文件的执行权限。如果您正在使用系统监控器，请不要将 java.io.tmpdir 设置为 noexec。

• -Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager：这允许 log4j2 处理那些使用标准 Java 日志记录的非 log4j2 组件（如 jetty）的日志。

扩展

Druid 的许多外部依赖项可以作为模块插入。可以使用以下配置提供扩展：

属性	描述	默认值
druid.extensions.directory	用户可以存放扩展相关文件的根扩展目录。Druid 将加载存储在此目录下的扩展。	extensions（这是相对于 Druid 工作目录的路径）
druid.extensions.loadList	一个 JSON 数组，包含 Druid 要从扩展目录加载的扩展名。如果未指定，其值将为 null，Druid 将加载 druid.extensions.directory 下的所有扩展。如果其值为空列表 []，则不会加载任何扩展。也可以指定未存储在公共扩展目录中的其他自定义扩展的绝对路径。	null
druid.extensions.searchCurrentClassloader	这是一个布尔标志，决定 Druid 是否会在主类加载器中搜索扩展。默认为 true，但如果您有理由不自动添加类路径上的所有模块，则可以将其关闭。	true
druid.extensions.useExtensionClassloaderFirst	这是一个布尔标志，决定 Druid 扩展是否应优先从其自身的 jar 包加载类，而不是从 Druid 捆绑的 jar 包加载。如果为 false，扩展必须与 Druid 捆绑的任何 jar 包提供的类兼容。如果为 true，扩展可以依赖冲突的版本。	false

模块

属性	描述	默认值
druid.modules.excludeList	一个模块类规范类名（例如 "org.apache.druid.somepackage.SomeModule"）的 JSON 数组，这些模块类不应被加载，即使它们在 druid.extensions.loadList 指定的扩展中找到，或者在特定 Druid 服务类型上指定加载的核心模块列表中找到。当某些有用的扩展包含某些模块，但由于该模块的某些依赖项无法满足而不应在某些 Druid 服务类型上加载时，此配置非常有用。	[]

ZooKeeper

我们建议仅设置基础 ZK 路径和 ZK 服务主机，但 Druid 使用的所有 ZK 路径都可以覆盖为绝对路径。

属性	描述	默认值
druid.zk.paths.base	基础 ZooKeeper 路径。	/druid
druid.zk.service.host	要连接的 ZooKeeper 主机。这是一个必需属性，因此必须提供主机地址。	无
druid.zk.service.user	用于向 ZooKeeper 进行身份验证的用户名。这是一个可选属性。	无
druid.zk.service.pwd	用于向 ZooKeeper 进行身份验证的 密码提供程序 或字符串密码。这是一个可选属性。	无
druid.zk.service.authScheme	digest 是唯一支持的身份验证方案。	digest

ZooKeeper 行为

属性	描述	默认值
druid.zk.service.sessionTimeoutMs	ZooKeeper 会话超时（以毫秒为单位）。	30000
druid.zk.service.connectionTimeoutMs	ZooKeeper 连接超时（以毫秒为单位）。	15000
druid.zk.service.compress	用于确定是否应压缩创建的 Znode 的布尔标志。	true
druid.zk.service.acl	用于确定是否启用 ZooKeeper ACL 安全性的布尔标志。如果启用了 ACL，zNode 创建者将拥有所有权限。	false
druid.zk.service.pathChildrenCacheStrategy	决定服务通告的底层缓存策略。设置为 true 可让通告程序使用 Apache Curator 的 PathChildrenCache 策略，否则使用 NodeCache 策略。当您在集群中处理大量 ZooKeeper 监视时，请考虑使用 NodeCache 策略。	true

路径配置

Druid 通过一组标准路径配置与 ZooKeeper 交互。我们建议仅设置基础 ZooKeeper 路径，但 Druid 使用的所有 ZooKeeper 路径都可以覆盖为绝对路径。

属性	描述	默认值
druid.zk.paths.base	基础 ZooKeeper 路径。	/druid
druid.zk.paths.propertiesPath	ZooKeeper 属性路径。	${druid.zk.paths.base}/properties
druid.zk.paths.announcementsPath	Druid 服务通告路径。	${druid.zk.paths.base}/announcements
druid.zk.paths.liveSegmentsPath	Druid 服务通告其 Segment 的当前路径。	${druid.zk.paths.base}/segments
druid.zk.paths.coordinatorPath	由 Coordinator 用于领导者选举。	${druid.zk.paths.base}/coordinator

索引服务也使用自己的一组路径。这些配置可以包含在通用配置中。

属性	描述	默认值
druid.zk.paths.indexer.base	基础 ZooKeeper 路径，用于	${druid.zk.paths.base}/indexer
druid.zk.paths.indexer.announcementsPath	Middle Manager 在此处通告自己。	${druid.zk.paths.indexer.base}/announcements
druid.zk.paths.indexer.tasksPath	用于将任务分配给 Middle Manager。	${druid.zk.paths.indexer.base}/tasks
druid.zk.paths.indexer.statusPath	用于通告任务状态的父路径。	${druid.zk.paths.indexer.base}/status

如果同时设置了 druid.zk.paths.base 和 druid.zk.paths.indexer.base，且没有设置其他 druid.zk.paths.* 或 druid.zk.paths.indexer.* 值，则其他属性将相对于它们各自的 base 进行评估。例如，如果 druid.zk.paths.base 设置为 /druid1，druid.zk.paths.indexer.base 设置为 /druid2，则 druid.zk.paths.announcementsPath 将默认为 /druid1/announcements，而 druid.zk.paths.indexer.announcementsPath 将默认为 /druid2/announcements。

以下路径用于服务发现。它不受 druid.zk.paths.base 的影响，并且必须单独指定。

属性	描述	默认值
druid.discovery.curator.path	服务在此 ZooKeeper 路径下通告自己。	/druid/discovery

TLS

通用配置

属性	描述	默认值
druid.enablePlaintextPort	启用/禁用 HTTP 连接器。	true
druid.enableTlsPort	启用/禁用 HTTPS 连接器。	false

虽然不推荐，但可以同时启用 HTTP 和 HTTPS 连接器，并且可以使用每个服务上的 druid.plaintextPort 和 druid.tlsPort 属性配置相应的端口。请参阅各服务的“配置”部分以查看这些端口的有效值和默认值。

Jetty 服务器 TLS 配置

Druid 使用 Jetty 作为嵌入式 Web 服务器。要了解有关 Jetty 中 TLS/SSL、证书和相关概念的更多信息（包括对以下配置设置的解释），请参阅 Jetty 操作指南 中的“配置 SSL/TLS KeyStores”。

有关 Java 中 TLS/SSL 支持的常规信息，请参阅 Java 安全套接字扩展 (JSSE) 参考指南。JDK 17 的 Java 加密架构标准算法名称文档 列出了以下属性的所有可能值，以及 Java 实现提供的其他属性。

属性	描述	默认值	是否必须
druid.server.https.keyStorePath	TLS/SSL KeyStore 的文件路径或 URL。	无	是
druid.server.https.keyStoreType	KeyStore 的类型。	无	是
druid.server.https.certAlias	连接器的 TLS/SSL 证书别名。	无	是
druid.server.https.keyStorePassword	KeyStore 的 密码提供程序 或字符串密码。	无	是

下表包含非强制性的高级配置选项，请谨慎使用。

属性	描述	默认值	是否必须
druid.server.https.keyManagerFactoryAlgorithm	用于创建 KeyManager 的算法，更多详细信息请见 此处。	javax.net.ssl.KeyManagerFactory.getDefaultAlgorithm()	否
druid.server.https.keyManagerPassword	Key Manager 的 密码提供程序 或字符串密码。	无	否
druid.server.https.includeCipherSuites	要包含的加密套件名称列表。您可以使用确切的加密套件名称或正则表达式。	Jetty 的默认包含加密套件列表	否
druid.server.https.excludeCipherSuites	要排除的加密套件名称列表。您可以使用确切的加密套件名称或正则表达式。	Jetty 的默认排除加密套件列表	否
druid.server.https.includeProtocols	要包含的确切协议名称列表。	Jetty 的默认包含协议列表	否
druid.server.https.excludeProtocols	要排除的确切协议名称列表。	Jetty 的默认排除协议列表	否

内部客户端 TLS 配置（需要 simple-client-sslcontext 扩展）

这些属性适用于 Druid 服务之间进行通信所使用的内部 HTTP 客户端提供的 SSLContext。这些属性需要加载 simple-client-sslcontext 扩展。否则，当启用 TLS 时，Druid 服务将无法相互通信。

属性	描述	默认值	是否必须
druid.client.https.protocol	要使用的 SSL 协议。	TLSv1.2	否
druid.client.https.trustStoreType	存储受信任根证书的密钥库类型。	java.security.KeyStore.getDefaultType()	否
druid.client.https.trustStorePath	存储受信任根证书的 TLS/SSL Key store 的文件路径或 URL。	无	是
druid.client.https.trustStoreAlgorithm	TrustManager 用于验证证书链的算法	javax.net.ssl.TrustManagerFactory.getDefaultAlgorithm()	否
druid.client.https.trustStorePassword	Trust Store 的 密码提供程序 或字符串密码。	无	是

此 文档 列出了上述配置的所有可能值，以及 Java 实现提供的其他值。

身份验证和授权

属性	类型	描述	默认值	是否必须
druid.auth.authenticatorChain	字符串的 JSON 列表	身份验证器类型名称列表	["allowAll"]	否
druid.escalator.type	String	用于 Druid 内部通信的 Escalator 类型。此 Escalator 必须使用 druid.auth.authenticatorChain 中身份验证器支持的身份验证方案。	noop	否
druid.auth.authorizers	字符串的 JSON 列表	授权器类型名称列表	["allowAll"]	否
druid.auth.unsecuredPaths	字符串列表	不对其执行安全检查的路径列表。允许所有对这些路径的请求。	[]	否
druid.auth.allowUnauthenticatedHttpOptions	布尔值	如果为 true，则跳过 HTTP OPTIONS 请求的身份验证检查。这对于某些用例（例如支持 CORS 预检请求）是必需的。请注意，禁用 OPTIONS 请求的身份验证检查将允许未经身份验证的用户确定哪些 Druid 端点是有效的（通过检查 OPTIONS 请求是否返回 200 而不是 404），因此启用此选项可能会泄露有关服务器配置的信息，包括有关加载了哪些扩展的信息（如果这些扩展添加了端点）。	false	否

有关更多信息，请参阅 身份验证和授权。

有关特定身份验证扩展的配置选项，请参阅扩展文档。

启动日志记录

所有服务都可以在启动时记录调试信息。

属性	描述	默认值
druid.startup.logging.logProperties	在启动时记录所有属性（来自 common.runtime.properties、runtime.properties 和 JVM 命令行）。	false
druid.startup.logging.maskProperties	屏蔽包含这些词的敏感属性（例如密码）。	["password"]

请注意，如果启用了这些设置，可能会记录某些敏感信息。

请求日志记录

所有能够处理查询的服务也可以记录它们看到的查询请求。Broker 服务还可以额外记录它们看到的 SQL 请求（来自 HTTP 和 JDBC）。有关设置请求日志记录的示例，请参阅 请求日志记录。

属性	描述	默认值
druid.request.logging.type	如何记录每个查询请求。选择：noop、file、emitter、slf4j、filtered、composing、switching	noop（默认禁用请求日志记录）

要启用将所有 HTTP 请求发送到日志，请将 org.apache.druid.jetty.RequestLog 设置为 DEBUG 级别。有关更多信息，请参阅 日志记录。

文件请求日志记录

file 请求记录器将每日请求日志存储在磁盘上。

属性	描述	默认值
druid.request.logging.dir	Historical、Realtime 和 Broker 服务会维护它们收到的所有请求的请求日志（交互通过 POST 进行，因此普通请求日志通常不会捕获有关实际查询的信息），这指定了存储请求日志的目录。	无
druid.request.logging.filePattern	Joda 日期时间格式，用于每个文件。	"yyyy-MM-dd'.log'"
druid.request.logging.durationToRetain	在磁盘上保留请求日志的期限。该期限应至少与滚动期限一样长。	无
druid.request.logging.rollPeriod	定义请求日志的日志轮转周期。该周期应至少为 PT1H。对于少于 1 天的周期，建议使用 "yyyy-MM-dd-HH'.log'" 作为文件模式。	P1D

请求日志的格式为 TSV，每个请求一行，包含五个字段：timestamp、remote_addr、native_query、query_context、sql_query。

对于原生 JSON 请求，sql_query 字段为空。例如：

2019-01-14T10:00:00.000Z        127.0.0.1   {"queryType":"topN","dataSource":{"type":"table","name":"wikiticker"},"virtualColumns":[],"dimension":{"type":"LegacyDimensionSpec","dimension":"page","outputName":"page","outputType":"STRING"},"metric":{"type":"LegacyTopNMetricSpec","metric":"count"},"threshold":10,"intervals":{"type":"LegacySegmentSpec","intervals":["2015-09-12T00:00:00.000Z/2015-09-13T00:00:00.000Z"]},"filter":null,"granularity":{"type":"all"},"aggregations":[{"type":"count","name":"count"}],"postAggregations":[],"context":{"queryId":"74c2d540-d700-4ebd-b4a9-3d02397976aa"},"descending":false}    {"query/time":100,"query/bytes":800,"success":true,"identity":"user1"}

对于 SQL 查询请求，native_query 字段为空。例如：

2019-01-14T10:00:00.000Z        127.0.0.1       {"sqlQuery/time":100, "sqlQuery/planningTimeMs":10, "sqlQuery/bytes":600, "success":true, "identity":"user1"}  {"query":"SELECT page, COUNT(*) AS Edits FROM wikiticker WHERE TIME_IN_INTERVAL(\"__time\", '2015-09-12/2015-09-13') GROUP BY page ORDER BY Edits DESC LIMIT 10","context":{"sqlQueryId":"c9d035a0-5ffd-4a79-a865-3ffdadbb5fdd","nativeQueryIds":"[490978e4-f5c7-4cf6-b174-346e63cf8863]"}}

发射器请求日志记录

emitter 请求记录器将每个请求发送到 发射器 配置中指定的外部位置。

属性	描述	默认值
druid.request.logging.feed	请求的 Feed 名称。	无

SLF4J 请求日志记录

slf4j 请求记录器使用 SLF4J 记录每个请求。无论 SLF4J 格式规范如何，它都会将原生查询序列化为日志消息中的 JSON。请求记录在 org.apache.druid.server.log.LoggingRequestLogger 类下。

属性	描述	默认值
druid.request.logging.setMDC	如果您想在日志条目中设置 MDC 条目，请将此值设置为 true。您的日志系统必须配置为支持 MDC，以便格式化此数据。	false
druid.request.logging.setContextMDC	设置为 "true" 可将 Druid 查询 context 添加到 MDC 条目中。仅当 setMDC 为 true 时适用。	false

对于原生查询，当 setMDC 为 true 时，会填充以下 MDC 字段：

MDC 字段	描述
queryId	查询 ID
sqlQueryId	如果此查询是 SQL 请求的一部分，则为 SQL 查询 ID
dataSource	查询针对的数据源
queryType	查询类型
hasFilters	如果查询有任何过滤器
remoteAddr	请求客户端的远程地址
duration	查询间隔的持续时间
resultOrdering	结果的排序
descending	如果查询是降序查询

过滤后的请求日志记录

filtered 请求记录器根据查询类型或查询完成所需的时间来过滤请求。对于原生查询，记录器仅在 query/time 指标超过 queryTimeThresholdMs 中提供的阈值时才记录请求。对于 SQL 查询，它仅在 sqlQuery/time 指标超过 sqlQueryTimeThresholdMs 中提供的阈值时才记录请求。有关查询指标的更多详细信息，请参阅 指标。

达到阈值的请求将使用 druid.request.logging.delegate.type 中设置的请求记录器类型进行记录。

属性	描述	默认值
druid.request.logging.queryTimeThresholdMs	query/time 指标的阈值（以毫秒为单位）。	0，即不过滤
druid.request.logging.sqlQueryTimeThresholdMs	sqlQuery/time 指标的阈值（以毫秒为单位）。	0，即不过滤
druid.request.logging.mutedQueryTypes	这些类型的查询请求不会被记录。查询类型定义为对应于 Druid 原生 JSON 查询 API 中指定查询的 "queryType" 值的字符串对象。拼写错误的查询类型将被忽略。忽略 scan 和 timeBoundary 查询的示例：["scan", "timeBoundary"]	[]
druid.request.logging.delegate.type	用于记录请求的委托请求记录器类型。	无

组合请求日志记录

composing 请求记录器将请求日志发送到多个请求记录器。

属性	描述	默认值
druid.request.logging.loggerProviders	用于发送请求日志的请求记录器列表。	无

切换请求日志记录

switching 请求记录器将原生查询请求日志路由到一个请求记录器，并将 SQL 查询请求日志路由到另一个请求记录器。

属性	描述	默认值
druid.request.logging.nativeQueryLogger	用于发送原生查询请求日志的请求记录器。	无
druid.request.logging.sqlQueryLogger	用于发送 SQL 查询请求日志的请求记录器。	无

审计日志记录

Coordinator 和 Overlord 会记录对 Lookup、Segment 加载/丢弃规则以及动态配置更改的审计信息。

属性	描述	默认值
druid.audit.manager.type	用于处理审计事件的审计管理器类型。设置为 log 时审计事件会被记录，设置为 sql 时会被持久化到元数据存储中。	sql
druid.audit.manager.logLevel	审计事件的日志级别，可能的值为 DEBUG、INFO、WARN。仅当 druid.audit.manager.type 设置为 log 时才使用此属性。	INFO
druid.audit.manager.auditHistoryMillis	查询审计历史记录的默认持续时间。	1 周
druid.audit.manager.includePayloadAsDimensionInMetric	关于是否在服务指标中添加 payload 列的布尔标志。	false
druid.audit.manager.maxPayloadSizeBytes	存储在 Druid 元数据存储审计表中的审计载荷的最大大小。如果审计载荷的大小超过此值，审计日志将改为存储一条消息，指示已省略该载荷。将 maxPayloadSizeBytes 设置为 -1（默认值）将禁用此检查，这意味着 Druid 将始终存储审计载荷，无论其大小如何。设置为除 -1 之外的任何负数都是无效的。支持人类可读格式，请参阅 此处。	-1
druid.audit.manager.skipNullField	如果为 true，存储在元数据存储中的审计载荷将排除任何具有 null 值的字段。	false

元数据存储 (Metadata storage)

这些属性指定 JDBC 连接以及围绕元数据存储的其他配置。唯一使用这些属性连接到元数据存储的服务是 Coordinator 和 Overlord。

属性	描述	默认值
druid.metadata.storage.type	要使用的元数据存储类型。mysql、postgresql 或 derby 之一。	derby
druid.metadata.storage.connector.connectURI	要连接的数据库的 JDBC URI	无
druid.metadata.storage.connector.user	用于连接的用户名。	无
druid.metadata.storage.connector.password	用于连接的 密码提供程序 或字符串密码。	无
druid.metadata.storage.connector.createTables	如果 Druid 需要一个表但它不存在，是否创建它？	true
druid.metadata.storage.tables.base	表的基础名称。	druid
druid.metadata.storage.tables.dataSource	用于查找由 Kafka 索引服务 创建的数据源的表。	druid_dataSource
druid.metadata.storage.tables.pendingSegments	用于查找待处理 Segment 的表。	druid_pendingSegments
druid.metadata.storage.tables.segments	用于查找 Segment 的表。	druid_segments
druid.metadata.storage.tables.rules	用于查找 Segment 加载/丢弃规则的表。	druid_rules
druid.metadata.storage.tables.config	用于查找配置的表。	druid_config
druid.metadata.storage.tables.indexingStates	存储索引状态载荷和指纹的表。	druid_indexingStates
druid.metadata.storage.tables.tasks	由索引服务用于存储任务。	druid_tasks
druid.metadata.storage.tables.taskLog	由索引服务用于存储任务日志。	druid_tasklogs
druid.metadata.storage.tables.taskLock	由索引服务用于存储任务锁。	druid_tasklocks
druid.metadata.storage.tables.supervisors	由索引服务用于存储 Supervisor 配置。	druid_supervisors
druid.metadata.storage.tables.audit	用于配置更改（例如 Coordinator 规则）的审计历史记录的表。	druid_audit
druid.metadata.storage.tables.useShortIndexNames	是否使用基于 SHA 的唯一索引名称以确保创建所有索引。	false

深度存储 (Deep storage)

这些配置涉及如何从深层存储中推送和拉取 Segment。

属性	描述	默认值
druid.storage.type	要使用的深层存储类型。local、noop、s3、hdfs、c* 之一。	local

本地深层存储

本地深层存储使用本地文件系统。

属性	描述	默认值
druid.storage.storageDirectory	磁盘上用作深层存储的目录。	/tmp/druid/localStorage

Noop 深层存储

此深层存储不执行任何操作。没有配置。

S3 深层存储

此深层存储用于与 Amazon S3 交互。注意必须加载 druid-s3-extensions 扩展。下表显示了一些重要的 S3 配置。有关完整配置，请参阅 S3 深层存储。

属性	描述	默认值
druid.storage.bucket	S3 存储桶名称。	无
druid.storage.baseKey	用于存储的 S3 对象键前缀。	无
druid.storage.disableAcl	ACL 的布尔标志。如果设置为 false，则存储桶所有者将被授予完全控制权。这可能需要设置额外的权限。请参阅 S3 权限设置。	false
druid.storage.archiveBucket	运行 存档任务 时用于存档的 S3 存储桶名称。	无
druid.storage.archiveBaseKey	用于存档的 S3 对象键前缀。	无
druid.storage.sse.type	服务器端加密类型。应为 s3、kms 和 custom 之一。有关更多详细信息，请参阅下面的 服务器端加密部分。	无
druid.storage.sse.kms.keyId	AWS KMS 密钥 ID。仅当 druid.storage.sse.type 为 kms 时才使用，可以留空以使用默认密钥 ID。	无
druid.storage.sse.custom.base64EncodedKey	Base64 编码的密钥。如果 druid.storage.sse.type 为 custom，则应指定此项。	无

HDFS 深层存储

此深层存储用于与 HDFS 交互。必须加载 druid-hdfs-storage 扩展。

属性	描述	默认值
druid.storage.storageDirectory	用作深层存储的 HDFS 目录。	无
druid.storage.compressionFormat	应用于上传到 HDFS 的 Segment 的压缩格式。仅支持 zip 和 lz4。	zip

Cassandra 深层存储

此深层存储用于与 Cassandra 交互。必须加载 druid-cassandra-storage 扩展。

属性	描述	默认值
druid.storage.host	Cassandra 主机。	无
druid.storage.keyspace	Cassandra 键空间。	无

集中式数据源架构（实验性）

这是一项 实验性功能，旨在通过将 Segment 架构持久化到元数据存储并在 Coordinator 上对其进行缓存来改进数据源架构管理。传统上，Broker 向数据节点和任务发出 Segment 元数据查询以获取所有可用 Segment 的架构。然后，每个 Broker 通过组合该数据源的所有 Segment 的架构来单独构建数据源的架构。这种机制是冗余的且容易出错，因为没有单一的架构事实来源。

集中式架构管理通过以下方式改进了此设计：

• 任务将 Segment 架构以及 Segment 元数据发布到数据库。
• 任务定期向 Coordinator 通告实时 Segment 的架构。
• Coordinator 缓存 Segment 架构并为每个数据源构建组合架构。
• Broker 轮询缓存在 Coordinator 上的数据源架构，而不是自己构建它。
• 如果 Broker 无法从 Coordinator 获取架构，它们仍然保留构建数据源架构的能力。

属性	描述	默认值	是否必须
druid.centralizedDatasourceSchema.enabled	用于在 Coordinator 上启用数据源架构构建和缓存的布尔标志。此属性应在通用运行时属性中指定。	false	否。
druid.indexer.fork.property.druid.centralizedDatasourceSchema.enabled	启用 CentralizedDatasourceSchema 功能时应设置此配置。应在 Middle Manager 运行时属性中指定此项。	false	否。

如果您启用此功能，则可以查询仅存储在深层存储中且未加载到 Historical 上的数据源。有关更多信息，请参阅 从深层存储查询。

有关陈旧架构清理配置，请参考 元数据管理 中前缀为 druid.coordinator.kill.segmentSchema 的属性。

摄取安全性配置

HDFS 输入源

您可以设置以下属性来指定 HDFS 输入源 的允许协议。

属性	可能的值	描述	默认值
druid.ingestion.hdfs.allowedProtocols	协议列表	HDFS 输入源的允许协议。	["hdfs"]

HTTP 输入源

您可以设置以下属性来指定 HTTP 输入源 的允许协议。

属性	可能的值	描述	默认值
druid.ingestion.http.allowedProtocols	协议列表	HTTP 输入源的允许协议。	["http", "https"]
druid.ingestion.http.allowedHeaders	HTTP 输入源的允许请求头列表。默认情况下，列表为空，这意味着摄取规范中不允许任何请求头。	[]

外部数据访问安全配置

外部数据库的 JDBC 连接

您可以使用以下属性来指定以下内容的允许 JDBC 选项：

• SQL 输入源
• 全局缓存的 JDBC Lookup
• 用于每个 Lookup 缓存的 JDBC 数据获取器.

这些属性不适用于元数据存储连接。

属性	可能的值	描述	默认值
druid.access.jdbc.enforceAllowedProperties	布尔值	为 true 时，Druid 将 druid.access.jdbc.allowedProperties 应用于以 jdbc:postgresql:、jdbc:mysql: 或 jdbc:mariadb: 开头的 JDBC 连接。为 false 时，Druid 允许任何类型的 JDBC 连接而不进行 JDBC 属性验证。此配置用于向后兼容性，特别是在升级期间，因为强制执行允许列表可能会破坏现有的摄取作业或基于 JDBC 的 Lookup。此配置已弃用，将在未来的版本中删除。	true
druid.access.jdbc.allowedProperties	JDBC 属性列表	定义允许的 JDBC 属性列表。如果 druid.access.jdbc.enforceAllowedProperties 设置为 true，则 Druid 始终会对所有以 jdbc:postgresql:、jdbc:mysql: 和 jdbc:mariadb: 开头的 JDBC 连接强制执行此列表。 此选项已针对 MySQL 连接器 8.2.0、MariaDB 连接器 2.7.4 和 PostgreSQL 连接器 42.2.14 进行了测试。其他连接器版本可能无法工作。	["useSSL", "requireSSL", "ssl", "sslmode"]
druid.access.jdbc.allowUnknownJdbcUrlFormat	布尔值	为 false 时，Druid 仅接受以 jdbc:postgresql: 或 jdbc:mysql: 开头的 JDBC 连接。为 true 时，Druid 允许到任何类型数据库的 JDBC 连接，但仅对 PostgreSQL 和 MySQL/MariaDB 强制执行 druid.access.jdbc.allowedProperties。	true

任务日志记录

您可以使用 druid.indexer 配置为任务日志文件设置 长期存储 位置，并设置 保留策略。

有关摄取任务和服务生成日志的更多信息，请参阅 任务参考。

日志长期存储

属性	描述	默认值
druid.indexer.logs.type	任务日志的存储位置。noop、s3、azure、google、hdfs、file	file

文件任务日志

将任务日志存储在本地文件系统中。

属性	描述	默认值
druid.indexer.logs.directory	本地文件系统路径。	log

S3 任务日志

将任务日志存储在 S3 中。注意必须加载 druid-s3-extensions 扩展。

属性	描述	默认值
druid.indexer.logs.s3Bucket	S3 存储桶名称。	无
druid.indexer.logs.s3Prefix	S3 键前缀。	无
druid.indexer.logs.disableAcl	ACL 的布尔标志。如果设置为 false，则存储桶所有者将被授予完全控制权。如果任务日志存储桶与深层存储 (S3) 存储桶相同，则如果已将 druid.storage.disableAcl 设置为 true，则需要将此属性的值设置为 true。	false

Azure Blob Store 任务日志

将任务日志存储在 Azure Blob Store 中。要启用此功能，请加载 druid-azure-extensions 扩展，并配置 Azure 深层存储。Druid 使用为深层存储配置的相同身份验证方法，并将任务日志存储在同一个存储账户中（在 druid.azure.account 中设置）。

属性	描述	默认值
druid.indexer.logs.container	要将日志写入到的 Azure Blob Store 容器。	必须设置。
druid.indexer.logs.prefix	要添加到日志前面的路径。	必须设置。

Google Cloud Storage 任务日志

将任务日志存储在 Google Cloud Storage 中。

注意：必须加载 druid-google-extensions 扩展，并且此功能使用与 Google 深层存储模块相同的存储设置。

属性	描述	默认值
druid.indexer.logs.bucket	要将日志写入到的 Google Cloud Storage 存储桶	无
druid.indexer.logs.prefix	要添加到日志前面的路径	无

HDFS 任务日志

将任务日志存储在 HDFS 中。注意必须加载 druid-hdfs-storage 扩展。

属性	描述	默认值
druid.indexer.logs.directory	用于存储日志的目录。	无

日志保留策略

属性	描述	默认值
druid.indexer.logs.kill.enabled	关于是否启用删除旧任务日志的布尔值。如果设置为 true，Overlord 将根据指定的 druid.indexer.logs.kill.delay 定期提交 kill 任务，这将从日志目录中删除任务日志，并删除元数据存储中除最后 druid.indexer.logs.kill.durationToRetain 期间创建的任务之外的任务和 tasklogs 表条目。	false
druid.indexer.logs.kill.durationToRetain	如果启用了 kill，则为必需。以毫秒为单位，表示保留最近 x 毫秒内创建的任务日志和任务相关元数据存储表中的条目。	无
druid.indexer.logs.kill.initialDelay	可选。Overlord 启动后运行第一次自动 kill 的毫秒数。	小于 300000 (5 分钟) 的随机值
druid.indexer.logs.kill.delay	可选。自动 kill 运行连续执行之间的延迟毫秒数。	21600000 (6 小时)

API 错误响应

您可以配置 Druid API 错误响应，以隐藏 Druid 类名、堆栈跟踪、线程名、Servlet 名、代码、行/列号、主机或 IP 地址等内部信息。

属性	描述	默认值
druid.server.http.showDetailedJettyErrors	设置为 true 时，来自 Jetty 层 / Jetty 过滤器的任何错误都会在 JSON 响应中包含以下字段（如果存在）：servlet、message、url、status 和 cause。设置为 false 时，JSON 响应仅包含 message、url 和 status。字段值保持不变。	true
druid.server.http.errorResponseTransform.strategy	错误响应转换策略。该策略控制 Druid 如何转换来自 Druid 服务的错误响应。当未设置或设置为 none 时，Druid 不会更改错误响应。	无

错误响应转换策略

您可以使用错误响应转换策略来转换来自 Druid 服务的错误响应，以隐藏内部信息。当您指定除 none 之外的错误响应转换策略时，Druid 将按以下方式转换来自 Druid 服务的错误响应：

• 对于 Router 服务中失败的任何查询 API，Druid 将 errorClass 和 host 字段设置为 null。Druid 将转换策略应用于 errorMessage 字段。
• 对于失败的任何 SQL 查询 API（例如 POST /druid/v2/sql/...），Druid 将 errorClass 和 host 字段设置为 null。Druid 将转换策略应用于 errorMessage 字段。
• 对于任何 JDBC 相关异常，Druid 会将所有已检查异常转换为 QueryInterruptedException，否则 Druid 将尝试保持异常为相同类型。例如，如果原始异常不属于 Druid，它将变为 QueryInterruptedException。Druid 将转换策略应用于 errorMessage 字段。

无错误响应转换策略

在此模式下，Druid 不会更改来自底层服务的错误响应，并将未更改的错误返回给 API 客户端。这是默认的 Druid 错误响应模式。要显式启用此策略，请将 druid.server.http.errorResponseTransform.strategy 设置为 none。

允许正则表达式错误响应转换策略

在此模式下，Druid 根据正则表达式列表验证来自底层服务的错误响应。仅返回匹配配置的正则表达式的错误消息。要启用此策略，请将 druid.server.http.errorResponseTransform.strategy 设置为 allowedRegex。

属性	描述	默认值
druid.server.http.errorResponseTransform.allowedRegex	Druid 用于验证错误消息的正则表达式列表。如果错误消息匹配任何正则表达式，则 Druid 会将其原样包含在响应中。如果错误消息不匹配任何正则表达式，Druid 会根据底层 Exception 的类型将错误消息替换为 null 或默认消息。	[]

例如，考虑以下错误响应：

{"error":"Plan validation failed","errorMessage":"org.apache.calcite.runtime.CalciteContextException: From line 1, column 15 to line 1, column 38: Object 'nonexistent-datasource' not found","errorClass":"org.apache.calcite.tools.ValidationException","host":null}

如果 druid.server.http.errorResponseTransform.allowedRegex 设置为 []，Druid 会将查询错误响应转换为：

{"error":"Plan validation failed","errorMessage":null,"errorClass":null,"host":null}

另一方面，如果 druid.server.http.errorResponseTransform.allowedRegex 设置为 [".*CalciteContextException.*"]，则 Druid 会将查询错误响应转换为：

{"error":"Plan validation failed","errorMessage":"org.apache.calcite.runtime.CalciteContextException: From line 1, column 15 to line 1, column 38: Object 'nonexistent-datasource' not found","errorClass":null,"host":null}

基于角色的错误响应转换策略

在此模式下，Druid 会转换任何针对非用户角色的异常。该策略不直接返回此类异常，而是针对一个随机 ID 记录异常，并将该 ID 连同通用的错误消息返回给用户。

要启用此策略，请将 druid.server.http.errorResponseTransform.strategy 设置为 persona。

Overlord 发现

此配置用于使用 Curator 服务发现来查找 Overlord。仅在您实际运行 Overlord 时才需要。

属性	描述	默认值
druid.selectors.indexing.serviceName	Overlord 服务的 druid.service 名称。要以不同的名称启动 Overlord，请使用此属性进行设置。	druid/overlord

Coordinator 发现

此配置用于使用 Curator 服务发现来查找 Coordinator。此配置由实时索引服务使用，以获取有关集群中加载的 Segment 的信息。

属性	描述	默认值
druid.selectors.coordinator.serviceName	Coordinator 服务的 druid.service 名称。要以不同的名称启动 Coordinator，请使用此属性进行设置。	druid/coordinator

通告 Segment

您可以配置如何在 ZooKeeper 中通告和取消通告 Znode（使用 Curator）。对于正常操作，您不需要覆盖任何这些配置。

批量数据 Segment 通告程序

在当前的 Druid 中，多个数据 Segment 可以在同一个 Znode 下通告。

属性	描述	默认值
druid.announcer.segmentsPerNode	每个 Znode 最多包含此数量的 Segment 的信息。	50
druid.announcer.maxBytesPerNode	Znode 的最大字节大小。允许范围是 [1024, 1048576]。	524288
druid.announcer.skipDimensionsAndMetrics	从 Segment 通告中跳过 Dimensions 和 Metrics 列表。注意：启用此功能还将从 Coordinator 和 Broker 端点中删除维度和指标列表。	false
druid.announcer.skipLoadSpec	从 Segment 通告中跳过 Segment LoadSpec。注意：启用此功能还将从 Coordinator 和 Broker 端点中删除 loadspec。	false

如果您想关闭批量数据 Segment 通告程序，可以添加一个属性来跳过通告 Segment。如果任何服务使用 batch 作为 druid.serverview.type，则不要启用此配置

属性	描述	默认值
druid.announcer.skipSegmentAnnouncementOnZk	跳过在 ZooKeeper 上通告 Segment。请注意，如果设置为 true，批量服务器视图将无法工作。	false

JavaScript

Druid 支持通过 JavaScript 函数进行动态运行时扩展。此功能可以通过以下属性进行配置。

属性	描述	默认值
druid.javascript.enabled	设置为 "true" 以启用 JavaScript 功能。这会影响 JavaScript 过滤器、extractionFn、聚合器、后聚合器、路由器策略和工作选择策略。	false

信息

基于 JavaScript 的功能默认是禁用的。请参阅 Druid JavaScript 编程指南，了解关于使用 Druid JavaScript 功能的指南，包括如何启用它的说明。

Double 列存储

在 0.13.0 版本之前，Druid 的存储层在索引时使用 32 位浮点表示来存储由 doubleSum、doubleMin 和 doubleMax 聚合器创建的列。从 0.13.0 版本开始，Double 列的默认值将是 64 位浮点数。为 Double 列使用 64 位表示将避免精度损失，但代价是此类列的存储大小增加一倍。要保持旧格式，请设置系统范围的属性 druid.indexing.doubleStorage=float。您还可以使用 floatSum、floatMin 和 floatMax 来使用 32 位浮点表示。64 位浮点列的支持是在 Druid 0.11.0 中发布的，因此如果您使用此功能，旧版本的 Druid 将无法读取您的数据 Segment。

属性	描述	默认值
druid.indexing.doubleStorage	设置为 "float" 以对 Double 列使用 32 位双精度浮点表示。	double

HTTP 客户端

所有 Druid 组件都可以通过 HTTP 相互通信。

属性	描述	默认值
druid.global.http.numConnections	每个目标 URL 的连接池大小。如果 HTTP 请求数超过此数字且都需要与同一 URL 通信，则它们将排队等待。	20
druid.global.http.eagerInitialization	指示应提前初始化 HTTP 连接。如果设置为 true，则在初始化时创建 numConnections 个连接。	false
druid.global.http.compressionCodec	与其他组件通信的压缩编解码器。可以是 "gzip" 或 "identity"。	gzip
druid.global.http.readTimeout	数据读取的超时时间。	PT15M
druid.global.http.unusedConnectionTimeout	连接池中空闲连接的超时时间。池中的连接将在超过此超时时间后关闭，并建立一个新的连接。此超时应小于 druid.global.http.readTimeout。将此超时设置为 druid.global.http.readTimeout 的 ~90%	PT4M
druid.global.http.numMaxThreads	I/O 工作线程的最大数量	(核心数) * 3 / 2 + 1
druid.global.http.clientConnectTimeout	建立客户端连接的超时时间（以毫秒为单位）。	500

通用端点配置

本节包含所有服务支持的端点的配置选项。

属性	描述	默认值
druid.server.hiddenProperties	如果属性名称或属性名称的子字符串（不区分大小写）在此列表中，则 /status/properties 端点的响应将不显示这些属性。	["druid.s3.accessKey","druid.s3.secretKey","druid.metadata.storage.connector.password", "password", "key", "token", "pwd"]

Master 服务器

本节包含位于主服务器（Coordinator 和 Overlord）上的服务的配置选项，该配置位于建议的 三服务器配置 中。

Coordinator

有关 Coordinator 服务的一般信息，请参阅 Coordinator 服务。

静态配置

这些 Coordinator 静态配置可以在 coordinator/runtime.properties 文件中定义。

Coordinator 服务配置

属性	描述	默认值
druid.host	当前服务的主机。这用于发布当前服务位置，使其可以从另一个服务访问，通常应进行指定，以便 http://${druid.host}/ 实际上可以与此服务通信。	InetAddress.getLocalHost().getCanonicalHostName()
druid.bindOnHost	指示服务的内部 jetty 服务器是否绑定到 druid.host。默认值为 false，这意味着绑定到所有接口。	false
druid.plaintextPort	实际监听的端口；除非使用端口映射，否则这将是与 druid.host 上的端口相同的端口。	8081
druid.tlsPort	HTTPS 连接器的 TLS 端口，如果设置了 druid.enableTlsPort，则将使用此配置。如果 druid.host 包含端口，则该端口将被忽略。这应该是一个非负整数。	8281
druid.service	服务的名称。在发出指标和警报时，这用作维度，以区分各种服务。	druid/coordinator
druid.labels	定义服务器自定义标签的键值对的可选 JSON 对象。这些标签显示在 Web 控制台的“服务”选项卡下。示例：druid.labels={"location":"Airtrunk"} 或 druid.labels.location=Airtrunk	null

Coordinator 操作

属性	描述	默认值
druid.coordinator.period	Coordinator 的运行周期。Coordinator 通过在内存中维护当前世界状态并定期查看“已使用”Segment 和正在服务的 Segment 集合来运行，以决定是否需要对数据拓扑进行任何更改。此属性设置每次运行之间的延迟。	PT60S
druid.coordinator.startDelay	Coordinator 的运行假设它在运行时拥有世界状态的最新视图，但是当前的 ZooKeeper 交互代码编写方式不允许 Coordinator 确实知道它已完成加载当前状态。此延迟是一个权宜之计，旨在给它足够的时间以相信它拥有所有数据。	PT300S
druid.coordinator.load.timeout	Coordinator 将 Segment 分配给 Historical 服务时的超时持续时间。	PT15M
druid.coordinator.balancer.strategy	Coordinator 用于在层内的 Historical 服务器之间分配 Segment 的 负载均衡策略。cost 策略通过最小化成本函数来分配 Segment，diskNormalized 使用服务器的磁盘使用率对这些成本进行加权，而 random 则随机分配 Segment。	cost
druid.coordinator.loadqueuepeon.http.repeatDelay	负载队列 peon 的启动和重复延迟（以毫秒为单位），它管理任何服务器的 Segment 加载/丢弃队列。	1 分钟
druid.coordinator.loadqueuepeon.http.batchSize	在一个 HTTP 请求中批量处理的 Segment 加载/丢弃请求数量。请注意，它必须小于或等于 Historical 服务上的 druid.segmentCache.numLoadingThreads 配置。如果未配置此值，Coordinator 将使用相应服务器的 numLoadingThreads 的值。	druid.segmentCache.numLoadingThreads
druid.coordinator.asOverlord.enabled	关于此 Coordinator 服务是否也应充当 Overlord 的布尔值。此配置允许用户通过不必部署任何独立的 Overlord 服务来简化 Druid 集群。如果设置为 true，则 Overlord 控制台可在 http://coordinator-host:port/console.html 获取，并确保也设置 druid.coordinator.asOverlord.overlordService。	false
druid.coordinator.asOverlord.overlordService	必需，如果 druid.coordinator.asOverlord.enabled 为 true。此值必须与独立 Overlord 服务上的 druid.service 以及 Middle Manager 上的 druid.selectors.indexing.serviceName 的值相同。	NULL

数据管理

属性	描述	默认值
druid.coordinator.period.indexingPeriod	Coordinator 运行数据管理任务（包括启动压缩任务和清理未使用数据）的周期。建议将此值设置为大于 druid.manager.segments.pollDuration。	PT1800S (30 分钟)
druid.coordinator.kill.pendingSegments.on	布尔标志，用于决定 Coordinator 是否清理元数据存储中 pendingSegments 表里的旧条目。如果设置为 true，Coordinator 将检查最近完成任务的创建时间。如果不存在，则查找最早的运行中/待处理/等待任务的创建时间。一旦找到创建时间，对于所有不在 killPendingSegmentsSkipList（参见 动态配置）中的数据源，Coordinator 将要求 Overlord 清理 pendingSegments 表中早于该创建时间 1 天或更长时间的条目。此操作将根据指定的 druid.coordinator.period.indexingPeriod 定期执行。	true
druid.coordinator.kill.on	布尔标志，用于启用 Coordinator 提交针对未使用分片的清理（kill）任务，并将其从元数据存储和深度存储中永久删除。	false
druid.coordinator.kill.period	向索引服务发送清理任务的频率。该值必须大于或等于 druid.coordinator.period.indexingPeriod。仅在启用 kill 功能时适用。	与 druid.coordinator.period.indexingPeriod 相同
druid.coordinator.kill.durationToRetain	ISO 8601 格式的持续时间，相对于当前时间，用于标识要保留的分片的数据间隔。当 druid.coordinator.kill.on 为 true 时，任何数据间隔结束于 now - durationToRetain 之前的分片都有资格被永久删除。例如，如果 durationToRetain 设置为 P90D，则时间间隔结束于 90 天前的未使用分片有资格被删除。如果 durationToRetain 设置为负的 ISO 8601 持续时间，则结束于 now - durationToRetain 之前的未来时间间隔的分片也有资格被删除。	P90D
druid.coordinator.kill.ignoreDurationToRetain	一种覆盖 druid.coordinator.kill.durationToRetain 的方法，告知 Coordinator 在执行清理任务时无需考虑未使用分片间隔的结束日期。如果为 true，Coordinator 会将所有未使用分片视为可被清理的对象。	false
druid.coordinator.kill.bufferPeriod	分片在能够从元数据和深度存储中永久删除之前必须保持未使用状态的时间长度。这可以作为一个缓冲期，防止在分片被标记为未使用后又被需要而导致数据丢失。	P30D
druid.coordinator.kill.maxSegments	每个清理任务要清理的未使用分片的最大数量。此数字必须大于 0。仅在 druid.coordinator.kill.on=true 时适用。	100
druid.coordinator.kill.maxInterval	每个清理任务可删除分片的最大间隔（以 ISO 8601 持续时间表示）。设置为零（例如 PT0S）则表示无限制。仅在 druid.coordinator.kill.on=true 时适用。	P30D

元数据管理

属性	描述	是否必须	默认值
druid.coordinator.period.metadataStoreManagementPeriod	运行元数据管理任务的频率，格式为 ISO 8601 持续时间。	否	PT1H
druid.coordinator.kill.supervisor.on	布尔值，用于决定是否启用已终止监督器（supervisor）的自动删除。如果设置为 true，Coordinator 将定期从元数据存储的 supervisor 表中移除已终止的监督器。	否	true
druid.coordinator.kill.supervisor.period	自动删除已终止监督器的频率，格式为 ISO 8601 持续时间。该值必须大于或等于 druid.coordinator.period.metadataStoreManagementPeriod。仅在 druid.coordinator.kill.supervisor.on 设置为 true 时适用。	否	P1D
druid.coordinator.kill.supervisor.durationToRetain	自创建时间起保留已终止监督器的时长，格式为 ISO 8601 持续时间。仅在 druid.coordinator.kill.supervisor.on 设置为 true 时适用。	如果 druid.coordinator.kill.supervisor.on 设置为 true，则为 Yes。	P90D
druid.coordinator.kill.audit.on	布尔值，用于决定是否启用审计日志的自动删除。如果设置为 true，Coordinator 将定期从元数据存储的审计表条目中移除审计日志。	否	True
druid.coordinator.kill.audit.period	自动删除审计日志的频率，格式为 ISO 8601 持续时间。该值必须大于或等于 druid.coordinator.period.metadataStoreManagementPeriod。仅在 druid.coordinator.kill.audit.on 设置为 true 时适用。	否	P1D
druid.coordinator.kill.audit.durationToRetain	自创建时间起保留审计日志的时长，格式为 ISO 8601 持续时间。仅在 druid.coordinator.kill.audit.on 设置为 true 时适用。	如果 druid.coordinator.kill.audit.on 设置为 true，则为 Yes。	P90D
druid.coordinator.kill.compaction.on	布尔值，用于决定是否启用压缩配置的自动删除。如果设置为 true，Coordinator 将定期从元数据存储的配置表中移除无效数据源（即没有已使用和未使用分片的数据源）的压缩配置。	否	True
druid.coordinator.kill.compaction.period	自动删除压缩配置的频率，格式为 ISO 8601 持续时间。该值必须大于或等于 druid.coordinator.period.metadataStoreManagementPeriod。仅在 druid.coordinator.kill.compaction.on 设置为 true 时适用。	否	P1D
druid.coordinator.kill.rule.on	布尔值，用于决定是否启用规则（rules）的自动删除。如果设置为 true，Coordinator 将定期从元数据存储的规则表中移除无效数据源（即没有已使用和未使用分片的数据源）的规则。	否	True
druid.coordinator.kill.rule.period	自动删除规则的频率，格式为 ISO 8601 持续时间。该值必须大于或等于 druid.coordinator.period.metadataStoreManagementPeriod。仅在 druid.coordinator.kill.rule.on 设置为 true 时适用。	否	P1D
druid.coordinator.kill.rule.durationToRetain	自创建时间起保留规则的时长，格式为 ISO 8601 持续时间。仅在 druid.coordinator.kill.rule.on 设置为 true 时适用。	如果 druid.coordinator.kill.rule.on 设置为 true，则为 Yes。	P90D
druid.coordinator.kill.datasource.on	布尔值，用于决定是否启用数据源元数据的自动删除（注：数据源元数据仅存在于通过监督器创建的数据源）。如果设置为 true，Coordinator 将定期从元数据存储的数据源表中移除已终止监督器的数据源元数据。	否	True
druid.coordinator.kill.datasource.period	自动删除数据源元数据的频率，格式为 ISO 8601 持续时间。该值必须大于或等于 druid.coordinator.period.metadataStoreManagementPeriod。仅在 druid.coordinator.kill.datasource.on 设置为 true 时适用。	否	P1D
druid.coordinator.kill.datasource.durationToRetain	自创建时间起保留数据源元数据的时长，格式为 ISO 8601 持续时间。仅在 druid.coordinator.kill.datasource.on 设置为 true 时适用。	如果 druid.coordinator.kill.datasource.on 设置为 true，则为 Yes。	P90D
druid.coordinator.kill.segmentSchema.on	布尔值，用于决定是否启用未使用分片模式（segment schema）的自动删除。如果设置为 true，Coordinator 将定期识别未被任何已使用分片引用的分片模式，并将它们标记为未使用。随后，这些未使用的模式会被删除。仅在启用了 集中式数据源模式 功能时适用。	否	True
druid.coordinator.kill.segmentSchema.period	自动删除分片模式的频率，格式为 ISO 8601 持续时间。该值必须大于或等于 druid.coordinator.period.metadataStoreManagementPeriod。仅在 druid.coordinator.kill.segmentSchema.on 设置为 true 时适用。	否	P1D
druid.coordinator.kill.segmentSchema.durationToRetain	自被标记为未使用之日起，分片模式的保留时长，格式为 ISO 8601 持续时间。仅在 druid.coordinator.kill.segmentSchema.on 设置为 true 时适用。	如果 druid.coordinator.kill.segmentSchema.on 设置为 true，则为 Yes。	P90D

分片管理

属性	可能的值	描述	默认值
druid.serverview.type	batch 或 http	使用的分片发现方法。“http” 支持使用 HTTP 而非 ZooKeeper 来发现分片。	http
druid.coordinator.segment.awaitInitializationOnStart	true 或 false	Coordinator 是否在启动前等待其分片视图完全初始化。如果设置为 'true'，Coordinator 的 HTTP 服务器将不会启动，且 Coordinator 不会宣告自己可用，直到服务器视图初始化完成。	true

元数据检索

属性	描述	默认值
druid.manager.config.pollDuration	管理器轮询配置表获取更新的频率。	PT1M
druid.manager.segments.pollDuration	Coordinator 轮询活动分片集更新的时间间隔。通常决定了 Coordinator 感知新分片的延迟时间。	PT1M
druid.manager.segments.useIncrementalCache	表示分片元数据增量缓存的使用模式。该缓存相对于 Coordinator 当前使用的轮询机制提供了性能改进，因为它仅检索已更新分片的有效载荷。可选的缓存模式包括：(a) never：禁用增量缓存。(b) always：启用增量缓存。服务启动将被阻塞，直到缓存至少与元数据存储同步一次。(c) ifSynced：启用缓存。此模式不会阻塞服务启动，并保留了 Coordinator 现有的行为。如果增量缓存处于 always 或 ifSynced 模式，读取缓存的操作将阻塞，直到它在成为 leader 后至少与元数据存储同步一次。Coordinator 永远不会写入此缓存。	ifSynced
druid.manager.rules.pollDuration	Coordinator 轮询活动规则集更新的时间间隔。通常决定了 Coordinator 感知规则的延迟时间。	PT1M
druid.manager.rules.defaultRule	集群的默认规则	_default
druid.manager.rules.alertThreshold	轮询失败后发出告警所需的持续时间。	PT10M

动态配置

Coordinator 具有动态配置，无需重启服务即可即时调整某些行为。您可以使用 Web 控制台（推荐）或通过 Coordinator 动态配置 API 来配置这些参数。

下表显示了 Coordinator 的动态配置属性。

属性	描述	默认值
millisToWaitBeforeDeleting	Coordinator 在能够开始将元数据存储中被覆盖（overshadowed）的分片标记为未使用之前，需要作为 leader 运行多长时间。	900000 (15 分钟)
smartSegmentLoading	启用 “智能”分片加载模式，该模式动态计算多个属性的最优值，从而最大化 Coordinator 性能。	true
maxSegmentsToMove	在任何给定时间内，Historical 层中可移动的最大分片数。	100
replicantLifetime	在 Druid 发出告警之前，分片在 Historical 负载队列中可等待的最大 Coordinator 运行次数。	15
replicationThrottleLimit	在单次 Coordinator 运行中，分配给 Historical 层分片副本的最大数量。此属性可防止 Historical 服务在加载集群中已存在分片的额外副本时被压垮。	500
balancerComputeThreads	用于在分片平衡期间计算分片移动成本的线程池大小。如果您有大量分片且分片移动开始停滞，请考虑增加此值。	num_cores / 2
killDataSourceWhitelist	当 druid.coordinator.kill.on 为 true 时，可为其发出清理任务的特定数据源列表。它可以是逗号分隔的数据源名称列表或 JSON 数组。如果 killDataSourceWhitelist 为空，Coordinator 将为所有数据源发出清理任务。	无
killTaskSlotRatio	清理任务可占用的总可用任务槽位比例（包括自动缩放（如适用））。该值必须介于 0 和 1 之间。仅适用于由 Coordinator 自动生成的自动清理任务，该功能在 druid.coordinator.kill.on 为 true 时启用。	0.1
maxKillTaskSlots	清理任务可占用的最大任务数。此限制仅适用于由 Coordinator 自动生成的自动清理任务，该功能在 druid.coordinator.kill.on 为 true 时启用。	Integer.MAX_VALUE - 无限制
killPendingSegmentsSkipList	如果属性 druid.coordinator.kill.pendingSegments.on 为 true，则此列表中的数据源对应的 PENDING_SEGMENTS 不会被清理。它可以是逗号分隔的数据源列表或 JSON 数组。	无
maxSegmentsInNodeLoadingQueue	任何给定服务器负载队列中允许的最大分片数。使用此参数可以更快地加载分片，例如，如果集群包含加载较慢的节点，或者有太多分片需要复制到特定节点（当优先考虑加载速度而非更好的分片分布时）。最优值取决于分片加载速度、可接受的复制时间和节点数量。	500
useRoundRobinSegmentAssignment	布尔标志，用于决定是否应以轮询方式将分片分配给 Historical 服务。禁用时，使用所选的平衡策略进行分片分配。启用时，这可以加速分片分配，将平衡工作留给后台进程，以惰性方式将分片移动到其最优位置（基于平衡策略）。	true
decommissioningNodes	要停用的 Historical 服务器列表。Coordinator 不会将新分片分配给正在停用的服务器，并且分片会以 maxSegmentsToMove 指定的最大速率从这些服务器上移走，并放置在非停用服务器上。	无
pauseCoordination	布尔标志，决定 Coordinator 是否应执行其协调集群的各项职责。将其设置为 true 实质上会暂停所有协调工作，同时保持 API 可用。暂停的职责包括实现 CoordinatorDuty 接口的所有类。此类职责包括：分片平衡、分片压缩、为未使用分片提交清理任务（如果已启用）、记录集群中已使用的分片、标记新未使用的或被覆盖的分片、匹配和执行已使用分片的加载/丢弃规则、从 Historical 服务器卸载不再标记为已使用的分片。管理员可能想要暂停协调的一个例子是：如果他们正在对 HDFS 名称节点进行停机维护，并且在维护完成且深度存储被再次声明健康之前，不希望 Coordinator 指导 Historical 节点向名称节点发出 API 请求。	false
replicateAfterLoadTimeout	布尔标志，用于决定对于因 druid.coordinator.load.timeout 过期而加载失败的分片，是否需要进行额外的复制。如果设置为 true，Coordinator 将尝试在不同的 Historical 服务器上复制失败的分片。如果集群中存在少量缓慢的 Historical 节点，这有助于提高分片可用性。然而，缓慢的 Historical 节点可能会在稍后加载该分片，如果分片被过度复制，Coordinator 可能会发出丢弃请求。	false
turboLoadingNodes	实验性功能。要置于 turbo 加载模式的 Historical 服务器列表。这些服务器使用更大的线程池来更快地加载分片，但会以查询性能为代价。对于 turboLoadingNodes 中指定的服务器，druid.coordinator.loadqueuepeon.http.batchSize 将被忽略，Coordinator 将改用各自 numLoadingThreads 的值。 请谨慎使用此配置。一旦相应 Historical 上的分片加载完成，应最终将所有服务器从该列表中移除。	无
cloneServers	实验性功能。目标 Historical 服务器到源 Historical 服务器的映射，目标服务器应克隆源服务器。目标 Historical 不参与常规的分片分配或平衡。相反，Coordinator 将对源 Historical 的任何分片分配镜像到目标 Historical，从而使目标成为源的精确副本。目标 Historical 上的分片也不计入副本计数。如果源服务器消失，目标将保持在源服务器最后已知的状态，直到从配置中移除。 请谨慎使用此配置。一旦在相应的 Historical 服务器上达到期望状态，应最终将所有服务器从该列表中移除。	无

智能分片加载

smartSegmentLoading 模式简化了用于分片加载和平衡的 Coordinator 配置。如果启用此模式，请勿为下表中的属性提供值，因为 Coordinator 会自动计算它们。Druid 会根据集群的当前状态计算这些值，以优化 Coordinator 性能。

如果您启用 smartSegmentLoading 模式，Druid 将忽略您为以下属性提供的任何值。

属性	计算值	描述
useRoundRobinSegmentAssignment	true	加速分片分配。
maxSegmentsInNodeLoadingQueue	0	移除负载队列大小限制。
replicationThrottleLimit	已使用分片的 5%，最小值 100	当 Historical 间歇性消失时，防止过度复制。
replicantLifetime	60	允许分片在负载队列中等待约一小时（假设 Coordinator 周期为 1 分钟）后再发出告警。在 smartSegmentLoading 模式下，负载队列不受大小限制。因此，即使相应服务器加载缓慢，分片也可能被分配到负载队列中。
maxSegmentsToMove	已使用分片的 2%，最小值 100，最大值 1000	确保集群中始终有一些分片在移动，以保持良好的平衡。最大值限制了 Coordinator 的运行时间。
balancerComputeThreads	num_cores / 2	确保有足够的线程来执行平衡计算，而不会占用所有 Coordinator 资源。

当 smartSegmentLoading 被禁用时，Druid 会使用这些属性的配置值。仅当您想显式设置上述任何属性的值时，才禁用 smartSegmentLoading。

查找（Lookups）动态配置

这些配置选项控制 Coordinator 查找管理。有关影响查找传播的配置，请参阅 查找的动态配置。

属性	描述	默认值
druid.manager.lookups.hostDeleteTimeout	在将 DELETE 请求视为失败之前，等待特定服务的时长。	PT1S
druid.manager.lookups.hostUpdateTimeout	在将 POST 请求视为失败之前，等待特定服务的时长。	PT10S
druid.manager.lookups.deleteAllTimeout	在将删除尝试视为失败之前，等待所有 DELETE 请求完成的时长。	PT10S
druid.manager.lookups.updateAllTimeout	在将尝试视为失败之前，等待所有 POST 请求完成的时长。	PT60S
druid.manager.lookups.threadPoolSize	可以同时管理多少个服务（并发 POST 和 DELETE 请求）。超出此限制的请求将会在队列中等待，直到有可用槽位。	10
druid.manager.lookups.period	检查配置更改之间的毫秒数。	120000 (2 分钟)

自动压缩动态配置

您可以使用 自动压缩 API 动态设置或更新 自动压缩 属性，而无需重启 Coordinator。

有关分片压缩的详情，请参阅 分片大小优化。

您可以通过以下属性配置自动压缩

属性	描述	是否必须
dataSource	要压缩的数据源名称。	是
taskPriority	压缩任务的 优先级。	无（默认 = 25）
inputSegmentSizeBytes	每个压缩任务处理的分片字节总数最大值。由于时间块（time chunk）必须作为一个整体进行处理，如果特定时间块的分片总大小（以字节为单位）大于此参数，则该时间块的压缩将不会运行。	无（默认 = 100,000,000,000,000，即 100TB）
skipOffsetFromLatest	搜索要压缩的分片时使用的偏移量，格式为 ISO 8601 持续时间。强烈建议为实时数据源设置此项。请参阅 压缩中的数据处理。	无（默认 = "P1D"）
tuningConfig	压缩任务的调优配置。请参阅下文的 自动压缩 tuningConfig。	否
taskContext	压缩任务的 任务上下文。	否
granularitySpec	自定义 granularitySpec。请参阅 自动压缩 granularitySpec。	否
dimensionsSpec	自定义 dimensionsSpec。请参阅 自动压缩 dimensionsSpec。	否
transformSpec	自定义 transformSpec。请参阅 自动压缩 transformSpec。	否
metricsSpec	自定义 metricsSpec。无论是否指定了 metricsSpec，压缩任务都会保留所有现有的指标。如果指定了 metricsSpec，Druid 不会将匹配指标名称的聚合器重新应用于已具有相关指标的行。对于尚未具有 metricsSpec 中指定指标的行，Druid 会在源列上应用指标聚合器，然后照常跨分片合并指标。如果未指定 metricsSpec，Druid 会自动发现现有分片中的指标，并将跨分片具有相同名称的现有指标进行合并。同名指标的聚合器被假定为可以兼容合并，否则压缩任务可能会失败。	否
ioConfig	压缩任务的 IO 配置。请参阅 自动压缩 ioConfig。	否

自动压缩配置示例

{
  "dataSource": "wikiticker",
  "granularitySpec" : {
    "segmentGranularity" : "none"
  }
}

当更高优先级的任务导致 Druid 撤销压缩任务的锁时，压缩任务会失败。默认情况下，像 ingestion 这样的实时任务比压缩任务具有更高的优先级。压缩任务和实时任务之间频繁的冲突可能导致 Coordinator 的自动压缩挂起。您可能会在来自 Kafka 和 Kinesis 的流式摄取中遇到此问题，它们会摄取迟到的数据。

为了缓解这个问题，将 skipOffsetFromLatest 设置为一个足够大的值，使得到达的数据倾向于落在距离当前时间该偏移量值之外。通过这种方式，您可以避免压缩任务和实时摄取任务之间的冲突。例如，如果您想跳过距离最近一个分片结束时间三十天前之前的分片，请指定 "skipOffsetFromLatest": "P30D"。更多信息，请参阅 避免与摄取冲突。

自动压缩 tuningConfig

自动压缩支持 并行任务 tuningConfig 的子集。

下表显示了自动压缩支持的配置。

属性	描述	是否必须
type	任务类型。如果您使用 Coordinator 职责进行自动压缩，请将其设置为 index_parallel。如果您使用压缩监督器，请将其设置为 autocompact。	是
maxRowsInMemory	用于确定何时应发生向磁盘的中间持久化。通常用户不需要设置此项，但根据数据的性质，如果行以字节计很短，用户可能不希望在内存中存储一百万行，此时应设置此值。	无（默认 = 1000000）
maxBytesInMemory	用于确定何时应发生向磁盘的中间持久化。通常这是在内部计算的，用户不需要设置它。此值表示在持久化之前在堆内存中聚合的字节数。这基于对内存使用的粗略估计，而不是实际使用。索引的最大堆内存使用量为 maxBytesInMemory * (2 + maxPendingPersists)	无（默认 = 最大 JVM 内存的 1/6）
splitHintSpec	用于给出一个提示，以控制每个第一阶段任务读取的数据量。根据输入源的实现，此提示可能会被忽略。请参阅 Split hint spec 获取更多详细信息。	无（默认 = 基于大小的拆分提示规范）
partitionsSpec	定义如何在每个时间块中对数据进行分区，请参阅 PartitionsSpec	无（默认 = dynamic）
indexSpec	定义索引时使用的分片存储格式选项，请参阅 IndexSpec	否
indexSpecForIntermediatePersists	定义索引时用于中间持久化临时分片的存储格式选项。这可用于在中间分片上禁用维度/指标压缩，以减少最终合并所需的内存。但是，在中间分片上禁用压缩可能会增加页面缓存使用量，而它们在发布为最终分片之前会被使用，有关可能的值，请参阅 IndexSpec。	否
maxPendingPersists	可以挂起但尚未开始的持久化最大数量。如果通过新的中间持久化超过此限制，摄取将阻塞直到当前运行的持久化完成。索引的最大堆内存使用量与 maxRowsInMemory * (2 + maxPendingPersists) 成比例。	无（默认 = 0，意味着一次持久化可以与摄取同时运行，并且不能有任何排队的持久化）
pushTimeout	等待推送分片的毫秒数。它必须 >= 0，其中 0 表示永久等待。	无（默认 = 0）
segmentWriteOutMediumFactory	创建分片时使用的分片写入介质。请参阅 SegmentWriteOutMediumFactory。	无（默认使用 druid.peon.defaultSegmentWriteOutMediumFactory.type 中的值）
maxNumConcurrentSubTasks	可以同时并行运行的工作任务最大数量。无论当前可用任务槽位如何，监督器任务都会产生最多 maxNumConcurrentSubTasks 个工作任务。如果此值设置为 1，监督器任务会自行处理数据摄取，而不是产生工作任务。如果此值设置得太大，可能会创建太多的工作任务，这可能会阻塞其他摄取。请检查 容量规划 获取更多详细信息。	无（默认 = 1）
maxRetry	任务失败时的最大重试次数。	无（默认 = 3）
maxNumSegmentsToMerge	单个任务在第二阶段可以同时合并的分片数量最大限制。仅与 hashed 或 single_dim partitionsSpec 一起使用。	无（默认 = 100）
totalNumMergeTasks	当 partitionsSpec 设置为 hashed 或 single_dim 时，在合并阶段合并分片的任务总数。	无（默认 = 10）
taskStatusCheckPeriodMs	检查运行中任务状态的轮询周期（以毫秒为单位）。	无（默认 = 1000）
chatHandlerTimeout	工作任务中报告已推送分片的超时时间。	无（默认 = PT10S）
chatHandlerNumRetries	工作任务中报告已推送分片的重试次数。	无（默认 = 5）
engine	压缩引擎。可以是 native 或 msq。msq 使用 MSQ 任务引擎，仅在 压缩监督器 下受支持。	无（默认 = native）

自动压缩 granularitySpec

字段	描述	是否必须
segmentGranularity	分片粒度的时间块周期。默认为 'null'，保留原始分片粒度。接受所有 查询粒度 值。	否
queryGranularity	每个分片内时间戳存储的分辨率。默认为 'null'，保留原始查询粒度。接受所有 查询粒度 值。	否
rollup	是否启用摄取时汇总（rollup）。默认为 null，保留原始设置。请注意，一旦数据经过汇总，单个记录将无法恢复。	否

自动压缩 dimensionsSpec

字段	描述	是否必须
dimensions	维度名称或对象的列表。默认为 null，保留原始维度。请注意，设置此项将导致使用 dimensionExclusions 手动压缩的分片再次被压缩。	否

自动压缩 transformSpec

字段	描述	是否必须
filter	在压缩期间有条件地过滤输入行。只有通过过滤器的行才会被包含在压缩后的分片中。可以使用 Druid 的任何标准 查询过滤器。默认为 null，即不过滤任何行。	否

自动压缩 ioConfig

自动压缩支持 并行任务 ioConfig 的子集。以下是自动压缩支持的配置列表。

属性	描述	默认值	是否必须
dropExisting	如果 true，当任务发布新分片和墓碑（tombstones）时，压缩任务会替换完全包含在压缩分片覆盖时间间隔内的所有现有分片。如果压缩失败，Druid 不会发布任何分片或墓碑。警告：此功能仍处于 Beta 阶段。请注意，更改此配置不会导致时间间隔再次被压缩。	false	否

Overlord

有关 Overlord 服务的常规信息，请参阅 Overlord。

Overlord 静态配置

这些 Overlord 静态配置可以在 overlord/runtime.properties 文件中定义。

Overlord 服务配置

属性	描述	默认值
druid.host	当前服务的主机。这用于发布当前服务位置，使其可以从另一个服务访问，通常应进行指定，以便 http://${druid.host}/ 实际上可以与此服务通信。	InetAddress.getLocalHost().getCanonicalHostName()
druid.bindOnHost	指示服务的内部 jetty 服务器是否绑定到 druid.host。默认值为 false，这意味着绑定到所有接口。	false
druid.plaintextPort	这是实际监听的端口；除非使用端口映射，否则这将与 druid.host 上的端口相同。	8090
druid.tlsPort	HTTPS 连接器的 TLS 端口，如果设置了 druid.enableTlsPort，则将使用此配置。如果 druid.host 包含端口，则该端口将被忽略。这应该是一个非负整数。	8290
druid.service	服务的名称。在发出指标和警报时，这用作维度，以区分各种服务。	druid/overlord
druid.labels	定义服务器自定义标签的键值对的可选 JSON 对象。这些标签显示在 Web 控制台的“服务”选项卡下。示例：druid.labels={"location":"Airtrunk"} 或 druid.labels.location=Airtrunk	null

Overlord 操作

属性	描述	默认值
druid.indexer.runner.type	指示任务应使用 local 在本地运行，还是使用 remote 在分布式环境中运行。推荐的选项是 httpRemote，它类似于 remote，但使用 HTTP 与 Middle Managers 交互，而不是 ZooKeeper。	httpRemote
druid.indexer.server.maxConcurrentActions	Overlord 将同时处理的最大并发操作请求数（例如获取锁、创建分片、获取分片等）。这可以防止线程耗尽，同时保留对健康检查端点的访问。设置为 0 可完全禁用服务质量过滤。如果未指定，默认值为 max(1, max(serverHttpNumThreads - 4, serverHttpNumThreads * 0.8))。	max(1, max(serverHttpNumThreads - 4, serverHttpNumThreads * 0.8))
druid.indexer.storage.type	指示传入的任务应存储在本地（堆中）还是元数据存储中。local 或 metadata 之一。local 主要用于内部测试，而在生产环境中推荐使用 metadata，因为将传入的任务存储在元数据存储中允许在 Overlord 失败时恢复任务。	local
druid.indexer.storage.recentlyFinishedThreshold	存储任务结果的时长。默认为 24 小时。如果您一天内运行数百个任务，请考虑增加此阈值。	PT24H
druid.indexer.tasklock.forceTimeChunkLock	如果设置为 true，则强制所有任务使用时间块锁。如果未设置，每个任务会自动选择要使用的锁类型，并且可能会选择已弃用的分片锁。可以通过在 任务上下文 中设置 forceTimeChunkLock 来覆盖此配置。有关任务锁定的更多详细信息，请参阅 任务锁系统。	true
druid.indexer.tasklock.batchSegmentAllocation	如果设置为 true，Druid 会批量执行分片分配操作，以提高吞吐量并减少平均 task/action/run/time。有关详细信息，请参阅 批量处理 segmentAllocate 操作。	true
druid.indexer.tasklock.batchAllocationWaitTime	Druid 将第一个分片分配操作添加到批次后，直到执行该批次之前的毫秒数。允许批次添加更多请求并提高平均分片分配运行时间。仅当启用了 batchSegmentAllocation 时，此配置才生效。	0
druid.indexer.tasklock.batchAllocationNumThreads	用于批量分片分配的工作线程数。这表示可以为不同数据源并行处理的最大分配批次数量。单个数据源的批次始终顺序处理。仅当启用了 batchSegmentAllocation 时，此配置才生效。	5
druid.indexer.task.default.context	应用于提交到 Overlord 的所有任务的默认任务上下文。此配置中的任何默认值都不会覆盖用户提供的上下文值，也不会覆盖 druid.indexer.tasklock.forceTimeChunkLock。	空上下文
druid.indexer.queue.maxSize	一次活动任务的最大数量。	Integer.MAX_VALUE
druid.indexer.queue.startDelay	在启动 Overlord 队列管理之前休眠此时间。这对于给集群时间进行重定向非常有用（例如，在广泛的网络问题之后）。	PT1M
druid.indexer.queue.restartDelay	当 Overlord 队列管理抛出异常时，休眠此时间后再尝试。	PT30S
druid.indexer.queue.storageSyncRate	以该频率与底层任务持久化机制同步 Overlord 状态。	PT1M
druid.indexer.queue.maxTaskPayloadSize	Overlord 接受的单个任务载荷允许的最大大小（字节）。	无（允许所有任务载荷大小）

以下配置仅在 Overlord 以远程模式运行时适用。有关本地模式与远程模式的描述，请参阅 Overlord 服务。

属性	描述	默认值
druid.indexer.runner.taskAssignmentTimeout	在任务分配给 Middle Manager 后，抛出错误之前等待的时长。	PT5M
druid.indexer.runner.minWorkerVersion	向其发送任务的最低 Middle Manager 版本。版本号是一个字符串。这会影响在某些操作（如与 druid.worker.version 进行比较）期间的预期行为。具体而言，版本比较遵循字典顺序。使用 ISO8601 日期格式作为版本以适应日期比较。	"0"
druid.indexer.runner.parallelIndexTaskSlotRatio	每个 worker 可用于并行索引监督器任务的任务槽比例。指定的值必须在范围 [0, 1] 内。	1
druid.indexer.runner.compressZnodes	指示 Overlord 是否应期望 Middle Managers 压缩 Znodes。	true
druid.indexer.runner.maxZnodeBytes	ZooKeeper 中可创建的最大 Znode 大小（字节），应在范围 [10KiB, 2GiB) 内。支持 人类可读格式。	512 KiB
druid.indexer.runner.taskCleanupTimeout	Middle Manager 从 ZooKeeper 断开连接后，等待任务失败的时长。	PT15M
druid.indexer.runner.taskShutdownLinkTimeout	在关闭请求超时之前，等待 Middle Manager 的时长	PT1M
druid.indexer.runner.pendingTasksRunnerNumThreads	将待处理任务分配给 workers 的线程数，必须至少为 1。	1
druid.indexer.runner.maxRetriesBeforeBlacklist	Middle Manager 在被加入黑名单之前可以连续失败任务的次数，必须至少为 1	5
druid.indexer.runner.workerBlackListBackoffTime	任务再次被白名单化之前等待的时长。此值应大于为 taskBlackListCleanupPeriod 设置的值。	PT15M
druid.indexer.runner.workerBlackListCleanupPeriod	清除线程启动以清理被加入黑名单的 workers 之后的持续时间。	PT5M
druid.indexer.runner.maxPercentageBlacklistWorkers	被加入黑名单的 workers 的最大百分比，必须介于 0 和 100 之间。	20

如果启用了自动缩放，您可以设置这些额外的配置

属性	描述	默认值
druid.indexer.autoscale.strategy	设置需要自动缩放时运行的策略。noop、ec2 或 gce 之一。	noop
druid.indexer.autoscale.doAutoscale	如果设置为 true，将启用自动缩放。	false
druid.indexer.autoscale.provisionPeriod	检查是否应添加新 Middle Managers 的频率。	PT1M
druid.indexer.autoscale.terminatePeriod	检查何时应移除 Middle Managers 的频率。	PT5M
druid.indexer.autoscale.originTime	终止周期在其上递增的起始参考时间戳。	2012-01-01T00:55:00.000Z
druid.indexer.autoscale.workerIdleTimeout	worker 在被考虑终止之前可以空闲（非运行任务）多久。	PT90M
druid.indexer.autoscale.maxScalingDuration	Overlord 在放弃之前等待 Middle Manager 出现的时间。	PT15M
druid.indexer.autoscale.numEventsToTrack	要跟踪的与自动缩放相关的事件（节点创建和终止）的数量。	10
druid.indexer.autoscale.pendingTaskTimeout	任务在 Overlord 尝试向上扩展之前可以处于“待处理”状态的时长。	PT30S
druid.indexer.autoscale.workerVersion	如果设置，将仅在自动缩放期间创建指定版本的节点。覆盖动态配置。	null
druid.indexer.autoscale.workerPort	Middle Managers 将运行的端口。	8080
druid.indexer.autoscale.workerCapacityHint	在没有运行 workers 时，自动缩放器启动的每个 worker 可用的任务槽数的估计值。自动缩放器使用 worker 容量提示来启动具有足够容量以处理待处理任务的 workers。当未设置或设置为小于或等于 0 的值时，自动缩放器会将 workers 的缩放比例设置为与 autoScaler 配置中 minNumWorkers 的值相等。自动缩放器假定每个 worker（无论是 Middle Manager 还是 indexer）都有相同数量的任务槽位。因此，当您的所有 workers 都具有相同容量（同构容量）时，将 autoscale.workerCapacityHint 的值设置为等于 druid.worker.capacity。如果您的 workers 具有不同的容量（异构容量），请将该值设置为所有 workers 上 druid.worker.capacity 的平均值。例如，如果两个 workers 的 druid.worker.capacity=10，一个为 druid.worker.capacity=4，则设置 autoscale.workerCapacityHint=8。仅适用于 pendingTaskBased 配置策略。	-1

监督器（Supervisors）

属性	描述	默认值
druid.supervisor.healthinessThreshold	在不健康的监督器再次被视为健康之前所需的成功运行次数。	3
druid.supervisor.unhealthinessThreshold	监督器在被视为不健康之前失败的运行次数。	3
druid.supervisor.taskHealthinessThreshold	在不健康的监督器再次被视为健康之前所需的连续任务成功次数。	3
druid.supervisor.taskUnhealthinessThreshold	在监督器被视为不健康之前连续的任务失败次数。	3
druid.supervisor.storeStackTrace	是否应存储监督器异常的完整堆栈跟踪，并由监督器 /status 端点返回。	false
druid.supervisor.maxStoredExceptionEvents	可以通过监督器 /status 端点返回的异常事件的最大数量。	max(healthinessThreshold, unhealthinessThreshold)
druid.supervisor.idleConfig.enabled	如果 true，如果输入流/主题上一段时间没有数据，监督器可以进入空闲状态。	false
druid.supervisor.idleConfig.inactiveAfterMillis	如果所有现有数据已从输入主题中读取，且在 inactiveAfterMillis 毫秒内没有发布新数据，则监督器被标记为空闲。	600_000

Overlord 运行时属性中的 druid.supervisor.idleConfig.* 规范定义了整个集群的默认行为。请参阅 Kafka 监督器 IOConfig 中的空闲配置 以覆盖单个监督器的行为。

分片元数据缓存

以下属性与 Overlord 上的分片元数据缓存有关，可用于加速分片分配和其他元数据操作。

属性	描述	默认值
druid.manager.segments.useIncrementalCache	表示分片元数据增量缓存的使用模式。可能的模式有：(a) never：禁用缓存。(b) always：始终从缓存中进行读取。服务启动将被阻塞，直到缓存至少与元数据存储同步一次。事务将阻塞，直到缓存至少与元数据存储同步一次后成为 leader。(c) ifSynced：仅当缓存已经与元数据存储同步时，才从缓存中进行读取。此模式不会阻塞服务启动或事务。	ifSynced
druid.manager.segments.pollDuration	缓存与元数据存储连续同步之间的持续时间（以 ISO 8601 格式）。此属性仅在增量缓存使用模式为 always 或 ifSynced 时使用。	PT1M (1 分钟)

自动清理未使用分片（实验性）

这些配置与在 Overlord 上运行 清理任务 的新嵌入模式有关。适用于 Coordinator 执行的自动清理 的任何配置均不被此功能使用。

属性	描述	默认值
druid.manager.segments.killUnused.enabled	布尔标志，用于启用 Overlord 上符合条件的未使用分片的自动清理。此功能仅在 Overlord 上启用了 分片元数据缓存 时才能使用，并且如果已在 Coordinator 上将 druid.coordinator.kill.on 设置为 true，则不得启用此功能。	true
druid.manager.segments.killUnused.bufferPeriod	在分片被标记为未使用后，该分片在 Overlord 上符合自动清理资格的时长。仅当 druid.manager.segments.killUnused.enabled 设置为 true 时，此配置才有效。	P30D (30 天)

Overlord 动态配置

Overlord 具有动态配置，用于调整 Druid 向 workers 分配任务的方式。您可以使用 Web 控制台 或通过 Overlord 动态配置 API 配置这些参数。

下表显示了 Overlord 的动态配置属性。

属性	描述	默认值
selectStrategy	描述如何向 Middle Managers 分配任务。类型可以是 equalDistribution、equalDistributionWithCategorySpec、fillCapacity、fillCapacityWithCategorySpec 和 javascript。	{"type":"equalDistribution"}
autoScaler	仅在启用 自动缩放 时使用。	null

以下是 Overlord 动态配置的示例

点击查看示例

{
  "selectStrategy": {
    "type": "fillCapacity",
    "affinityConfig": {
      "affinity": {
        "datasource1": ["host1:port", "host2:port"],
        "datasource2": ["host3:port"]
      }
    }
  },
  "autoScaler": {
    "type": "ec2",
    "minNumWorkers": 2,
    "maxNumWorkers": 12,
    "envConfig": {
      "availabilityZone": "us-east-1a",
      "nodeData": {
        "amiId": "${AMI}",
        "instanceType": "c3.8xlarge",
        "minInstances": 1,
        "maxInstances": 1,
        "securityGroupIds": ["${IDs}"],
        "keyName": "${KEY_NAME}"
      },
      "userData": {
        "impl": "string",
        "data": "${SCRIPT_COMMAND}",
        "versionReplacementString": ":VERSION:",
        "version": null
      }
    }
  }
}

Worker 选择策略

选择策略控制 Druid 如何将任务分配给 workers (Middle Managers)。从高层次来看，选择策略使用 affinityConfig 或 categorySpec 确定给定任务的合格 workers 列表。然后，Druid 通过尝试平均分配负载 (equalDistribution) 或将尽可能多的 workers 填充至容量 (fillCapacity) 来分配任务。选择策略有 4 个选项

• equalDistribution
• equalDistributionWithCategorySpec
• fillCapacity
• fillCapacityWithCategorySpec

也提供了一个 javascript 选项，但仅应用于新策略的初始原型设计。

如果为给定任务提供了 affinityConfig（作为 fillCapacity 和 equalDistribution 策略的一部分），则分配任务的合格 workers 列表确定如下

• 如果没有为该数据源指定关联性，则为非关联性 worker。任何未列在 affinityConfig 中的 worker 都被视为非关联性 worker。
• 如果首选 workers 不可用且关联性为 弱（即 strong: false），则为非关联性 worker。
• 如果它有可用容量，则为该数据源 affinityConfig 中列出的首选 worker
• 如果首选 workers 不可用且关联性为 强（即 strong: true），则没有 worker。在这种情况下，任务保持在“待处理”状态。所选的配置策略（例如 pendingTaskBased）然后可以使用待处理任务的总数来确定是否应配置新节点。

请注意，affinityConfig 中列出的每个 worker 都仅用于分配的数据源，不会用于其他任何数据源。

如果提供了 categorySpec（作为 fillCapacityWithCategorySpec 和 equalDistributionWithCategorySpec 策略的一部分），则给定数据源的任务可以分配给

• 如果任务类型没有给定分类配置，则为任何 worker
• 如果任务类型给定了分类配置，但数据源没有给定分类，且没有默认分类，则为任何 worker
• 首选 worker（基于分类配置和数据源分类，如果可用）
• 如果给定了分类配置和分类，但没有可用的首选 worker，且分类配置为 弱，则为任何 worker
• 如果首选 workers 不可用且分类配置为 强，则根本不分配

在这两种情况下，Druid 都会确定合格 workers 列表，并根据它们的负载选择一个，目标是平均分配负载或尽可能填满 workers。

如果您正在使用自动缩放，请使用 fillCapacity 选择策略，因为自动缩放的节点无法分配类别，并且您希望将工作集中在最少数量的 workers 上，以便腾空的 workers 可以缩减规模。

equalDistribution

任务在开始运行时尚未分配给拥有最多空闲槽位的 Middle Manager。这会平均分配 Middle Managers 之间的负载。

属性	描述	默认值
type	equalDistribution	必填；必须为 equalDistribution
affinityConfig	AffinityConfig 对象	null（无关联性）
taskLimits	TaskLimits 对象	null（无限制）

equalDistributionWithCategorySpec

此策略是 equalDistribution 的变体，支持 workerCategorySpec 字段而不是 affinityConfig。通过指定 workerCategorySpec，您可以根据任务的 类型 和 dataSource 将任务分配给不同类别的 Middle Managers 运行。此策略不适用于 AutoScaler，因为行为未定义。

属性	描述	默认值
type	equalDistributionWithCategorySpec	必填；必须为 equalDistributionWithCategorySpec
workerCategorySpec	WorkerCategorySpec 对象	null（无 worker 分类规范）
taskLimits	TaskLimits 对象	null（无限制）

以下示例显示了类型为 index_kafka 的任务默认在类别 c1 的 Middle Managers 上运行，写入数据源 ds1 的任务除外，它们在类别 c2 的 Middle Managers 上运行。

{
  "selectStrategy": {
    "type": "equalDistributionWithCategorySpec",
    "workerCategorySpec": {
      "strong": false,
      "categoryMap": {
        "index_kafka": {
          "defaultCategory": "c1",
          "categoryAffinity": {
            "ds1": "c2"
          }
        }
      }
    }
  }
}

fillCapacity

任务被分配给当前运行任务最多的 worker。当您自动缩放 Middle Managers 时，这很有用，因为它倾向于将一些 workers 填满，而让其他一些 workers 保持空闲。空闲的 workers 可以安全地终止。

请注意，如果 druid.indexer.runner.pendingTasksRunnerNumThreads 设置为 N > 1，则此策略将同时填满 N 个 Middle Managers 至容量，而不是单个 Middle Manager。

属性	描述	默认值
type	fillCapacity	必填；必须为 fillCapacity
affinityConfig	AffinityConfig 对象	null（无关联性）
taskLimits	TaskLimits 对象	null（无限制）

fillCapacityWithCategorySpec

此策略是 fillCapacity 的变体，支持 workerCategorySpec 而不是 affinityConfig。其用法与 equalDistributionWithCategorySpec 策略相同。此策略不适用于 AutoScaler，因为行为未定义。

属性	描述	默认值
type	fillCapacityWithCategorySpec.	必填；必须为 fillCapacityWithCategorySpec
workerCategorySpec	WorkerCategorySpec 对象	null（无 worker 分类规范）
taskLimits	TaskLimits 对象	null（无限制）

javascript

允许使用 JavaScript 函数为运行任务定义任意选择 workers 的逻辑。函数被传递 remoteTaskRunnerConfig、workerId 到可用 workers 的映射以及要执行的任务，并返回应在其上运行任务的 workerId，如果任务无法运行，则返回 null。它可用于快速开发缺失的功能，其中 worker 选择逻辑需要经常更改或调整。如果选择逻辑相当复杂且不能轻易在 JavaScript 环境中测试，最好编写一个 Druid 扩展模块，通过扩展当前用 Java 编写的 worker 选择策略来实现。

属性	描述	默认值
type	javascript	必填；必须为 javascript
function	表示 JavaScript 函数的字符串

以下示例展示了一个将 batch_index_task 发送到 workers 10.0.0.1 和 10.0.0.2，并将所有其他任务发送到其他可用 workers 的函数。

{
  "type":"javascript",
  "function":"function (config, zkWorkers, task) {\nvar batch_workers = new java.util.ArrayList();\nbatch_workers.add(\"middleManager1_hostname:8091\");\nbatch_workers.add(\"middleManager2_hostname:8091\");\nworkers = zkWorkers.keySet().toArray();\nvar sortedWorkers = new Array()\n;for(var i = 0; i < workers.length; i++){\n sortedWorkers[i] = workers[i];\n}\nArray.prototype.sort.call(sortedWorkers,function(a, b){return zkWorkers.get(b).getCurrCapacityUsed() - zkWorkers.get(a).getCurrCapacityUsed();});\nvar minWorkerVer = config.getMinWorkerVersion();\nfor (var i = 0; i < sortedWorkers.length; i++) {\n var worker = sortedWorkers[i];\n  var zkWorker = zkWorkers.get(worker);\n  if(zkWorker.canRunTask(task) && zkWorker.isValidVersion(minWorkerVer)){\n    if(task.getType() == 'index_parallel' && batch_workers.contains(worker)){\n      return worker;\n    } else {\n      if(task.getType() != 'index_parallel' && !batch_workers.contains(worker)){\n        return worker;\n      }\n    }\n  }\n}\nreturn null;\n}"
}

信息

基于 JavaScript 的功能默认情况下是禁用的。请参阅 Druid JavaScript 编程指南 以获取关于使用 Druid JavaScript 功能的指南，包括如何启用它的说明。

affinityConfig

使用 affinityConfig 字段将关联性配置传递给 equalDistribution 和 fillCapacity 策略。如果未提供，则默认为无关联性。

属性	描述	默认值
affinity	将数据源字符串名称映射到索引服务 Middle Manager host:port 值列表的 JSON 对象。Druid 不执行 DNS 解析，因此 'host' 值必须与 Middle Manager 上配置的内容以及 Middle Manager 自行宣告的内容匹配（检查 Overlord 日志以查看您的 Middle Manager 自行宣告的内容）。	{}
strong	当 true 时，数据源的任务必须分配给关联映射的 Middle Managers。任务保持排队直到有可用槽位。当 false 时，如果关联映射的 Middle Managers 不可用，Druid 可能会将数据源的任务分配给其他 Middle Managers。	false

workerCategorySpec

您可以使用 workerCategorySpec 字段为 equalDistributionWithCategorySpec 和 fillCapacityWithCategorySpec 策略提供 workerCategorySpec。如果未提供，则默认为根本不使用它。

属性	描述	默认值
categoryMap	一个 JSON 映射对象，将任务类型字符串名称映射到 CategoryConfig 对象，由此您可以为不同任务类型指定分类配置。	{}
strong	使用弱 workerCategorySpec（默认值），如果 categoryMap 中指定的 Middle Managers 无法运行该数据源队列中的所有待处理任务，则数据源的任务可能会被分配给其他 Middle Managers。使用强 workerCategorySpec，数据源的任务将始终仅被分配给其指定的 Middle Managers，并在必要时在待处理队列中等待。	false

taskLimits

taskLimits 字段可与 equalDistribution、fillCapacity、equalDistributionWithCategorySpec 和 fillCapacityWithCategorySpec 策略一起使用。如果您不提供它，它将默认为不使用。

属性	描述	默认值
maxSlotCountByType	一个映射，其中每个键都是任务类型（String），对应的值表示该类型任务可以占用的任务槽位的绝对限制。该值是一个大于或等于 0 的 Integer。例如，值为 5 意味着该类型的任务总共可以占用最多 5 个任务槽位。如果为同一任务类型指定了绝对限制和比例限制，则有效限制将是绝对限制与从相应比例导出的限制中较小的一个。maxSlotCountByType = {"index_parallel": 3, "query_controller": 5}。在此示例中，并行索引任务最多可以占用 3 个任务槽位，查询控制器最多可以占用 5 个任务槽位。	{}
maxSlotRatioByType	一个映射，其中每个键都是任务类型（String），对应的值是一个应在 [0, 1] 范围内的 Double，表示该类型任务可以占用的任务槽位比例。此比例定义了任务类型可以使用的总任务槽位的比例，计算方式为 ratio * totalSlots。如果为同一任务类型指定了绝对限制和比例限制，则有效限制将是绝对限制与从相应比例导出的限制中较小的一个。maxSlotRatioByType = {"index_parallel": 0.5, "query_controller": 0.25}。在此示例中，并行索引任务最多可以占用总任务槽位的 50%，查询控制器最多可以占用总任务槽位的 25%。	{}

CategoryConfig

属性	描述	默认值
defaultCategory	指定任务类型的默认分类。	null
categoryAffinity	一个 JSON 映射对象，将数据源字符串名称映射到 Middle Manager 的分类字符串名称。如果未为数据源指定分类，则使用 defaultCategory。如果未指定分类且 defaultCategory 也为 null，则任务可以在任何可用的 Middle Managers 上运行。	null

自动缩放器（Autoscaler）

亚马逊的 EC2 和谷歌的 GCE 是目前唯一支持的自动缩放器。

EC2 的自动缩放器属性为

属性	描述	默认值
type	ec2	0
minNumWorkers	集群中在任何给定时间可以拥有的最少 workers 数量。	0
maxNumWorkers	集群中在任何给定时间可以拥有的最多 workers 数量。	0
envConfig.availabilityZone	要在哪个亚马逊可用区中运行。	无
envConfig.nodeData	描述如何启动新节点的 JSON 对象。	无；必填
envConfig.userData	描述如何配置新节点的 JSON 对象。如果您设置了 druid.indexer.autoscale.workerVersion，则此对象必须具有 versionReplacementString。否则，不需要 versionReplacementString。	无；可选

有关 GCE 的属性，请参阅 gce-extensions。

Data 服务器

本节包含建议的 三服务器配置 中驻留在数据服务器（Middle Managers/Peons 和 Historicals）上的服务的配置选项。

这里还提供了 Indexer 进程 的配置选项。

Middle Manager 和 Peon

这些 Middle Manager 和 Peon 配置可以在 middleManager/runtime.properties 文件中定义。

Middle Manager 服务配置

属性	描述	默认值
druid.host	当前服务的主机。这用于宣告当前服务位置为可从其他服务访问，通常应指定为 http://${druid.host}/ 实际上可以与此服务通信。	InetAddress.getLocalHost().getCanonicalHostName()
druid.bindOnHost	指示服务的内部 jetty 服务器是否绑定到 druid.host。默认值为 false，这意味着绑定到所有接口。	false
druid.plaintextPort	实际监听的端口；除非使用端口映射，否则这将是与 druid.host 上的端口相同的端口。	8091
druid.tlsPort	HTTPS 连接器的 TLS 端口，如果设置了 druid.enableTlsPort，则将使用此配置。如果 druid.host 包含端口，则该端口将被忽略。这应该是一个非负整数。	8291
druid.service	服务的名称。在发出指标和告警时用作维度，以区分各种服务	druid/middlemanager
druid.labels	定义服务器自定义标签的键值对的可选 JSON 对象。这些标签显示在 Web 控制台的“服务”选项卡下。示例：druid.labels={"location":"Airtrunk"} 或 druid.labels.location=Airtrunk	null

Middle Manager 配置

Middle Managers 将其配置向下传递给子 Peons。Middle Manager 需要以下配置

属性	描述	默认值
druid.indexer.runner.allowedPrefixes	可传递给子 Peons 的配置前缀的白名单。	com.metamx, druid, org.apache.druid, user.timezone, file.encoding, java.io.tmpdir, hadoop
druid.indexer.runner.compressZnodes	指示 Middle Managers 是否应压缩 Znodes。	true
druid.indexer.runner.classpath	Peon 的 Java 类路径。	System.getProperty("java.class.path")
druid.indexer.runner.javaCommand	执行 Java 所需的命令。	java
druid.indexer.runner.javaOpts	已弃用 一串要传递给 Peon JVM 的 -X Java 选项。带有引号的参数或带有空格的参数鼓励使用 javaOptsArray	''
druid.indexer.runner.javaOptsArray	作为选项传递给 Peon JVM 的字符串 JSON 数组。这是对 druid.indexer.runner.javaOpts 的补充，建议用于正确处理包含引号或空格的参数，如 ["-XX:OnOutOfMemoryError=kill -9 %p"]	[]
druid.indexer.runner.maxZnodeBytes	ZooKeeper 中可创建的最大 Znode 大小（字节），应在范围 [10KiB, 2GiB) 内。支持 人类可读格式。	512KiB
druid.indexer.runner.startPort	用于 Peon 服务的起始端口，应大于 1023 且小于 65536。	8100
druid.indexer.runner.endPort	用于 Peon 服务的结束端口，应大于或等于 druid.indexer.runner.startPort 且小于 65536。	65535
druid.indexer.runner.ports	一个整数 JSON 数组，用于指定用于 Peon 服务的端口。如果提供且非空，Peon 服务的端口将从这些端口中选择。并且 druid.indexer.runner.startPort/druid.indexer.runner.endPort 将被完全忽略。	[]
druid.worker.ip	worker 的 IP。	localhost
druid.worker.version	Middle Manager 的版本标识符。版本号是一个字符串。这会影响在某些操作（如与 druid.indexer.runner.minWorkerVersion 进行比较）期间的预期行为。具体而言，版本比较遵循字典顺序。使用 ISO8601 日期格式作为版本以适应日期比较。	0
druid.worker.capacity	Middle Manager 可以接受的最大任务数。	机器上的 CPU 数量 - 1
druid.worker.baseTaskDirs	基础临时工作目录列表，每个任务以循环方式被分配其中之一。此属性可用于允许将多个磁盘用于索引。建议使用此属性代替 ${druid.indexer.task.baseTaskDir}，并且该属性优先级更高。如果未设置此配置，则使用 ${druid.indexer.task.baseTaskDir}。例如，druid.worker.baseTaskDirs=[\"PATH1\",\"PATH2\",...]。	null
druid.worker.baseTaskDirSize	可以在任何单个任务目录上由任务使用的总字节量。此值在所有目录中对称处理，也就是说，如果这是 500 GB 且有 3 个 baseTaskDirs，则假设这些任务目录中的每一个都允许使用 500 GB，并且所有任务总共将潜在地可用 1.5 TB。分配给每个任务的实际内存量在 配置任务存储大小 中讨论	Long.MAX_VALUE
druid.worker.category	用于命名 Middle Manager 节点所属分类的字符串。	_default_worker_category
druid.indexer.fork.property.druid.centralizedDatasourceSchema.enabled	当启用 集中式数据源模式 (Centralized Datasource Schema) 功能时，应设置此配置。	false

Peon 处理

在 Middle Manager 上设置的处理属性会传递给 Peon。

属性	描述	默认值
druid.processing.buffer.sizeBytes	指定用于存储中间结果的缓冲区大小（小于 2GiB）。Historical 和 Realtime 进程中的计算引擎将使用此大小的暂存缓冲区在堆外执行所有中间计算。较大的值允许在对数据进行单次传递时进行更多的聚合，而较小的值则可能需要根据正在执行的查询进行更多次传递。支持 人类可读格式。	auto（最大 1 GiB）
druid.processing.buffer.poolCacheMaxCount	处理缓冲区池会缓存缓冲区以供后续使用。这是缓存将增长到的最大数量。请注意，如果需要，池创建的缓冲区数量可能会超过其缓存的数量。	Integer.MAX_VALUE
druid.processing.formatString	Realtime 和 Historical 进程使用此格式字符串来命名其处理线程。	processing-%s
druid.processing.numMergeBuffers	可用于合并查询结果的直接内存缓冲区数量。缓冲区的缓冲区大小由 druid.processing.buffer.sizeBytes 指定。此属性实际上是需要合并缓冲区的查询的并发限制。如果您使用的任何查询需要合并缓冲区（目前仅 groupBy），则应至少设置两个。	max(2, druid.processing.numThreads / 4)
druid.processing.numThreads	可用于并行处理 Segment 的处理线程数量。我们的经验法则是 num_cores - 1，这意味着即使在重负载下，仍有一个核心可用于执行诸如与 ZooKeeper 通信和下载 Segment 等后台任务。如果只有一个核心可用，此属性默认为 1。	核心数 - 1（或 1）
druid.processing.numTimeoutThreads	用于处理 Segment 查询超时的处理线程数量。将此值设置为 0 会移除服务于 Segment 级超时的能力，而不受 perSegmentTimeout 查询上下文参数的影响。由于这些线程仅服务于计时器，建议将此值设置为 Peon 可用的总查询处理核心的一小部分（例如 5%）。	0
druid.processing.fifo	使处理队列能够以 FIFO（先进先出）方式处理优先级相同的任务。	true
druid.processing.tmpDir	处理查询时创建的临时文件的存储路径。如果指定，此配置的优先级高于默认的 java.io.tmpdir 路径。	由 java.io.tmpdir 表示的路径
druid.processing.intermediaryData.storage.type	原生并行索引任务之间数据混洗（shuffle）的中间 Segment 的存储类型。 设置为 local 以将 Segment 文件存储在 Middle Manager 或 Indexer 的本地存储中。 设置为 deepstore 以使用配置的深度存储，从而在滚动更新期间实现更好的容错能力。当存储类型为 deepstore 时，Druid 会将数据存储在配置的深度存储路径下的 shuffle-data 目录中。仅当深度存储基于 HDFS 时才支持自动清理 shuffle-data 目录。对于其他深度存储类型，您可以设置云存储生命周期规则，以在 shuffle-data 前缀位置自动清理数据。	local
druid.processing.parallelPoolInit	（实验性）允许在进程启动时并行分配所有合并/处理内存池。如果分配多个大缓冲区，这可以显著加快 Peon 启动时间。	false

Druid 所需的直接内存量至少为 druid.processing.buffer.sizeBytes * (druid.processing.numMergeBuffers + druid.processing.numThreads + 1)。您可以通过在 druid.indexer.runner.javaOptsArray 中提供 -XX:MaxDirectMemorySize=<VALUE>（如上所述）来确保至少提供此数量的直接内存。

Peon 查询配置

请参阅 通用查询配置。

Peon 缓存

您可以通过在此处设置缓存配置来选择性地在 Peon 上启用缓存。

属性	可能的值	描述	默认值
druid.realtime.cache.useCache	true, false	在 realtime 进程上启用缓存。	false
druid.realtime.cache.populateCache	true, false	在 realtime 进程上填充缓存。	false
druid.realtime.cache.unCacheable	所有 druid 查询类型	不缓存的所有查询类型。	[scan]
druid.realtime.cache.maxEntrySize	正整数	最大缓存条目大小（字节）。	1_000_000

有关如何配置缓存设置的信息，请参阅 缓存配置。

额外的 Peon 配置

虽然 Peon 继承了其父级 Middle Manager 的配置，但可以通过添加前缀来显式设置 Middle Manager 中的子 Peon 配置

druid.indexer.fork.property

额外的 Peon 配置包括

属性	描述	默认值
druid.peon.mode	local 或 remote 之一。将此属性设置为 local 意味着您打算将 Peon 作为独立进程运行，这不推荐。	remote
druid.indexer.task.baseDir	基础临时工作目录。	System.getProperty("java.io.tmpdir")
druid.indexer.task.baseTaskDir	任务的基础临时工作目录。	${druid.indexer.task.baseDir}/persistent/task
druid.indexer.task.defaultRowFlushBoundary	持久化到磁盘前的最高行数。用于索引生成任务。	75000
druid.indexer.task.directoryLockTimeout	等待僵尸 Peon 退出的时长，之后放弃其替换进程。	PT10M
druid.indexer.task.gracefulShutdownTimeout	在 Middle Manager 重启时，等待可恢复任务优雅退出的时长。	PT5M
druid.indexer.task.restoreTasksOnRestart	如果为 true，Middle Manager 将尝试在关机时优雅地停止任务并在重启时恢复它们。	false
druid.indexer.task.ignoreTimestampSpecForDruidInputSource	如果为 true，使用 Druid 输入源的任务将忽略提供的 timestampSpec，并使用输入数据源的 __time 列。提供此选项是为了兼容 Druid 0.22.0 之前编写的摄取规范。	false
druid.indexer.task.storeEmptyColumns	布尔值，用于确定摄取期间是否存储空列。设置为 true 时，Druid 会存储 dimensionsSpec 中指定的所有列。如果您使用基于字符串的无模式摄取且未指定要摄取的维度，则还必须设置 includeAllDimensions，以便 Druid 存储空列。 如果您将 storeEmptyColumns 设置为 false，引用空列的 Druid SQL 查询将失败。如果您打算禁用 storeEmptyColumns，则应为这些列摄取占位符数据，或者不要对空列进行查询。 您可以通过在 任务上下文中设置 storeEmptyColumns 来覆盖此配置。	true
druid.indexer.task.tmpStorageBytesPerTask	每个任务用于在磁盘上存储临时文件的最大字节数。此配置通常仅用于内部用途。尝试设置它极有可能被执行该任务的 TaskRunner 覆盖，因此在直接调整此配置参数之前，请确认您的预期结果。记录此配置主要是为了了解在看到它被设置时的含义。值 -1 表示禁用此限制。	-1
druid.indexer.server.maxChatRequests	任务聊天处理程序处理的最大并发请求数。设置为 0 可禁用限制。	0
druid.indexing.formats.maxStringLength	每个字符串维度值存储的最大字符数。较长的值会在摄取期间被截断。不适用于多值字符串维度。可以使用 维度对象 中的 maxStringLength 按维度覆盖。值必须 >= 0。	null（无截断）

如果 Peon 在远程模式下运行，则必须有 Overlord 在运行。远程模式下的 Peon 可以设置以下配置

属性	描述	默认值
druid.peon.taskActionClient.retry.minWait	与 Overlord 通信的最小重试时间。	PT5S
druid.peon.taskActionClient.retry.maxWait	与 Overlord 通信的最大重试时间。	PT1M
druid.peon.taskActionClient.retry.maxRetryCount	与 Overlord 通信的最大重试次数。	13（大约 10 分钟重试）

SegmentWriteOutMediumFactory

当创建新的 Segment 时，Druid 会暂时将一些预处理数据存储在缓冲区中。缓冲区存在以下几种介质类型

• 临时文件 (tmpFile) 存储在任务工作目录（见上述 druid.worker.baseTaskDirs 配置）下，因此共享其挂载属性。例如，它们可以由 HDD、SSD 或内存 (tmpfs) 支持。这种介质类型可能会产生不必要的磁盘 I/O，并需要一定的可用磁盘空间。

• 堆外内存 (offHeapMemory) 在运行任务的 JVM 进程的堆外内存中创建缓冲区。这是首选的介质类型，但可能需要您通过更改 -XX:MaxDirectMemorySize 配置来允许 JVM 拥有更多的堆外内存。目前尚不清楚所需的堆外内存大小与正在创建的 Segment 大小之间的关系。但您不应添加比同一 JVM 的配置的最大堆大小 (-Xmx) 更多的额外堆外内存。

• 堆内内存 (onHeapMemory) 使用运行任务的 JVM 进程的已分配堆内存来创建缓冲区。使用堆内内存会引入垃圾回收开销，因此在大多数情况下不建议使用。此类型介质对于在外部集群上运行的任务最有用，因为在这些环境中可能难以有效地分配和处理直接内存。

对于大多数类型的任务，SegmentWriteOutMediumFactory 可以按任务进行配置（有关详细信息，请参阅 任务），但如果未为任务指定，或者特定任务类型不支持，则 Druid 将使用以下配置中的值

属性	描述	默认值
druid.peon.defaultSegmentWriteOutMediumFactory.type	tmpFile, offHeapMemory, 或 onHeapMemory	tmpFile

Indexer

Indexer 进程配置

属性	描述	默认值
druid.host	当前进程的主机。这用于发布当前进程的位置，以便从其他进程访问，通常应指定为使得 http://${druid.host}/ 实际上可以与该进程通信	InetAddress.getLocalHost().getCanonicalHostName()
druid.bindOnHost	指示进程的内部 jetty 服务器是否绑定在 druid.host 上。默认为 false，这意味着绑定到所有接口。	false
druid.plaintextPort	实际监听的端口；除非使用端口映射，否则这将是与 druid.host 上的端口相同的端口。	8091
druid.tlsPort	HTTPS 连接器的 TLS 端口，如果设置了 druid.enableTlsPort，则将使用此配置。如果 druid.host 包含端口，则该端口将被忽略。这应该是一个非负整数。	8283
druid.service	服务的名称。在发出指标和告警时用作维度，以区分各种服务	druid/indexer
druid.labels	定义服务器自定义标签的键值对的可选 JSON 对象。这些标签显示在 Web 控制台的“服务”选项卡下。示例：druid.labels={"location":"Airtrunk"} 或 druid.labels.location=Airtrunk	null

Indexer 通用配置

属性	描述	默认值
druid.worker.version	Indexer 的版本标识符。	0
druid.worker.capacity	Indexer 可接受的最大任务数。	可用处理器数 - 1
druid.worker.baseTaskDirs	基础临时工作目录列表，每个任务以循环方式分配其中一个。此属性可用于允许在索引任务中使用多个磁盘。建议使用此属性代替并优先于 ${druid.indexer.task.baseTaskDir}。如果未设置此配置，则使用 ${druid.indexer.task.baseTaskDir}。示例： druid.worker.baseTaskDirs=[\"PATH1\",\"PATH2\",...]。	null
druid.worker.baseTaskDirSize	可以在任何单个任务目录上由任务使用的总字节量。此值在所有目录中对称处理，也就是说，如果这是 500 GB 且有 3 个 baseTaskDirs，则假设这些任务目录中的每一个都允许使用 500 GB，并且所有任务总共将潜在地可用 1.5 TB。分配给每个任务的实际内存量在 配置任务存储大小 中讨论	Long.MAX_VALUE
druid.worker.globalIngestionHeapLimitBytes	可用于摄取处理的总堆大小。这是通过自动设置任务上的 maxBytesInMemory 属性来应用的。	已配置的最大 JVM 堆大小 / 6
druid.worker.numConcurrentMerges	所有任务中可同时运行的最大 Segment 持久化或合并操作数。	druid.worker.capacity / 2，向下取整
druid.indexer.task.baseDir	基础临时工作目录。	System.getProperty("java.io.tmpdir")
druid.indexer.task.baseTaskDir	任务的基础临时工作目录。	${druid.indexer.task.baseDir}/persistent/tasks
druid.indexer.task.gracefulShutdownTimeout	在 Indexer 重启时，等待可恢复任务优雅退出的时长。	PT5M
druid.indexer.task.restoreTasksOnRestart	如果为 true，Indexer 将尝试在关机时优雅地停止任务并在重启时恢复它们。	false
druid.indexer.task.ignoreTimestampSpecForDruidInputSource	如果为 true，使用 Druid 输入源的任务将忽略提供的 timestampSpec，并使用输入数据源的 __time 列。提供此选项是为了兼容 Druid 0.22.0 之前编写的摄取规范。	false
druid.indexer.task.storeEmptyColumns	布尔值，用于确定摄取期间是否存储空列。设置为 true 时，Druid 会存储 dimensionsSpec 中指定的所有列。 如果您将 storeEmptyColumns 设置为 false，引用空列的 Druid SQL 查询将失败。如果您打算禁用 storeEmptyColumns，则应为这些列摄取占位符数据，或者不要对空列进行查询。 您可以通过在 任务上下文中设置 storeEmptyColumns 来覆盖此配置。	true
druid.peon.taskActionClient.retry.minWait	与 Overlord 通信的最小重试时间。	PT5S
druid.peon.taskActionClient.retry.maxWait	与 Overlord 通信的最大重试时间。	PT1M
druid.peon.taskActionClient.retry.maxRetryCount	与 Overlord 通信的最大重试次数。	13（大约 10 分钟重试）

Indexer 并发请求

Druid 使用 Jetty 来服务 HTTP 请求。

属性	描述	默认值
druid.server.http.numThreads	HTTP 请求的线程数。请参阅 Indexer Server HTTP 线程 文档，了解有关 Indexer 如何使用此配置的更多详细信息。	max(10, (核心数 * 17) / 16 + 2) + 30
druid.server.http.queueSize	Jetty 服务器使用的用于临时存储传入客户端连接的工作队列大小。如果设置了此值且因为队列已满而被 jetty 拒绝请求，客户端将观察到请求失败，TCP 连接会立即关闭，服务器返回完全为空的响应。	无界
druid.server.http.maxIdleTime	连接的 Jetty 最大空闲时间。	PT5M
druid.server.http.enableRequestLimit	如果启用，则不会在 jetty 队列中排队任何请求，并将发送 "HTTP 429 Too Many Requests" 错误响应。	false
druid.server.http.defaultQueryTimeout	查询超时（毫秒），超过此时间未完成的查询将被取消	300000
druid.server.http.gracefulShutdownTimeout	Jetty 在接收到关闭信号后等待的最大时间。在此超时后，线程将被强制关闭。这允许正在执行的查询完成（仅大于零的值有效）。	PT30S
druid.server.http.unannouncePropagationDelay	在关闭 Jetty 之前等待 ZooKeeper 取消发布（unannouncement）传播的时间。这是一个最小值，druid.server.http.gracefulShutdownTimeout 只有在此周期过后才开始计时。	PT0S（不等待）
druid.server.http.maxQueryTimeout	timeout 参数允许的最大值（毫秒）。请参阅 查询上下文 以了解有关 timeout 的更多信息。如果查询上下文中的 timeout 大于此值，查询将被拒绝。	Long.MAX_VALUE
druid.server.http.maxRequestHeaderSize	请求头的最大大小（字节）。较大的 header 会消耗更多内存，并可能使服务器更容易受到拒绝服务攻击。	8 * 1024
druid.server.http.enableForwardedRequestCustomizer	如果启用，将添加 Jetty ForwardedRequestCustomizer，它会读取 X-Forwarded-* 请求头，以便在 Druid 置于代理之后时操作 servlet 请求对象。	false
druid.server.http.allowedHttpMethods	除 Druid API 所需的方法之外应允许的 HTTP 方法列表。Druid API 需要 GET、PUT、POST 和 DELETE，这些始终被允许。除非您安装了需要这些额外 HTTP 方法或添加了与 CORS 相关功能的扩展，否则此选项无用。没有任何 Druid 自带的扩展需要这些方法。	[]
druid.server.http.contentSecurityPolicy	在每个非 POST 响应上设置的 Content-Security-Policy header 值。将此属性设置为空字符串或省略它，都会导致设置默认的 frame-ancestors: none。	frame-ancestors 'none'
druid.server.http.uriCompliance	Druid 嵌入式 Jetty 服务器的 Jetty UriCompliance 模式。要修改，请使用 Jetty 支持 的任何 UriCompliance 模式的字符串表示来覆盖此配置。	LEGACY
druid.server.http.enforceStrictSNIHostChecking	如果启用，Jetty 服务器将强制执行严格的 SNI 主机检查。这意味着如果客户端使用 TLS 连接到服务器但未提供 SNI 主机名，或提供的 SNI 主机名与服务器配置的主机名不匹配，则请求将收到 400 响应。不建议在生产环境中将其设置为 false。	true

Indexer 处理资源

属性	描述	默认值
druid.processing.buffer.sizeBytes	此配置指定用于存储中间结果的缓冲区大小（小于 2GiB）。Indexer 进程中的计算引擎将使用此大小的暂存缓冲区在堆外执行所有中间计算。较大的值允许在对数据进行单次传递时进行更多的聚合，而较小的值则可能需要根据正在执行的查询进行更多次传递。支持 人类可读格式。	auto（最大 1GiB）
druid.processing.buffer.poolCacheMaxCount	处理缓冲区池会缓存缓冲区以供后续使用，这是缓存将增长到的最大数量。请注意，如果需要，池创建的缓冲区数量可能会超过其缓存的数量。	Integer.MAX_VALUE
druid.processing.formatString	Indexer 进程使用此格式字符串来命名其处理线程。	processing-%s
druid.processing.numMergeBuffers	可用于合并查询结果的直接内存缓冲区数量。缓冲区的缓冲区大小由 druid.processing.buffer.sizeBytes 指定。此属性实际上是需要合并缓冲区的查询的并发限制。如果您使用的任何查询需要合并缓冲区（目前仅 groupBy），则应至少设置两个。	max(2, druid.processing.numThreads / 4)
druid.processing.numThreads	可用于并行处理 Segment 的处理线程数量。我们的经验法则是 num_cores - 1，这意味着即使在重负载下，仍有一个核心可用于执行诸如与 ZooKeeper 通信和下载 Segment 等后台任务。如果只有一个核心可用，此属性默认为 1。	核心数 - 1（或 1）
druid.processing.numTimeoutThreads	用于处理 Segment 查询超时的处理线程数量。将此值设置为 0 会移除服务于 Segment 级超时的能力，而不受 perSegmentTimeout 查询上下文参数的影响。由于这些线程仅服务于计时器，建议将此值设置为 Indexer 可用的总查询处理核心的一小部分（例如 5%）。	0
druid.processing.fifo	处理队列是否应以 FIFO 方式处理优先级相同的任务	true
druid.processing.tmpDir	处理查询时创建的临时文件的存储路径。如果指定，此配置的优先级高于默认的 java.io.tmpdir 路径。	由 java.io.tmpdir 表示的路径
druid.processing.parallelPoolInit	（实验性）允许在进程启动时并行分配所有合并/处理内存池。如果分配多个大缓冲区，这可以显著加快 Indexer 启动时间。	false

Druid 所需的直接内存量至少为 druid.processing.buffer.sizeBytes * (druid.processing.numMergeBuffers + druid.processing.numThreads + 1)。您可以通过在命令行提供 -XX:MaxDirectMemorySize=<VALUE> 来确保至少提供此数量的直接内存。

查询配置

请参阅 通用查询配置。

Indexer 缓存

您可以通过在此处设置缓存配置来选择性地在 Indexer 上启用缓存。

属性	可能的值	描述	默认值
druid.realtime.cache.useCache	true, false	在 realtime 进程上启用缓存。	false
druid.realtime.cache.populateCache	true, false	在 realtime 进程上填充缓存。	false
druid.realtime.cache.unCacheable	所有 druid 查询类型	不缓存的所有查询类型。	[scan]
druid.realtime.cache.maxEntrySize	正整数	最大缓存条目大小（字节）。	1_000_000

有关如何配置缓存设置的信息，请参阅 缓存配置。

请注意，仅支持诸如 local 类型缓存和 caffeine 缓存等本地缓存。如果使用诸如 memcached 之类的远程缓存，它将被忽略。

Historical

有关 Historical 服务的常规信息，请参阅 Historical。

这些 Historical 配置可以在 historical/runtime.properties 文件中定义。

Historical 服务配置

属性	描述	默认值
druid.host	当前服务的主机。这用于宣告当前服务位置为可从其他服务访问，通常应指定为 http://${druid.host}/ 实际上可以与此服务通信。	InetAddress.getLocalHost().getCanonicalHostName()
druid.bindOnHost	指示服务的内部 jetty 服务器是否绑定到 druid.host。默认值为 false，这意味着绑定到所有接口。	false
druid.plaintextPort	实际监听的端口；除非使用端口映射，否则这将是与 druid.host 上的端口相同的端口。	8083
druid.tlsPort	HTTPS 连接器的 TLS 端口，如果设置了 druid.enableTlsPort，则将使用此配置。如果 druid.host 包含端口，则该端口将被忽略。这应该是一个非负整数。	8283
druid.service	服务的名称。在发出指标和告警时用作维度，以区分各种服务	druid/historical
druid.labels	定义服务器自定义标签的键值对的可选 JSON 对象。这些标签显示在 Web 控制台的“服务”选项卡下。示例：druid.labels={"location":"Airtrunk"} 或 druid.labels.location=Airtrunk	null

Historical 通用配置

属性	描述	默认值
druid.server.maxSize	该服务希望分配到的 Segment 的最大字节数。Coordinator 服务仅在此属性大于该 Historical 服务所服务的 Segment 总大小时，才会尝试将 Segment 分配给它。由于此属性定义了可分配给 Historical 的总 Segment 大小的上限，因此默认值为 druid.segmentCache.locations 属性中指定的所有 maxSize 值之和。支持人类可读格式，请参阅 此处。	druid.segmentCache.locations 中定义的 maxSize 值之和
druid.server.tier	用于命名存储服务所属的分发层（tier）的字符串。Coordinator 服务用于管理 Segment 的许多 规则 都可以按层进行键控。	_default_tier
druid.server.priority	在分层架构中，层的优先级，从而允许控制查询哪些服务。数字越大表示优先级越高。默认值（无优先级）适用于没有交叉复制的架构（没有数据存储重叠的层）。数据中心通常具有相等的优先级。	0

存储 Segment

属性	描述	默认值
druid.segmentCache.locations	分配给 Historical 服务的 Segment 首先存储在本地文件系统（磁盘缓存中），然后由 Historical 服务提供服务。这些位置定义了本地缓存的位置。此值不能为 NULL 或 EMPTY。这是一个示例 druid.segmentCache.locations=[{"path": "/mnt/druidSegments", "maxSize": "10k", "freeSpacePercent": 1.0}]。 "freeSpacePercent" 是可选的，如果提供，则强制在存储 Segment 时保持那么多的空闲磁盘分区空间。但是，它依赖于 File.getTotalSpace() 和 File.getFreeSpace() 方法，因此仅当它们适用于您的文件系统时才启用。	无
druid.segmentCache.locationSelector.strategy	用于从已配置的 druid.segmentCache.locations 中选择用于 Segment 分发的位置的策略。可能的值为 leastBytesUsed、roundRobin、random 或 mostAvailableSize。	leastBytesUsed
druid.segmentCache.deleteOnRemove	当服务不再服务 Segment 时，从缓存中删除 Segment 文件。	true
druid.segmentCache.dropSegmentDelayMillis	服务在彻底丢弃 Segment 之前延迟多长时间。	30000（30 秒）
druid.segmentCache.infoDir	Historical 服务会跟踪它们正在服务的 Segment，以便在服务重启时，它们可以重新加载相同的 Segment，而无需等待 Coordinator 重新分配。此路径定义了该元数据的保存位置。如果需要，将创建目录。	${first_location}/info_dir
druid.segmentCache.announceIntervalMillis	从缓存加载 Segment 时，发布 Segment 的频率。将此值设置为零以在发布之前等待所有 Segment 加载完成。	5000（5 秒）
druid.segmentCache.numLoadingThreads	从深度存储中并发丢弃或加载多少个 Segment。请注意，加载 Segment 的工作涉及从深度存储下载 Segment、解压它们并将其加载到内存映射位置。因此，工作并不全是 I/O 密集型的。根据 CPU 和网络负载，可以增加此配置的值。	max(1,核心数 / 6)
druid.segmentCache.numBootstrapThreads	Historical 启动期间并发加载的 Segment 数量。	druid.segmentCache.numLoadingThreads
druid.segmentCache.lazyLoadOnStart	是否在 Historical 启动期间延迟加载 Segment 列元数据。当设置为 true 时，Historical 启动时间将大幅缩短，方法是将 Segment 加载推迟到该 Segment 首次参与查询时，从而导致在此过程中产生此成本。	false
druid.segmentCache.numThreadsToLoadSegmentsIntoPageCacheOnDownload	在 Historical 服务完成引导后，每个新 Segment 下载时，将 Segment 索引文件异步读取到 null 输出流中的线程数。建议设置为 1 或 2，或留空以禁用。另请参阅 druid.segmentCache.numThreadsToLoadSegmentsIntoPageCacheOnBootstrap	0
druid.segmentCache.numThreadsToLoadSegmentsIntoPageCacheOnBootstrap	在 Historical 服务引导期间，将 Segment 索引文件异步读取到 null 输出流中的线程数。此线程池在 Historical 服务完成引导后终止。建议设置为可用核心数的一半。如果未指定，将使用 druid.segmentCache.numThreadsToLoadSegmentsIntoPageCacheOnDownload。如果两个配置均未指定，则禁用此功能。预先将 Segment 加载到页面缓存中是有帮助的，因为稍后当查询 Segment 时，它已经在页面缓存中，只需触发较小的页面错误，而不是代价更高的严重页面错误，从而使查询延迟更一致。请注意，将 Segment 加载到页面缓存中只是对 Segment 索引文件进行盲加载，并且当本地磁盘上的总 Segment 大小大于 RAM 中可用的页面缓存时，操作系统将酌情从页面缓存中驱逐任何现有 Segment，该大小大致等于主机上的总可用 RAM - druid 进程内存（包括堆和直接内存） - 主机上其他非 druid 进程使用的内存，因此用户有责任确保主机拥有足够的 RAM 来承载所有 Segment，以避免随机驱逐，从而充分利用此功能。	druid.segmentCache.numThreadsToLoadSegmentsIntoPageCacheOnDownload

在 druid.segmentCache.locations 中，添加了 freeSpacePercent，因为 maxSize 设置只是一个理论上的限制，并假设始终有那么多空间可用于存储 Segment。如果任何 Druid 错误导致磁盘上留有未计入的 Segment 文件，或者其他服务向磁盘写入数据，此检查可以在磁盘完全填满之前尽早开始失败 Segment 加载，从而使主机保持可用状态。

在 druid.segmentCache.locationSelector.strategy 中，可以指定 leastBytesUsed、roundRobin、random 或 mostAvailableSize 中的一个来代表跨多个 Segment 缓存位置分发 Segment 的策略。

策略	描述
leastBytesUsed	选择绝对使用字节数最少的位置。
roundRobin	以轮询方式选择位置，不考虑使用的字节数或容量。
random	每次在可用存储位置中随机选择一个 Segment 缓存位置。
mostAvailableSize	选择在可用存储位置中剩余空间最大的 Segment 缓存位置。

请注意，如果 druid.segmentCache.numLoadingThreads > 1，多个线程可以同时下载不同的 Segment。在这种情况下，使用 leastBytesUsed 策略或 mostAvailableSize 策略，Historical 服务可能会选择次优的存储位置，因为每个决定都基于请求下载 Segment 时的存储位置状态快照。

Historical 查询配置

并发请求

Druid 使用 Jetty 来服务 HTTP 请求。

属性	描述	默认值
druid.server.http.numThreads	HTTP 请求的线程数。	max(10, (核心数 * 17) / 16 + 2) + 30
druid.server.http.queueSize	Jetty 服务器使用的用于临时存储传入客户端连接的工作队列大小。如果设置了此值且因为队列已满而被 jetty 拒绝请求，客户端将观察到请求失败，TCP 连接会立即关闭，服务器返回完全为空的响应。	无界
druid.server.http.maxIdleTime	连接的 Jetty 最大空闲时间。	PT5M
druid.server.http.enableRequestLimit	如果启用，则不会在 jetty 队列中排队任何请求，并将发送 "HTTP 429 Too Many Requests" 错误响应。	false
druid.server.http.defaultQueryTimeout	查询超时（毫秒），超过此时间未完成的查询将被取消	300000
druid.server.http.gracefulShutdownTimeout	Jetty 在接收到关闭信号后等待的最大时间。在此超时后，线程将被强制关闭。这允许正在执行的查询完成（仅大于零的值有效）。	PT30S
druid.server.http.unannouncePropagationDelay	在关闭 Jetty 之前等待 ZooKeeper 取消发布（unannouncement）传播的时间。这是一个最小值，druid.server.http.gracefulShutdownTimeout 只有在此周期过后才开始计时。	PT0S（不等待）
druid.server.http.maxQueryTimeout	timeout 参数允许的最大值（毫秒）。请参阅 查询上下文 以了解有关 timeout 的更多信息。如果查询上下文中的 timeout 大于此值，查询将被拒绝。	Long.MAX_VALUE
druid.server.http.maxRequestHeaderSize	请求头的最大大小（字节）。较大的 header 会消耗更多内存，并可能使服务器更容易受到拒绝服务攻击。	8 * 1024
druid.server.http.contentSecurityPolicy	在每个非 POST 响应上设置的 Content-Security-Policy header 值。将此属性设置为空字符串或省略它，都会导致设置默认的 frame-ancestors: none。	frame-ancestors 'none'

处理

属性	描述	默认值
druid.processing.buffer.sizeBytes	此配置指定用于存储中间结果的缓冲区大小（小于 2GiB）。Historical 和 Realtime 进程中的计算引擎将使用此大小的暂存缓冲区在堆外执行所有中间计算。较大的值允许在对数据进行单次传递时进行更多的聚合，而较小的值则可能需要根据正在执行的查询进行更多次传递。支持 人类可读格式。	auto（最大 1GiB）
druid.processing.buffer.poolCacheMaxCount	处理缓冲区池会缓存缓冲区以供后续使用，这是缓存将增长到的最大数量。请注意，如果需要，池创建的缓冲区数量可能会超过其缓存的数量。	Integer.MAX_VALUE
druid.processing.formatString	Realtime 和 Historical 进程使用此格式字符串来命名其处理线程。	processing-%s
druid.processing.numMergeBuffers	可用于合并查询结果的直接内存缓冲区数量。缓冲区的缓冲区大小由 druid.processing.buffer.sizeBytes 指定。此属性实际上是需要合并缓冲区的查询的并发限制。如果您使用的任何查询需要合并缓冲区（目前仅 groupBy），则应至少设置两个。	max(2, druid.processing.numThreads / 4)
druid.processing.numThreads	可用于并行处理 Segment 的处理线程数量。我们的经验法则是 num_cores - 1，这意味着即使在重负载下，仍有一个核心可用于执行诸如与 ZooKeeper 通信和下载 Segment 等后台任务。如果只有一个核心可用，此属性默认为 1。	核心数 - 1（或 1）
druid.processing.numTimeoutThreads	用于处理 Segment 查询超时的处理线程数量。将此值设置为 0 会移除服务于 Segment 级超时的能力，而不受 perSegmentTimeout 查询上下文参数的影响。由于这些线程仅服务于计时器，建议将此值设置为 Historical 可用的总查询处理核心的一小部分（例如 5%）。	0
druid.processing.fifo	处理队列是否应以 FIFO 方式处理优先级相同的任务	true
druid.processing.tmpDir	处理查询时创建的临时文件的存储路径。如果指定，此配置的优先级高于默认的 java.io.tmpdir 路径。	由 java.io.tmpdir 表示的路径
druid.processing.parallelPoolInit	（实验性）允许在进程启动时并行分配所有合并/处理内存池。如果分配多个大缓冲区，这可以显著加快 Historical/Broker 启动时间。	false

Druid 所需的直接内存量至少为 druid.processing.buffer.sizeBytes * (druid.processing.numMergeBuffers + druid.processing.numThreads + 1)。您可以通过在命令行提供 -XX:MaxDirectMemorySize=<VALUE> 来确保至少提供此数量的直接内存。

Historical 查询配置

请参阅 通用查询配置。

Historical 缓存

您可以通过在此处设置缓存配置来选择性地仅在 Historical 上启用缓存。

属性	可能的值	描述	默认值
druid.historical.cache.useCache	true, false	在 Historical 上启用缓存。	false
druid.historical.cache.populateCache	true, false	在 Historical 上填充缓存。	false
druid.historical.cache.unCacheable	所有 druid 查询类型	不缓存的所有查询类型。	[scan]
druid.historical.cache.maxEntrySize	正整数	最大缓存条目大小（字节）。	1_000_000

有关如何配置缓存设置的信息，请参阅 缓存配置。

Query 服务器

本节包含建议的 三服务器配置 中驻留在查询服务器（Broker）上的服务的配置选项。

此处还提供了 Router 进程 的配置选项。

Broker

有关 Broker 进程的常规信息，请参阅 此处。

这些 Broker 配置可以在 broker/runtime.properties 文件中定义。

Broker 进程配置

属性	描述	默认值
druid.host	当前进程的主机。这用于发布当前进程的位置，以便从其他进程访问，通常应指定为使得 http://${druid.host}/ 实际上可以与该进程通信	InetAddress.getLocalHost().getCanonicalHostName()
druid.bindOnHost	指示进程的内部 jetty 服务器是否绑定在 druid.host 上。默认为 false，这意味着绑定到所有接口。	false
druid.plaintextPort	实际监听的端口；除非使用端口映射，否则这将是与 druid.host 上的端口相同的端口。	8082
druid.tlsPort	HTTPS 连接器的 TLS 端口，如果设置了 druid.enableTlsPort，则将使用此配置。如果 druid.host 包含端口，则该端口将被忽略。这应该是一个非负整数。	8282
druid.service	服务的名称。在发出指标和告警时用作维度，以区分各种服务	druid/broker
druid.labels	定义服务器自定义标签的键值对的可选 JSON 对象。这些标签显示在 Web 控制台的“服务”选项卡下。示例：druid.labels={"location":"Airtrunk"} 或 druid.labels.location=Airtrunk	null

查询配置

查询路由

属性	可能的值	描述	默认值
druid.broker.balancer.type	random, connectionCount	确定 Broker 如何平衡到 Historical 进程的连接。 random 随机选择，connectionCount 选择具有最少活动连接数的进程	random
druid.broker.select.tier	highestPriority, lowestPriority, custom, preferred	如果 Segment 在集群中的多层之间进行交叉复制，您可以告诉 Broker 倾向于选择具有特定优先级的层中的 Segment。	highestPriority
druid.broker.select.tier.custom.priorities	整数优先级的数组，例如 [-1, 0, 1, 2]	选择具有自定义优先级列表的层中的服务器。	该配置仅在 druid.broker.select.tier 设置为 custom 时生效。如果 druid.broker.select.tier 设置为 custom 但未指定此配置，则效果与将 druid.broker.select.tier 设置为 highestPriority 相同。如果没有任何相应的层具有此类优先级，此配置中的任何整数都可能被忽略。在此配置中明确指定优先级的层总是比未指定的层具有更高的优先级，而未指定的层退回到它们之间使用 highestPriority 策略。
druid.broker.select.tier.preferred.tier	首选层名称。例如，_default_tier	指定查询时将从中挑选 Historical 服务器的首选层的非空值。如果首选层中的 Historical 服务器不足，将选择其他层（如果有）的服务器。此配置仅在 druid.broker.select.tier 设置为 preferred 时生效	null
druid.broker.select.tier.preferred.priority	highest, lowest	如果首选层中有多个候选者，则指定挑选候选者的优先级。默认情况下，Historical 的优先级越高，被挑选的机会就越大。此配置仅在 druid.broker.select.tier 设置为 preferred 时生效	highest

查询优先级和通道（Laning）

通道策略允许您控制异构查询工作负载的容量利用率。通过通道（laning），Broker 检查并分类查询，以便将其分配到特定通道。通道具有由 Broker 强制执行的容量限制，可用于确保为其他通道或交互式查询（无通道）留出足够的资源，或限制通道内查询的整体吞吐量。超出容量的请求将被丢弃，并返回 HTTP 429 状态码。

属性	描述	默认值
druid.query.scheduler.numThreads	最大并发运行查询数。当此参数设置得低于 druid.server.http.numThreads 时，超出限制的查询请求将被放入 Jetty 请求队列中。这具有为非查询请求保留剩余 Jetty 线程的效果。 当此参数设置为等于或高于 druid.server.http.numThreads 时，它无效。	无界
druid.query.scheduler.laning.strategy	用于将查询分配到通道以控制特定类别查询容量的查询通道策略。	无
druid.query.scheduler.prioritization.strategy	自动分配优先级的查询优先级策略。	manual

优先级策略

手动优先级策略

使用此配置，查询永远不会自动分配优先级，但会保留在 查询上下文 中通过 priority 键手动设置的优先级。此模式可以通过将 druid.query.scheduler.prioritization.strategy 设置为 manual 来显式设置。

阈值优先级策略

此优先级策略降低了超过可配置阈值集（例如数据过期程度、查询覆盖的时间间隔大小或查询涉及的 Segment 数量）的查询的优先级。

可以通过将 druid.query.scheduler.prioritization.strategy 设置为 threshold 来启用此策略。

属性	描述	默认值
druid.query.scheduler.prioritization.periodThreshold	在自动调整查询优先级之前，可查询多旧数据的 ISO 持续时间阈值。	无
druid.query.scheduler.prioritization.durationThreshold	在自动调整优先级之前，查询间隔可跨越的最大持续时间的 ISO 持续时间阈值。	无
druid.query.scheduler.prioritization.segmentCountThreshold	在自动调整优先级之前，查询可涉及的最大 Segment 数量的数字阈值。	无
druid.query.scheduler.prioritization.segmentRangeThreshold	在自动调整优先级之前，查询可跨越的最大 Segment 范围的 ISO 持续时间阈值。	无
druid.query.scheduler.prioritization.adjustment	降低超过任何阈值的查询优先级的幅度。	5

通道（Laning）策略

无通道策略

在此模式下，查询永远不会分配到通道，并发查询计数仅受 druid.server.http.numThreads 或 druid.query.scheduler.numThreads（如果已设置）限制。这是默认的 Druid 查询调度程序操作模式。通过将 druid.query.scheduler.laning.strategy 设置为 none 来显式启用此策略。

'高/低'通道策略

此通道策略自动将 priority 低于零的查询拆分为 low 查询通道。优先级为零（默认值）或更高的查询被视为“交互式”。对 low 查询的限制可以设置为总容量（或 HTTP 线程池大小）的某个期望百分比，从而为交互式查询保留容量。low 通道中的查询不保证其容量，该容量可能被交互式查询消耗，但如果总容量可用，则可以使用到此限制。

如果 low 通道在 查询上下文 lane 参数中指定，这将覆盖计算出的通道。

可以通过将 druid.query.scheduler.laning.strategy=hilo 设置来启用此策略。

属性	描述	默认值
druid.query.scheduler.laning.maxLowPercent	定义可被优先级低于 0 的查询使用的 HTTP 线程数的 druid.server.http.numThreads 或 druid.query.scheduler.numThreads 较小值的最大百分比。值必须是 1 到 100 之间的整数，并将向上取整	无默认值，如果使用此模式则必须设置

子查询物化保护栏

Druid 将子查询行存储在驻留在 Java 堆中的临时表中。在 Druid 中避免大型子查询是一个很好的做法。因此，Druid 内置了保护栏，以防止查询生成可能耗尽堆空间的子查询结果。它们可以在集群级别设置，也可以根据需要按查询级别修改。请注意集群管理员可以设置以下保护栏来限制子查询结果

1. Broker 配置中的 druid.server.http.maxSubqueryRows 用于设置整个集群的默认值，或查询上下文中的 maxSubqueryRows 用于设置子查询可以生成的行的上限
2. Broker 配置中的 druid.server.http.maxSubqueryBytes 用于设置整个集群的默认值，或查询上下文中的 maxSubqueryBytes 用于设置子查询可以生成的字节数的上限

按字节限制子查询是一个实验性功能，因为它以不同的方式物化结果。

您可以将 maxSubqueryBytes 配置为以下值

• disabled: 这是开箱即用的默认设置。它禁用了子查询的基于字节的限制，并有效地禁用了此功能。
• auto: Druid 根据可用堆空间和最大并发查询数自动决定最佳的基于字节的限制。
• 正长整型值: 用户可以手动指定单个查询的子查询结果在堆上可以占用的字节数。

由于 Java 对象和 Frame 格式之间的转换，如果子查询开始生成 1000 万行及以上数量级的行，设置 maxSubqueryBytes 可能会变慢。在这种情况下，请为此类查询禁用 maxSubqueryBytes 设置，评估子查询生成的行数，并将 maxSubqueryRows 覆盖为适当的值。

如果您选择修改或设置上述任何限制，您还必须考虑所有处理子查询数据的 Brokers、Historicals 和任务 Peons 的堆大小，以容纳子查询结果。没有计算正确值的公式。试错是最好的方法。

手动通道策略

此通道策略最适合查询 Druid 的一个或多个外部应用程序能够手动决定给定查询应属于哪个通道的情况。配置了通道名称到百分比或确切最大容量的映射，查询上下文 中具有匹配 lane 参数的查询将受到这些限制。

属性	描述	默认值
druid.query.scheduler.laning.lanes.{name}	可在定义通道中并发运行的最大查询百分比或确切限制。可以定义任意数量的通道。通道名称 'total' 和 'default' 保留用于内部使用。	无默认值，必须至少定义一个限制大于 0 的通道。如果 druid.query.scheduler.laning.isLimitPercent 设置为 true，则值必须是 1 到 100 范围内的整数。
druid.query.scheduler.laning.isLimitPercent	如果设置为 true，则为 druid.query.scheduler.laning.lanes 设置的值将被视为 druid.server.http.numThreads 或 druid.query.scheduler.numThreads 较小值的百分比。请注意，在此模式下，这些通道值之和不要求相加，并且可以超过 100%。	false

服务器配置

Druid 使用 Jetty 来服务 HTTP 请求。正在处理的每个查询都会消耗来自 druid.server.http.numThreads 的单个线程，因此考虑将 druid.query.scheduler.numThreads 设置为较低的值，以便为响应健康检查、查找加载和其他非查询（在大多数情况下）生命周期非常短的 HTTP 请求预留 HTTP 线程。

属性	描述	默认值
druid.server.http.numThreads	HTTP 请求的线程数。	max(10, (核心数 * 17) / 16 + 2) + 30
druid.server.http.queueSize	Jetty 服务器使用的用于临时存储传入客户端连接的工作队列大小。如果设置了此值且因为队列已满而被 jetty 拒绝请求，客户端将观察到请求失败，TCP 连接会立即关闭，服务器返回完全为空的响应。	无界
druid.server.http.maxIdleTime	连接的 Jetty 最大空闲时间。	PT5M
druid.server.http.enableRequestLimit	如果启用，则不会在 jetty 队列中排队任何请求，并将发送 "HTTP 429 Too Many Requests" 错误响应。	false
druid.server.http.defaultQueryTimeout	查询超时（毫秒），超过此时间未完成的查询将被取消	300000
druid.server.http.maxScatterGatherBytes	从诸如 Historical 和实时进程等数据进程中收集以执行查询的最大字节数。超过此限制的查询将失败。这是一个高级配置，允许在 Broker 处于重负载下且没有足够快地利用内存中收集的数据并导致 OOM 时进行保护。此限制可以在查询时使用上下文中的 maxScatterGatherBytes 进一步降低。请注意，如果 Broker 从未处于高并发负载下，则较大的限制不一定不好，在这种情况下，收集的数据会很快被处理，从而释放所使用的内存。支持人类可读格式，请参阅 此处。	Long.MAX_VALUE
druid.server.http.maxSubqueryRows	每个查询中所有子查询的最大行数。Druid 将子查询行存储在驻留在 Java 堆中的临时表中。 druid.server.http.maxSubqueryRows 是一个保护栏，旨在防止系统耗尽可用堆。当子查询超过行限制时，Druid 会抛出资源限制超出异常：“Subquery generated results beyond maximum.” 在 Druid 中避免大型子查询是一个很好的做法。但是，如果您选择提高子查询行限制，您还必须增加所有处理子查询数据的 Brokers、Historicals 和任务 Peons 的堆大小，以容纳子查询结果。 没有计算正确值的公式。试错是最好的方法。	100000
druid.server.http.maxSubqueryBytes	每个查询中所有子查询的最大字节数。由于结果存储在 Java 堆上，druid.server.http.maxSubqueryBytes 就像 druid.server.http.maxSubqueryRows 一样是一个保护栏，以防止堆空间耗尽。当子查询超过字节限制时，Druid 会抛出资源限制超出异常。此保护栏的负值表示 Druid 不会按内存进行保护栏限制。可以将其设置为 'disabled'（禁用通过字节限制结果）、'auto'（考虑可用堆空间自动设置此值）或一个正长整型值（表示单个查询的子查询结果可以占用的字节数）。这是目前的实验性功能，因为它以不同的格式物化结果。	'disabled'
druid.server.http.gracefulShutdownTimeout	Jetty 在接收到关闭信号后等待的最大时间。在此超时后，线程将被强制关闭。这允许正在执行的查询完成（仅大于零的值有效）。	PT30S
druid.server.http.unannouncePropagationDelay	在关闭 Jetty 之前等待 ZooKeeper 取消发布（unannouncement）传播的时间。这是一个最小值，druid.server.http.gracefulShutdownTimeout 只有在此周期过后才开始计时。	PT0S（不等待）
druid.server.http.maxQueryTimeout	timeout 参数允许的最大值（毫秒）。请参阅 查询上下文 以了解有关 timeout 的更多信息。如果查询上下文中的 timeout 大于此值，查询将被拒绝。	Long.MAX_VALUE
druid.server.http.maxRequestHeaderSize	请求头的最大大小（字节）。较大的 header 会消耗更多内存，并可能使服务器更容易受到拒绝服务攻击。	8 * 1024
druid.server.http.contentSecurityPolicy	在每个非 POST 响应上设置的 Content-Security-Policy header 值。将此属性设置为空字符串或省略它，都会导致设置默认的 frame-ancestors: none。	frame-ancestors 'none'
druid.server.http.enableHSTS	如果设置为 true，druid 服务将向所有 HTTP 响应添加严格传输安全 header Strict-Transport-Security: max-age=63072000; includeSubDomains	false

客户端配置

Druid Brokers 使用 HTTP 客户端与数据服务器（Historical 服务器和实时任务）进行通信。此客户端具有以下配置选项。

属性	描述	默认值
druid.broker.http.numConnections	Broker 连接到 Historical 和实时进程的连接池大小。如果有超过此数量的查询都需要与同一个进程对话，那么它们将排队等待。	20
druid.broker.http.eagerInitialization	指示应尽早初始化从 Broker 到 Historical 和实时进程的 http 连接。如果设置为 true，则在初始化时创建 numConnections 个连接	true
druid.broker.http.compressionCodec	Broker 用于与 Historical 和实时进程通信的压缩编解码器。可以是 "gzip" 或 "identity"。	gzip
druid.broker.http.readTimeout	来自 Historical 服务器和实时任务的数据读取超时时间。	PT15M
druid.broker.http.unusedConnectionTimeout	连接池中空闲连接的超时时间。池中的连接在此超时后将关闭，并将建立新的连接。此超时时间应小于 druid.broker.http.readTimeout。将此超时时间设置为 = druid.broker.http.readTimeout 的 ~90%	PT4M
druid.broker.http.maxQueuedBytes	在对数据服务器的通道施加 背压（backpressure） 之前，每个查询排队的最大字节数。 类似于 druid.server.http.maxScatterGatherBytes，不同之处在于 maxQueuedBytes 触发 背压 而不是查询失败。设置为零可禁用。您可以通过使用 maxQueuedBytes 查询上下文参数 来覆盖此设置。Druid 支持 人类可读 格式。	25 MB 或 Broker 最大堆大小的 2%，以较大者为准。
druid.broker.http.numMaxThreads	I/O 工作线程的最大数量	(核心数) * 3 / 2 + 1
druid.broker.http.clientConnectTimeout	建立客户端连接的超时时间（以毫秒为单位）。	500

重试策略

Druid broker 可以选择为瞬时错误在内部重试查询。

属性	描述	默认值
druid.broker.retryPolicy.numTries	尝试次数。	1

处理

Broker 将处理配置用于嵌套 groupBy 查询。

属性	描述	默认值
druid.processing.buffer.sizeBytes	指定用于存储中间结果的缓冲区大小（小于 2GiB）。Historical 和 Realtime 进程中的计算引擎将使用此大小的暂存缓冲区在堆外执行所有中间计算。较大的值允许在对数据进行单次传递时进行更多的聚合，而较小的值则可能需要根据正在执行的查询进行更多次传递。支持 人类可读格式。	auto（最大 1GiB）
druid.processing.buffer.poolCacheInitialCount	初始化分配在中间结果池上的缓冲区数量。请注意，如果需要，池可以创建更多缓冲区。	0
druid.processing.buffer.poolCacheMaxCount	处理缓冲区池会缓存缓冲区以供后续使用，这是缓存将增长到的最大数量。请注意，如果需要，池创建的缓冲区数量可能会超过其缓存的数量。	Integer.MAX_VALUE
druid.processing.numMergeBuffers	可用于合并查询结果的直接内存缓冲区数量。缓冲区的缓冲区大小由 druid.processing.buffer.sizeBytes 指定。此属性实际上是需要合并缓冲区的查询的并发限制。如果您使用的任何查询需要合并缓冲区（目前仅 groupBy），则应至少设置两个。	max(2, druid.processing.numThreads / 4)
druid.processing.fifo	处理队列是否应以 FIFO 方式处理优先级相同的任务	true
druid.processing.tmpDir	处理查询时创建的临时文件的存储路径。如果指定，此配置的优先级高于默认的 java.io.tmpdir 路径。	由 java.io.tmpdir 表示的路径
druid.processing.merge.useParallelMergePool	为 Broker 启用专用异步 ForkJoinPool 上的自动并行合并。如果为 false，合并将在 HTTP 线程池上串行完成。	true
druid.processing.merge.parallelism	ForkJoinPool 的大小。请注意，默认配置假设 Runtime.getRuntime().availableProcessors() 返回的值代表每个物理核心 2 个超线程，并将此值乘以 0.75 以尝试将其调整为物理核心数的 1.5 倍。	Runtime.getRuntime().availableProcessors() * 0.75（向上取整）
druid.processing.merge.defaultMaxQueryParallelism	每个查询的默认最大并行合并任务数。请注意，默认配置假设 Runtime.getRuntime().availableProcessors() 返回的值代表每个物理核心 2 个超线程，并将此值乘以 0.5 以尝试将其调整为物理核心数。	Runtime.getRuntime().availableProcessors() * 0.5（向上取整）
druid.processing.merge.awaitShutdownMillis	在进程关闭时非优雅停止之前，等待合并 ForkJoinPool 任务完成的时间（毫秒）。	60_000
druid.processing.merge.targetRunTimeMillis	在分叉新任务以继续合并序列之前，每个 ForkJoinPool 合并任务的理想运行时间。	100
druid.processing.merge.initialYieldNumRows	在分叉新任务以继续合并序列之前，每个 ForkJoinPool 合并任务产生的行数。	16384
druid.processing.merge.smallBatchNumRows	ForkJoinPool 合并任务中操作的结果批次大小。	4096

Druid 所需的直接内存量至少为 druid.processing.buffer.sizeBytes * (druid.processing.numMergeBuffers + 1)。您可以通过在命令行提供 -XX:MaxDirectMemorySize=<VALUE> 来确保至少提供此数量的直接内存。

Broker 查询配置

请参阅 通用查询配置。

Broker 生成的查询配置补充

Broker 在内部生成查询。本配置部分描述了操作员如何扩充这些查询的配置。

目前唯一支持的扩充是覆盖默认查询上下文。这为操作员根据需要调整它提供了灵活性。此配置的常见用途是覆盖集群生成查询的查询优先级，以避免以默认优先级 0 运行。

属性	描述	默认值
druid.broker.internal.query.config.context	要添加到内部生成的 Broker 查询中的查询上下文的字符串格式 key:value 映射。	null

动态配置

Broker 具有动态配置，可以在不重启服务的情况下动态调整某些行为。您可以使用 Web 控制台（推荐）或通过 Broker 动态配置 API 配置这些参数。

SQL

Druid SQL 服务器通过 Broker 上的以下属性进行配置。

属性	描述	默认值
druid.sql.enable	是否启用 SQL，包括后台元数据获取。如果为 false，这将覆盖所有其他 SQL 相关属性，并完全禁用 SQL 元数据、服务和规划。	true
druid.sql.avatica.enable	是否在 /druid/v2/sql/avatica/ 启用 JDBC 查询。	true
druid.sql.avatica.maxConnections	Avatica 服务器的最大打开连接数。这些不是 HTTP 连接，而是可能跨越多个 HTTP 连接的逻辑客户端连接。	25
druid.sql.avatica.maxRowsPerFrame	JDBC 客户端 Statement.setFetchSize 方法的可接受最大值。此设置决定了 Druid 为 JDBC ResultSet 在单次 'fetch' 中填充的最大行数。将此属性设置为 -1 可强制服务器端无行限制，并可能在初始语句执行时返回整个行集。如果 JDBC 客户端调用 Statement.setFetchSize 且值不是 -1，Druid 将使用客户端提供限制和 maxRowsPerFrame 中的较小值。如果 maxRowsPerFrame 小于 minRowsPerFrame，则 ResultSet 大小将固定。要处理产生大量行结果的查询，可以增加 druid.sql.avatica.maxRowsPerFrame 的值以减少完全传输结果集所需的提取次数。	5,000
druid.sql.avatica.minRowsPerFrame	JDBC 客户端 Statement.setFetchSize 方法的可接受最小值。此属性的值必须大于 0。如果 JDBC 客户端调用 Statement.setFetchSize 且值较小，Druid 将改为使用 minRowsPerFrame。如果 maxRowsPerFrame 小于 minRowsPerFrame，Druid 将使用两者的最小值。对于处理产生大量行结果的查询，可以增加此值以减少完全传输结果集所需的提取次数。	100
druid.sql.avatica.maxStatementsPerConnection	每个 Avatica 客户端连接的最大同时打开语句数。	4
druid.sql.avatica.connectionIdleTimeout	Avatica 客户端连接空闲超时。	PT5M
druid.sql.avatica.fetchTimeoutMs	Avatica 获取超时（毫秒）。当请求下一批数据的时间超过此时间时，Druid 会返回一个空结果集，导致客户端再次轮询。这避免了长时间运行查询的 HTTP 超时。默认的 5 秒在大多数情况下是好的。	5000
druid.sql.http.enable	是否在 /druid/v2/sql/ 启用 HTTP 上的 JSON 查询。	true
druid.sql.planner.maxTopNLimit	TopN 查询的阈值。较高的限制将被规划为 GroupBy 查询。	100000
druid.sql.planner.metadataRefreshPeriod	元数据刷新的节流阀。	PT1M
druid.sql.planner.metadataColumnTypeMergePolicy	定义计算 SQL 架构时在 Segment 之间存在差异时如何选择列类型。选项指定为 JSON 对象，有效选择为 leastRestrictive 或 latestInterval。对于 leastRestrictive，Druid 会自动将为架构计算的类型加宽到所有 Segment 的数据都可以转换为的类型，但计划的架构迁移只有在所有 Segment 都已重新摄取到新架构后才能生效。使用 latestInterval，最新时间块中的列类型定义了架构的类型。	leastRestrictive
druid.sql.planner.useApproximateCountDistinct	是否对 COUNT(DISTINCT foo) 使用近似基数算法。	true
druid.sql.planner.useGroupingSetForExactDistinct	仅在禁用 useApproximateCountDistinct 时相关。如果设置为 true，精确的去重查询将使用分组集重写。否则，精确的去重查询将使用连接重写。对于具有多个精确去重聚合的 group by 查询，应将其设置为 true。此标志可以按查询覆盖。	false
druid.sql.planner.useApproximateTopN	当 SQL 查询可以表示为此类时，是否使用近似 TopN 查询。如果为 false，则将使用精确的 GroupBy 查询。	true
druid.sql.planner.useLexicographicTopN	是否使用具有字典维度顺序的 TopN 查询。如果为 false，则字典排序将改为使用 GroupBy 查询。当此属性和 useApproximateTopN 均为 false 时，永不使用 TopN 查询。	false
druid.sql.planner.requireTimeCondition	是否要求 SQL 在 __time 列上有过滤条件，以便所有生成的原生查询都具有用户指定的时间间隔。如果为 true，所有在 __time 列上没有过滤条件的查询都将失败	false
druid.sql.planner.sqlTimeZone	设置服务器的默认时区，这将影响时间函数和时间戳文字的表现方式。应为类似 "America/Los_Angeles" 的时区名称或类似 "-08:00" 的偏移量。	UTC
druid.sql.planner.metadataSegmentCacheEnable	是否在 Broker 上保留已发布 Segment 的缓存，该缓存可用于针对 sys.segments 提供查询。如果为 true，Broker 在后台轮询 Coordinator 以从元数据存储中获取 Segment 并维护本地缓存。如果为 false，则在 Broker 需要已发布 Segment 信息时将调用 Coordinator 的 REST API。	true
druid.sql.planner.metadataSegmentPollPeriod	如果将 druid.sql.planner.metadataSegmentCacheEnable 设置为 true，则轮询 Coordinator 以获取已发布 Segment 列表的频率。轮询周期以毫秒为单位。	60000
druid.sql.planner.authorizeSystemTablesDirectly	如果为 true，Druid 会授权对任何系统架构表（SQL 中的 sys）进行查询，将其作为需要 READ 访问权限的 SYSTEM_TABLE 资源，此外还基于权限的内容过滤。	false
druid.sql.planner.useNativeQueryExplain	如果为 true，EXPLAIN PLAN FOR 将返回执行计划作为等效原生查询的 JSON 表示，否则将返回由 Calcite 生成的原始版本执行计划。可以使用 useNativeQueryExplain 上下文键按查询覆盖它。	true
druid.sql.planner.maxNumericInFilters	当查询的整个 SQL WHERE 子句转换为 Bound filter 的 OR 时，可为字符串类型维度比较的数值的最大限制。默认情况下，Druid 不限制 String 列上的数值 Bound Filter 数量，尽管这种情况可能会阻止其他查询运行。将此属性设置为较小的值可防止 Druid 运行具有过长 Segment 处理时间的查询。最佳限制需要一些试错；我们建议从 100 开始。提交超出 maxNumericInFilters 限制查询的用户应改为重写查询，在 WHERE 子句中使用字符串而不是数字。例如， WHERE someString IN (‘123’, ‘456’)。如果此值被禁用，查询上下文中设置的 maxNumericInFilters 将被忽略。	-1（禁用）
druid.sql.approxCountDistinct.function	用于 APPROX_COUNT_DISTINCT 函数 的实现。如果没有加载扩展，唯一有效的值是 APPROX_COUNT_DISTINCT_BUILTIN（一种基于 HyperLogLog 或 HLL 的实现）。如果加载了 DataSketches 扩展，这也可以是 APPROX_COUNT_DISTINCT_DS_HLL（替代 HLL 实现）或 APPROX_COUNT_DISTINCT_DS_THETA。 Theta sketches 比 HLL sketches 消耗更多的内存，因此您应该优先使用两种 HLL 实现之一。	APPROX_COUNT_DISTINCT_BUILTIN
druid.sql.planner.enableSysQueriesTable	实验性。 是否启用 sys.queries 表，该表提供有关当前正在运行和最近完成的 SQL 查询的信息。目前仅显示来自 Dart (MSQ) 引擎的查询。	false

信息

旧版本的 Druid 具有名为 druid.sql.planner.maxQueryCount 和 druid.sql.planner.maxSemiJoinRowsInMemory 的属性。这些属性不再可用。自 Druid 0.18.0 起，您可以使用 druid.server.http.maxSubqueryRows 来控制所有子查询允许的最大行数。

Broker 缓存

您可以通过在此处设置缓存配置来选择性地仅在 Broker 上启用缓存。

属性	可能的值	描述	默认值
druid.broker.cache.useCache	true, false	在 Broker 上启用缓存。	false
druid.broker.cache.populateCache	true, false	在 Broker 上填充缓存。	false
druid.broker.cache.useResultLevelCache	true, false	在 Broker 上启用结果级缓存。	false
druid.broker.cache.populateResultLevelCache	true, false	在 Broker 上填充结果级缓存。	false
druid.broker.cache.resultLevelCacheLimit	正整数	可缓存的查询响应的最大大小。	Integer.MAX_VALUE
druid.broker.cache.unCacheable	所有 druid 查询类型	不缓存的所有查询类型。	[scan]
druid.broker.cache.cacheBulkMergeLimit	正整数或 0	涉及的 Segment 数量超过此数量的查询将不会尝试在 Broker 级别从缓存中提取，将潜在的缓存提取（和缓存结果合并）留给 Historical 服务	Integer.MAX_VALUE
druid.broker.cache.maxEntrySize	正整数	最大缓存条目大小（字节）。	1_000_000

有关如何配置缓存设置的信息，请参阅 缓存配置。

信息

注意：即使启用了缓存，对于 groupBy 查询，Segment 级缓存也不适用于 Broker。有关更多信息，请参阅 查询缓存。

Segment 发现

属性	可能的值	描述	默认值
druid.serverview.type	batch 或 http	使用的分片发现方法。“http” 支持使用 HTTP 而非 ZooKeeper 来发现分片。	http
druid.broker.segment.watchedTiers	字符串列表	Broker 监视服务 Segment 的进程的 Segment 公告，以建立一个将每个进程与其所服务 Segment 相关联的缓存。此配置允许 Broker 仅考虑从层列表中服务的 Segment。默认情况下，Broker 考虑所有层。这可用于将您的 dataSources 分区到特定的 Historical 层中，并将 brokers 配置为分区，以便它们仅可针对特定的 dataSources 进行查询。此配置与 druid.broker.segment.ignoredTiers 互斥，并且在 Broker 上最多只能配置其中一个。	无
druid.broker.segment.ignoredTiers	字符串列表	Broker 监视服务 Segment 的进程的 Segment 公告，以建立一个将每个进程与其所服务 Segment 相关联的缓存。此配置允许 Broker 忽略从层列表中服务的 Segment。默认情况下，Broker 考虑所有层。此配置与 druid.broker.segment.watchedTiers 互斥，并且在 Broker 上最多只能配置其中一个。	无
druid.broker.segment.watchedDataSources	字符串列表	Broker 监视服务 Segment 的进程的 Segment 公告，以建立有关哪个进程正在服务哪些 Segment 的缓存，此配置允许仅考虑从数据源白名单中服务的 Segment。默认情况下，Broker 会考虑所有数据源。这可用于将 brokers 配置为分区，以便它们仅可针对特定的 dataSources 进行查询。	无
druid.broker.segment.watchRealtimeTasks	布尔值	Broker 监视服务 Segment 的进程的 Segment 公告，以建立一个将每个进程与其所服务 Segment 相关联的缓存。当 watchRealtimeTasks 为 true 时，Broker 监视来自 Historical 和实时进程的 Segment 公告。要将 Broker 配置为排除由实时进程服务的 Segment，请将 watchRealtimeTasks 设置为 false。	true
druid.broker.segment.awaitInitializationOnStart	布尔值	Broker 在启动前是否会等待其 Segment 视图完全初始化。如果设置为 'true'，则 Broker 的 HTTP 服务器将不会启动，Broker 也不会将自己发布为可用，直到服务器视图初始化完成。另请参阅 druid.sql.planner.awaitInitializationOnStart，这是一个相关设置。	true

指标监视器

您可以将 Druid 服务配置为定期通过 发射器 从多个 监视器 发出 指标。下表列出了指标的常规配置

属性	描述	默认值
druid.monitoring.emissionPeriod	Druid 发出指标的频率。	PT1M
druid.monitoring.monitors	设置服务使用的 Druid 监视器列表。	无（无监视器）
druid.emitter	设置此值会初始化其中一个发射器模块。	noop（默认禁用指标发出）

每个服务的指标监视器

指标监控是 Druid 操作的重要组成部分。可以通过在通用配置文件 common.runtime.properties 中配置属性 druid.monitoring.monitors 来启用监视器。如果监视器在某个服务上不受支持，它将在启动该服务时直接被忽略。

下表列出了可用的监视器以及支持它们的相关服务

名称	描述	服务
org.apache.druid.client.cache.CacheMonitor	发出关于 Historical 和 Broker 服务 Segment 结果缓存的指标（到日志）。报告典型的缓存统计信息，包括命中、未命中、比率和大小（字节数和条目数），以及超时和错误。	Broker, Historical, Indexer, Peon
org.apache.druid.java.util.metrics.OshiSysMonitor	使用 OSHI（一个用于 Java 的基于 JNA 的（原生）操作系统和硬件信息库）报告各种系统活动和状态。	任意
org.apache.druid.java.util.metrics.JvmMonitor	报告各种 JVM 相关统计信息。	任意
org.apache.druid.java.util.metrics.JvmCpuMonitor	报告 JVM 的 CPU 消耗统计信息。	任意
org.apache.druid.java.util.metrics.CpuAcctDeltaMonitor	报告根据 cpuacct cgroup 消耗的 CPU。	任意
org.apache.druid.java.util.metrics.JvmThreadsMonitor	报告 JVM 中的线程统计信息，如总线程数、守护线程数、启动线程数、死亡线程数。	任意
org.apache.druid.java.util.metrics.CgroupCpuMonitor	报告根据 cpu cgroup 的 CPU 共享和配额。如果检测到 cgroupv2 类型，自动切换到 CgroupV2CpuMonitor。	任意
org.apache.druid.java.util.metrics.CgroupCpuSetMonitor	报告根据 cpuset cgroup 的 CPU 核心/HT 和内存节点分配。如果检测到 cgroupv2 类型，自动切换到 CgroupV2CpuSetMonitor。	任意
org.apache.druid.java.util.metrics.CgroupDiskMonitor	报告根据 blkio cgroup 的磁盘统计信息。如果检测到 cgroupv2 类型，自动切换到 CgroupV2DiskMonitor。	任意
org.apache.druid.java.util.metrics.CgroupMemoryMonitor	报告根据内存 cgroup 的内存统计信息。如果检测到 cgroupv2 类型，自动切换到 CgroupV2MemoryMonitor。	任意
org.apache.druid.java.util.metrics.CgroupV2CpuMonitor	报告来自 cpu.stat 文件的 CPU 使用率。仅适用于 cgroupv2。	任意
org.apache.druid.java.util.metrics.CgroupV2CpuSetMonitor	报告根据 cpuset cgroup 的 CPU 核心/HT 和内存节点分配。仅适用于 cgroupv2。	任意
org.apache.druid.java.util.metrics.CgroupV2DiskMonitor	报告来自 io.stat 文件的磁盘使用情况。仅适用于 cgroupv2。	任意
org.apache.druid.java.util.metrics.CgroupV2MemoryMonitor	报告来自 memory.current 和 memory.max 文件的内存使用情况。仅适用于 cgroupv2。	任意
org.apache.druid.server.metrics.HistoricalMetricsMonitor	报告 Historical 服务的统计信息。	Historical
org.apache.druid.server.metrics.SegmentStatsMonitor	实验性 报告有关 Historical 服务上 Segment 的统计信息。配置了延迟加载时不得使用。	Historical
org.apache.druid.server.metrics.QueryCountStatsMonitor	报告有多少查询成功/失败/中断。	Broker, Historical, Router, Indexer, Peon
org.apache.druid.server.metrics.SubqueryCountStatsMonitor	报告有多少子查询已物化为行或字节，以及与子查询执行相关的各种其他统计信息	Broker
org.apache.druid.server.emitter.HttpEmittingMonitor	报告 http 或 parametrized 发射器（见下文）的内部指标。不得与其他发射器类型一起使用。请参阅此处的指标描述： https://github.com/apache/druid/pull/4973。	任意
org.apache.druid.server.metrics.TaskCountStatsMonitor	报告当前正在运行/挂起/等待的摄入任务数量，以及每个发射周期内成功/失败的任务数量。	Overlord
org.apache.druid.server.metrics.TaskSlotCountStatsMonitor	报告每个发射周期内任务槽（Task Slot）使用情况的指标。	Overlord
org.apache.druid.server.metrics.SupervisorStatsMonitor	报告每个发射周期内每个监督者（Supervisor）的统计数量和状态。	Overlord
org.apache.druid.server.metrics.WorkerTaskCountStatsMonitor	报告每个发射周期内报告工作节点（Worker）当前正在运行/挂起/等待的摄入任务数量、成功/失败任务数量以及任务槽使用情况的指标。	MiddleManager, Indexer
org.apache.druid.server.metrics.ServiceStatusMonitor	报告服务的健康心跳。	任意
org.apache.druid.server.metrics.GroupByStatsMonitor	报告 groupBy 查询的指标，例如磁盘和合并缓冲区（merge buffer）的使用情况。	Broker, Historical, Indexer, Peon

例如，如果您只想在所有服务上监控系统和 JVM 信息，您需要将以下内容添加到 common.runtime.properties 中

druid.monitoring.monitors=["org.apache.druid.java.util.metrics.OshiSysMonitor","org.apache.druid.java.util.metrics.JvmMonitor"]

您的 Druid 部署中的所有服务都将拥有这两个监控器。

但是，如果您需要任何特定于服务的监控器，则必须将您希望在该服务上运行的所有监控器添加到该服务的 runtime.properties 文件中，即使它们已经在通用文件中列出。特定于服务的属性具有优先权。

以下示例将 TaskCountStatsMonitor、TaskSlotCountStatsMonitor 和 SupervisorStatsMonitor 以及前一个示例中的 OshiSysMonitor 和 JvmMonitor 添加到 Overlord 服务中（coordinator-overlord/runtime.properties）

druid.monitoring.monitors=["org.apache.druid.server.metrics.TaskCountStatsMonitor", "org.apache.druid.server.metrics.TaskSlotCountStatsMonitor", "org.apache.druid.server.metrics.SupervisorStatsMonitor", "org.apache.druid.java.util.metrics.OshiSysMonitor","org.apache.druid.java.util.metrics.JvmMonitor"]

如果您未在 Overlord 的 runtime.properties 文件中包含 OshiSysMonitor 和 JvmMonitor，那么即使在通用文件中指定了这些监控器，它们也不会被加载到 Overlord 上。

指标发射器（Metrics emitters）

有几种可用的发射器

• noop（默认）禁用指标发射。
• logging 使用 Log4j2 发射日志。
• http 发送 JSON 事件的 POST 请求。
• parametrized 的操作方式类似于 http 发射器，但会根据事件源（feed）微调目标 URL。
• composing 初始化多个发射器模块。
• graphite 将指标发射到 Graphite Carbon 服务。
• switching 根据事件源初始化并向多个发射器模块发射数据。

Logging 发射器模块

要使用此发射器模块，请设置 druid.emitter=logging。logging 发射器使用名为 druid.emitter.logging.loggerClass 的 Log4j2 记录器来发射事件。每个事件都被记录为单个 json 对象，并将事件源作为 Marker。用户可能希望编辑 log4j 配置，以便根据事件源将这些日志路由到不同的来源。

属性	描述	默认值
druid.emitter.logging.loggerClass	用于记录日志的类。	org.apache.druid.java.util.emitter.core.LoggingEmitter
druid.emitter.logging.logLevel	选项：debug, info, warn, error。记录消息的日志级别。	info
druid.emitter.logging.shouldFilterMetrics	当为 true 时，仅发射允许列表中的指标；非指标事件（例如警报）始终会被发射。当为 false 时，所有事件都会被记录（向后兼容）。	false
druid.emitter.logging.allowedMetricsPath	JSON 文件的路径，其键为允许的指标名称。仅在 shouldFilterMetrics 为 true 时使用。如果为 null 或空，则使用捆绑的类路径资源 loggingEmitterAllowedMetrics.json。如果设置了路径但文件丢失，则会记录警告，并且发射器将回退到默认的类路径资源。	null

HTTP 发射器模块

属性	描述	默认值
druid.emitter.http.flushMillis	内部消息缓冲区的刷新频率（即发送数据的频率）。	60000
druid.emitter.http.flushCount	缓冲区在刷新（发送）前最多可容纳的消息数量。	500
druid.emitter.http.basicAuthentication	密码提供程序，用于以 "login:password" 形式提供登录名和密码进行身份验证。例如，druid.emitter.http.basicAuthentication=admin:adminpassword 使用允许明文密码的默认密码提供程序。	未指定 = 无身份验证
druid.emitter.http.flushTimeOut	即使内部缓冲区未填满，事件也应发送到端点的超时时间（毫秒）。	未指定 = 无超时
druid.emitter.http.batchingStrategy	批处理的格式化策略。 "ARRAY" 表示 [event1,event2]，"NEWLINES" 表示 event1\nevent2，ONLY_EVENTS 表示 event1event2。	ARRAY
druid.emitter.http.maxBatchSize	最大批处理大小（字节）。	(JVM 堆大小的 10% 除以 2) 与 (5242880 (即 5 MiB)) 中的较小值
druid.emitter.http.batchQueueSizeLimit	如果发射出现问题，发射器队列中的最大批次数。	(2) 与 (JVM 堆大小的 10% 除以 5MiB) 中的较大值
druid.emitter.http.minHttpTimeoutMillis	如果批处理填充速度导致超时小于此值，则不会尝试向端点发送批处理，因为它很可能失败。根据 emitter/successfulSending/minTimeMs 指标配置此值。合理的值为 10ms..100ms。	0
druid.emitter.http.recipientBaseUrl	接收消息的基本 URL。Druid 将向此属性指定的 HTTP 端点 POST JSON 数据。	无，必需配置

HTTP 发射器模块 TLS 覆盖

默认情况下，在向启用了 TLS 的接收器发送事件时，HTTP 发射器使用从 Druid 内部通信 TLS 支持 中描述的服务获取的 SSLContext，即与用于 Druid 服务之间内部通信相同的 SSLContext。

在某些用例中，可能希望 HTTP 发射器使用其自己单独的信任库（truststore）配置。例如，某些组织策略可能禁止将启用了 TLS 的指标接收器的证书添加到 Druid 内部 HTTP 客户端所使用的同一信任库中。

以下属性允许 HTTP 发射器在构建其 SSLContext 时使用其自己的信任库配置。

属性	描述	默认值
druid.emitter.http.ssl.useDefaultJavaContext	如果设置为 true，HttpEmitter 将使用 SSLContext.getDefault()（默认的 Java SSLContext），下面的所有其他属性将被忽略。	false
druid.emitter.http.ssl.trustStorePath	存储受信任根证书的 TLS/SSL 密钥库的文件路径或 URL。如果未指定，HTTP 发射器将使用本节开头所述的与 Druid 内部 HTTP 客户端相同的 SSLContext，下面的所有其他属性将被忽略。	null
druid.emitter.http.ssl.trustStoreType	存储受信任根证书的密钥库类型。	java.security.KeyStore.getDefaultType()
druid.emitter.http.ssl.trustStoreAlgorithm	TrustManager 用于验证证书链的算法	javax.net.ssl.TrustManagerFactory.getDefaultAlgorithm()
druid.emitter.http.ssl.trustStorePassword	Trust Store 的 密码提供程序 或字符串密码。	无
druid.emitter.http.ssl.protocol	要使用的 TLS 协议。	"TLSv1.2"

参数化 HTTP 发射器模块

参数化发射器采用与 http 发射器 相同的配置，使用前缀 druid.emitter.parametrized.httpEmitting.。例如

• druid.emitter.parametrized.httpEmitting.flushMillis
• druid.emitter.parametrized.httpEmitting.flushCount
• druid.emitter.parametrized.httpEmitting.ssl.trustStorePath

请勿在参数化发射器中指定 recipientBaseUrl。请改用下表中描述的 recipientBaseUrlPattern。

属性	描述	默认值
druid.emitter.parametrized.recipientBaseUrlPattern	根据事件源发送事件的 URL 模式。例如，http://foo.bar/{feed}，如果事件源为 "metrics"，则会将事件发送到 http://foo.bar/metrics。	无，必需配置

组合发射器模块

属性	描述	默认值
druid.emitter.composing.emitters	要加载的发射器模块列表，例如 ["logging","http"]。	[]

Graphite 发射器

要使用 graphite 作为发射器，请设置 druid.emitter=graphite。有关配置详细信息，请参阅 Graphite 发射器 Druid 扩展的 Graphite 发射器 文档。

切换发射器

要使用切换发射器，请设置 druid.emitter=switching。

属性	描述	默认值
druid.emitter.switching.emitters	事件源到该事件源所使用的发射器模块列表的 JSON 映射，例如 {"metrics":["http"], "alerts":["logging"]}
druid.emitter.switching.defaultEmitters	当没有为事件源指定特定发射器时使用的加载发射器模块的 JSON 列表，例如 ["logging","http"]。	[]

缓存配置

本节介绍 Broker、Historical 和 Middle Manager/Peon 进程通用的缓存配置。

可以选择在 Broker、Historical 和 Middle Manager/Peon 进程上启用缓存。有关如何为不同进程启用缓存的信息，请参阅 Broker、Historical 和 Peon 配置选项。

除非指定了其他类型的缓存，否则 Druid 默认使用本地内存缓存。使用 druid.cache.type 配置来设置不同类型的缓存。

缓存设置是全局配置的，因此当在通用属性文件中定义时，相同的配置可以同时用于 Broker 和 Historical 进程。

缓存类型

属性	可能的值	描述	默认值
druid.cache.type	local, memcached, hybrid, caffeine	用于查询的缓存类型。有关每种缓存类型的配置选项，请见下文	caffeine

本地缓存

信息

已弃用：改用 caffeine（v0.12.0 及更高版本的默认设置）

本地缓存已被弃用，取而代之的是 Caffeine 缓存，并可能在未来的 Druid 版本中被移除。与 local 缓存相比，Caffeine 缓存提供了显著更好的性能和对驱逐行为的控制，建议在任何使用 JRE 8u60 或更高版本的场景下使用。

一种简单的内存中 LRU 缓存。本地缓存驻留在 JVM 堆内存中，因此如果启用它，请确保相应地增加堆大小。

属性	描述	默认值
druid.cache.sizeInBytes	最大缓存大小（字节）。零表示禁用缓存。	0
druid.cache.initialSize	支持缓存的哈希表的初始大小。	500000
druid.cache.logEvictionCount	如果不为零，则每 logEvictionCount 个项目记录一次缓存驱逐。	0

Caffeine 缓存

一种基于 Caffeine 的高性能 Druid 本地缓存实现。如果使用 COMMON_FJP，需要 JRE8u60 或更高版本。

配置

下表显示了该模块已知的配置选项

runtime.properties	描述	默认值
druid.cache.type	将此设置为 caffeine 或省略该参数	caffeine
druid.cache.sizeInBytes	堆上缓存的最大大小（字节）。可以按照此处所述进行配置。	min(1GiB, Runtime.maxMemory / 10)
druid.cache.expireAfter	访问后缓存条目可能过期的毫秒数	无（无时间限制）
druid.cache.cacheExecutorFactory	用于 Caffeine 维护的执行器工厂。COMMON_FJP、SINGLE_THREAD 或 SAME_THREAD 之一	ForkJoinPool 公共池（COMMON_FJP）
druid.cache.evictOnClose	关闭命名空间（例如，从进程中删除段）是否应导致关联缓存值的立即驱逐	false

druid.cache.cacheExecutorFactory

以下是 druid.cache.cacheExecutorFactory 的可能值，它控制如何运行维护任务

• COMMON_FJP（默认）使用公共 ForkJoinPool。应与 JRE 8u60 或更高版本 一起使用。旧版本的 JRE 性能可能比新版本差。
• SINGLE_THREAD 使用单线程执行器。
• SAME_THREAD 缓存维护被立即执行。

指标

除了正常的缓存指标外，Caffeine 缓存实现还报告以下总计（total）和增量（delta）指标

指标	描述	正常值
query/cache/caffeine/*/requests	命中或未命中的计数。	hit + miss
query/cache/caffeine/*/loadTime	Caffeine 加载新值所花费的时间（未使用功能）。	0
query/cache/caffeine/*/evictionBytes	已从缓存中驱逐的大小（字节）	变化不定，应调整缓存 sizeInBytes，使得 sizeInBytes/evictionBytes 大致等于您期望的缓存流失率。

Memcached

使用 memcached 作为缓存后端。这允许所有进程共享同一个缓存。

属性	描述	默认值
druid.cache.expiration	Memcached 过期时间。	2592000 (30 天)
druid.cache.timeout	等待 Memcached 响应的最长时间（毫秒）。	500
druid.cache.hosts	逗号分隔的 Memcached 主机列表 <host:port>。当 druid.cache.clientMode 设置为 static 时，需要指定所有节点。动态模式 会自动识别您集群中的节点，因此只需指定配置端点和端口即可。	无
druid.cache.maxObjectSize	Memcached 对象的最大对象大小（字节）。	52428800 (50 MiB)
druid.cache.memcachedPrefix	Memcached 中所有键的键前缀。	druid
druid.cache.numConnections	要使用的 memcached 连接数。	1
druid.cache.protocol	Memcached 通信协议。可以是 binary 或 text。	binary
druid.cache.locator	Memcached 定位器。可以是 consistent 或 array_mod。	consistent
druid.cache.enableTls	启用 Memcached 客户端的基于 TLS 的连接。布尔值。	false
druid.cache.clientMode	客户端模式。静态模式需要用户指定各个集群节点。动态模式使用 AWS Memcached 的 自动发现（AutoDiscovery） 功能。字符串。"static" 或 "dynamic"	static
druid.cache.skipTlsHostnameVerification	跳过 TLS 主机名验证。布尔值。	true

混合缓存（Hybrid）

使用任意两个缓存的组合作为两级 L1 / L2 缓存。这可用于将本地内存缓存与远程 memcached 缓存结合使用。

缓存请求将首先检查 L1 缓存，然后再检查 L2。如果 L1 未命中而 L2 命中，它也会填充 L1。

属性	描述	默认值
druid.cache.l1.type	用于 L1 缓存的缓存类型。有关有效类型，请参阅 druid.cache.type 配置。	caffeine
druid.cache.l2.type	用于 L2 缓存的缓存类型。有关有效类型，请参阅 druid.cache.type 配置。	caffeine
druid.cache.l1.*	可以使用此前缀设置给定 L1 缓存类型的所有有效属性。例如，如果您使用 caffeine L1 缓存，请指定 druid.cache.l1.sizeInBytes 来设置其大小。	默认值与给定缓存类型的默认值相同
druid.cache.l2.*	L2 缓存设置的前缀，请参阅 L1 的说明。	默认值与给定缓存类型的默认值相同
druid.cache.useL2	一个布尔值，指示如果 L1 未命中，是否查询 L2 缓存。如果 L2 是像 memcached 这样的远程缓存，并且该缓存也在 Broker 上使用，那么在 Historical 进程上将其配置为 false 是合理的。因为在这种情况下，如果查询到达 Historical，意味着 Broker 没有在同一个远程缓存中找到相应的结果，因此 Historical 对远程缓存的查询肯定也会未命中。	true
druid.cache.populateL2	一个布尔值，指示是否将结果放入 L2 缓存。	true

通用查询配置

本节描述控制 Druid 查询类型行为的配置，适用于 Broker、Historical 和 Middle Manager 进程。

覆盖默认查询上下文值

您可以通过设置格式为 druid.query.default.context.{query_context_key} 的运行时属性来覆盖任何 查询上下文通用参数 的默认值。druid.query.default.context.{query_context_key} 运行时属性前缀适用于所有当前和未来的查询上下文键，这与查询中传递的查询上下文参数的工作方式相同。如果查询上下文中指定了相同键的值，则可以覆盖运行时属性值。

查询上下文值的优先级链如下

Druid 代码中的硬编码默认值 <- 没有前缀为 druid.query.default.context 的运行时属性 <- 有前缀为 druid.query.default.context 的运行时属性 <- 查询中的上下文参数

请注意，并非所有查询上下文键都有一个不带 druid.query.default.context 前缀的运行时属性来覆盖硬编码的默认值。例如，maxQueuedBytes 有 druid.broker.http.maxQueuedBytes，但 joinFilterRewriteMaxSize 没有。因此，覆盖 joinFilterRewriteMaxSize 硬编码默认值的唯一方法是使用运行时属性 druid.query.default.context.joinFilterRewriteMaxSize。

进一步阐述前面的示例

如果既没有设置 druid.broker.http.maxQueuedBytes 也没有设置 druid.query.default.context.maxQueuedBytes，并且查询的上下文中也没有 maxQueuedBytes，则使用 Druid 代码中的硬编码值。如果运行时属性仅包含 druid.broker.http.maxQueuedBytes=x 且查询上下文中没有 maxQueuedBytes，则使用属性值 x。但是，如果查询上下文中有 maxQueuedBytes，则改用该值。如果运行时属性仅包含 druid.query.default.context.maxQueuedBytes=y 或者运行时属性同时包含 druid.broker.http.maxQueuedBytes=x 和 druid.query.default.context.maxQueuedBytes=y，则使用 druid.query.default.context.maxQueuedBytes 的值 y（前提是查询上下文没有 maxQueuedBytes）。如果查询上下文中有 maxQueuedBytes，则改用该值。

搜索查询配置

属性	描述	默认值
druid.query.search.maxSearchLimit	返回的最大搜索结果数。	1000
druid.query.search.searchStrategy	默认搜索查询策略。	useIndexes

SegmentMetadata 查询配置

属性	描述	默认值
druid.query.segmentMetadata.defaultHistory	当查询中未指定间隔时，使用距最近段结束时间之前的默认间隔（以 ISO8601 格式指定）。此属性还控制 GET /druid/v2/datasources/{dataSourceName} 用于检索数据源维度和指标的默认间隔持续时间。	P1W
druid.query.segmentMetadata.defaultAnalysisTypes	这可用于为所有段元数据查询设置默认分析类型，在进行查询时可以覆盖此设置。	["cardinality", "interval", "minmax"]

GroupBy 查询配置

本节描述 groupBy 查询的配置。您可以在 Broker、Historical 和 Middle Manager 进程的 runtime.properties 文件中设置运行时属性。您可以通过 查询上下文 设置查询上下文参数。

支持的运行时属性

属性	描述	默认值
druid.query.groupBy.maxSelectorDictionarySize	用于每个段字符串字典的最大堆空间量（近似值）。有关详细信息，请参阅 groupBy 内存调优和资源限制。	100000000
druid.query.groupBy.maxMergingDictionarySize	用于每个查询字符串字典的最大堆空间量（近似值）。当字典超过此大小时，将触发溢出到磁盘。有关详细信息，请参阅 groupBy 内存调优和资源限制。	100000000
druid.query.groupBy.maxOnDiskStorage	当合并缓冲区或字典填满时，每个查询用于将结果集溢出到磁盘的最大磁盘空间量。超过此限制的查询将失败。设置为零可禁用磁盘溢出。	0 (已禁用)
druid.query.groupBy.maxSpillFileCount	每个 GroupBy 查询允许的最大溢出文件数。超过此限制的查询将失败。有关详细信息，请参阅 groupBy 内存调优和资源限制。	Integer.MAX_VALUE (无限制)
druid.query.groupBy.defaultOnDiskStorage	当合并缓冲区或字典填满时，每个查询用于将结果集溢出到磁盘的默认磁盘空间量。设置为零可为未在上下文中覆盖 maxOnDiskStorage 的查询禁用磁盘溢出。	druid.query.groupBy.maxOnDiskStorage

支持的查询上下文

键	描述
maxSelectorDictionarySize	可用于降低此查询的 druid.query.groupBy.maxMergingDictionarySize 的值。
maxMergingDictionarySize	可用于降低此查询的 druid.query.groupBy.maxMergingDictionarySize 的值。
maxOnDiskStorage	可用于将此查询的 maxOnDiskStorage 设置为 0 到 druid.query.groupBy.maxOnDiskStorage 之间的值。如果此查询上下文覆盖超过 druid.query.groupBy.maxOnDiskStorage，查询将使用 druid.query.groupBy.maxOnDiskStorage。从查询上下文中省略此项将导致查询使用 druid.query.groupBy.defaultOnDiskStorage 作为 maxOnDiskStorage。
maxSpillFileCount	可用于覆盖此查询的 druid.query.groupBy.maxSpillFileCount 的值。

高级配置

支持的运行时属性

属性	描述	默认值
druid.query.groupBy.singleThreaded	使用单个线程合并结果。	false
druid.query.groupBy.bufferGrouperInitialBuckets	用于对结果进行分组的堆外哈希表中的初始桶数。设置为 0 以使用合理的默认值 (1024)。	0
druid.query.groupBy.bufferGrouperMaxLoadFactor	用于对结果进行分组的堆外哈希表的最大负载因子。当负载因子超过此大小时，表将增长或溢出到磁盘。设置为 0 以使用合理的默认值 (0.7)。	0
druid.query.groupBy.forceHashAggregation	强制使用基于哈希的聚合。	false
druid.query.groupBy.intermediateCombineDegree	合并树中组合在一起的中间进程数。更高的度数需要更少的线程，如果服务器有足够强大的 CPU 核心，这可能有助于通过减少过多线程的开销来提高查询性能。	8
druid.query.groupBy.numParallelCombineThreads	并行组合线程数的提示。这应该大于 1 以开启并行组合功能。用于并行组合的实际线程数为 min(druid.query.groupBy.numParallelCombineThreads, druid.processing.numThreads)。	1 (已禁用)

支持的查询上下文

键	描述	默认值
groupByIsSingleThreaded	覆盖此查询的 druid.query.groupBy.singleThreaded 值。
bufferGrouperInitialBuckets	覆盖此查询的 druid.query.groupBy.bufferGrouperInitialBuckets 值。	无
bufferGrouperMaxLoadFactor	覆盖此查询的 druid.query.groupBy.bufferGrouperMaxLoadFactor 值。	无
forceHashAggregation	覆盖 druid.query.groupBy.forceHashAggregation 的值	无
intermediateCombineDegree	覆盖 druid.query.groupBy.intermediateCombineDegree 的值	无
numParallelCombineThreads	覆盖 druid.query.groupBy.numParallelCombineThreads 的值	无
sortByDimsFirst	首先按维度值对结果进行排序，然后按时间戳排序。	false
forceLimitPushDown	当 orderby 中的所有字段都是分组键的一部分时，Broker 会将限制（limit）应用推送到 Historical 进程。当排序顺序使用不属于分组键的字段时，应用此优化可能会导致精度未知的近似结果，因此在该情况下默认禁用此优化。启用此上下文标志会为包含非分组键列的 limit/orderby 开启限制下推。	false

Router

Router 进程配置

属性	描述	默认值
druid.host	当前进程的主机。这用于发布当前进程的位置，以便从其他进程访问，通常应指定为使得 http://${druid.host}/ 实际上可以与该进程通信	InetAddress.getLocalHost().getCanonicalHostName()
druid.bindOnHost	指示进程的内部 jetty 服务器是否绑定在 druid.host 上。默认为 false，这意味着绑定到所有接口。	false
druid.plaintextPort	实际监听的端口；除非使用端口映射，否则这将是与 druid.host 上的端口相同的端口。	8888
druid.tlsPort	HTTPS 连接器的 TLS 端口，如果设置了 druid.enableTlsPort，则将使用此配置。如果 druid.host 包含端口，则该端口将被忽略。这应该是一个非负整数。	9088
druid.service	服务的名称。在发出指标和告警时用作维度，以区分各种服务	druid/router
druid.labels	定义服务器自定义标签的键值对的可选 JSON 对象。这些标签显示在 Web 控制台的“服务”选项卡下。示例：druid.labels={"location":"Airtrunk"} 或 druid.labels.location=Airtrunk	null

运行时配置

属性	描述	默认值
druid.router.defaultBrokerServiceName	如果服务发现失败时要连接的默认 Broker。	druid/broker
druid.router.tierToBrokerMap	针对特定数据层的查询被路由到其相应的 Broker。此值应为层到 Broker 名称的有序 JSON 映射。Broker 的优先级基于该顺序。	{"_default_tier": "<defaultBrokerServiceName>"}
druid.router.defaultRule	所有数据源的默认规则。	_default
druid.router.pollPeriod	轮询新规则的频率。	PT1M
druid.router.sql.enable	启用使用策略的 SQL 查询路由。当 true 时，Router 使用 druid.router.strategies 中定义的策略来确定给定 SQL 查询的代理服务。当 false 时，Router 使用 defaultBrokerServiceName。	false
druid.router.strategies	详细信息请参阅 Router 策略。	[{"type":"timeBoundary"},{"type":"priority"}]
druid.router.avatica.balancer.type	用于跨 Broker 平衡 Avatica 查询的类。请参阅 Avatica 查询平衡。	rendezvousHash
druid.router.managementProxy.enabled	启用 Router 的 管理代理（management proxy） 功能。	false
druid.router.http.numConnections	Router 连接到 Broker 进程的连接池大小。如果需要与同一进程通信的查询数量超过此数字，它们将排队。	20
druid.router.http.eagerInitialization	指示应尽早初始化从 Router 到 Broker 的 http 连接。如果设置为 true，则在初始化时创建 numConnections 个连接	true
druid.router.http.readTimeout	从 Broker 进程读取数据的超时时间。	PT15M
druid.router.http.numMaxThreads	处理 HTTP 请求和响应的最大工作线程数	(核心数) * 3 / 2 + 1
druid.router.http.numRequestsQueued	目标端点可排队的最大请求数	1024
druid.router.http.requestBuffersize	用于接收请求的内容缓冲区大小。这些缓冲区仅用于具有主体（body）的活动连接，且这些主体无法容纳在头缓冲区内	8 * 1024
druid.router.http.clientConnectTimeout	建立客户端连接的超时时间（以毫秒为单位）。	500