#
# Copyright © 2016-2026 The Thingsboard Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# HTTP server parameters
server:
# Shutdown type. Accepted values: graceful, immediate.
shutdown: "${SERVER_SHUTDOWN:graceful}"
# HTTP Server bind address. Has no effect if web-environment is disabled.
address: "${HTTP_BIND_ADDRESS:0.0.0.0}"
# HTTP Server bind port. Has no effect if web-environment is disabled.
port: "${HTTP_BIND_PORT:8083}"
# Server headers forwarding strategy. Required for Swagger UI when a reverse proxy is used.
forward_headers_strategy: "${HTTP_FORWARD_HEADERS_STRATEGY:framework}"
# HTTP/2 support. Takes effect only if server SSL is enabled.
http2:
# Enables or disables HTTP/2 support.
enabled: "${HTTP2_ENABLED:true}"
# Enables or disables logging of errors with stacktrace when the REST API throws an exception.
log_controller_error_stack_trace: "${HTTP_LOG_CONTROLLER_ERROR_STACK_TRACE:false}"
# REST publish API (POST /api/mqtt/publish) configuration.
rest_publish:
# Maximum size of the decoded MQTT payload accepted from the REST publish API (in bytes).
max_payload_size: "${REST_PUBLISH_MAX_PAYLOAD_SIZE:65536}"
# Time to wait for the publish queue to acknowledge a message before answering 503 Service Unavailable (in ms).
timeout_ms: "${REST_PUBLISH_TIMEOUT_MS:30000}"
# Server SSL configuration.
ssl:
# Enables or disables SSL support.
enabled: "${SSL_ENABLED:false}"
# Server SSL credentials.
credentials:
# Server credentials type. Accepted values: PEM (PEM certificate file), KEYSTORE (Java keystore).
type: "${SSL_CREDENTIALS_TYPE:PEM}"
# PEM server credentials.
pem:
# Path to the server certificate file (holds server certificate or certificate chain, may include server private key).
cert_file: "${SSL_PEM_CERT:server.pem}"
# Path to the server certificate private key file. Optional by default. Required if the private key is not present in the server certificate file.
key_file: "${SSL_PEM_KEY:server_key.pem}"
# Optional. Server certificate private key password.
key_password: "${SSL_PEM_KEY_PASSWORD:server_key_password}"
# Keystore server credentials.
keystore:
# Type of the key store. Accepted values: JKS, PKCS12.
type: "${SSL_KEY_STORE_TYPE:PKCS12}"
# Path to the key store that holds the SSL certificate.
store_file: "${SSL_KEY_STORE:classpath:keystore/keystore.p12}"
# Password used to access the key store.
store_password: "${SSL_KEY_STORE_PASSWORD:thingsboard_mqtt_broker}"
# Key alias.
key_alias: "${SSL_KEY_ALIAS:tomcat}"
# Password used to access the key.
key_password: "${SSL_KEY_PASSWORD:thingsboard_mqtt_broker}"
# MQTT listeners parameters
listener:
# Enables or disables proxy protocol support as a global setting for all listeners. If enabled, supports both v1 and v2.
# Useful to get the real IP address of the client in the logs, for session details info and unauthorized clients feature.
proxy_enabled: "${MQTT_PROXY_PROTOCOL_ENABLED:false}"
# Netty leak detector level. Accepted values: DISABLED, SIMPLE, ADVANCED, PARANOID. Applied globally for all listeners.
leak_detector_level: "${NETTY_LEAK_DETECTOR_LVL:DISABLED}"
# Threshold (in KB) at which Netty considers the channel non-writable. When reached, TBMQ stops delivering data to the subscriber until the channel becomes writable again.
# Non-persistent clients lose data in this case.
write_buffer_high_water_mark: "${NETTY_WRITE_BUFFER_HIGH_WATER_MARK:1280}"
# Threshold (in KB) at which Netty considers the channel writable again. When reached, TBMQ resumes delivering data to the subscriber.
write_buffer_low_water_mark: "${NETTY_WRITE_BUFFER_LOW_WATER_MARK:640}"
# Netty socket receive buffer size (in KB). When the buffer limit is reached, TCP triggers backpressure and notifies the sender to slow down.
# Defaults to 0, which uses the system's default buffer size.
so_receive_buffer: "${NETTY_SO_RECEIVE_BUFFER:0}"
tcp:
# Enables or disables MQTT TCP port listener.
enabled: "${LISTENER_TCP_ENABLED:true}"
# MQTT TCP listener bind address.
bind_address: "${LISTENER_TCP_BIND_ADDRESS:0.0.0.0}"
# MQTT TCP listener bind port.
bind_port: "${LISTENER_TCP_BIND_PORT:1883}"
# Enables or disables proxy protocol support for the MQTT TCP listener. Unset by default — inherits the global MQTT_PROXY_PROTOCOL_ENABLED value.
# If explicitly set, supports both v1 and v2 and takes precedence over the global setting.
# Useful to get the real IP address of the client in the logs, for session details info and unauthorized clients feature.
proxy_enabled: "${MQTT_TCP_PROXY_PROTOCOL_ENABLED:}"
netty:
# Number of Netty boss group threads.
boss_group_thread_count: "${TCP_NETTY_BOSS_GROUP_THREADS:1}"
# Number of Netty worker group threads.
worker_group_thread_count: "${TCP_NETTY_WORKER_GROUP_THREADS:12}"
# Maximum payload size (in bytes).
max_payload_size: "${TCP_NETTY_MAX_PAYLOAD_SIZE:65536}"
# Enables or disables the TCP keep-alive mechanism to periodically probe the other end of a connection.
so_keep_alive: "${TCP_NETTY_SO_KEEPALIVE:true}"
# Quiet period during graceful shutdown, in which no new tasks are submitted (in s).
shutdown_quiet_period: "${TCP_NETTY_SHUTDOWN_QUIET_PERIOD:0}"
# Maximum time to wait until the executor is stopped (in s).
shutdown_timeout: "${TCP_NETTY_SHUTDOWN_TIMEOUT:5}"
ssl:
# Enables or disables MQTT SSL port listener.
enabled: "${LISTENER_SSL_ENABLED:false}"
# MQTT SSL listener bind address.
bind_address: "${LISTENER_SSL_BIND_ADDRESS:0.0.0.0}"
# MQTT SSL listener bind port.
bind_port: "${LISTENER_SSL_BIND_PORT:8883}"
# Enables or disables proxy protocol support for the MQTT TLS listener. Unset by default — inherits the global MQTT_PROXY_PROTOCOL_ENABLED value.
# If explicitly set, supports both v1 and v2 and takes precedence over the global setting.
# Useful to get the real IP address of the client in the logs, for session details info and unauthorized clients feature.
proxy_enabled: "${MQTT_SSL_PROXY_PROTOCOL_ENABLED:}"
config:
# SSL protocol. See this link for accepted values.
protocol: "${LISTENER_SSL_PROTOCOL:TLSv1.2}"
# Comma-separated list of cipher suites enabled for the mqtts listener (e.g. TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256).
# Defaults to empty, meaning all cipher suites supported by the provider are used.
enabled_cipher_suites: "${LISTENER_SSL_ENABLED_CIPHER_SUITES:}"
# Server SSL credentials.
credentials:
# Server credentials type. Accepted values: PEM (PEM certificate file), KEYSTORE (Java keystore).
type: "${LISTENER_SSL_CREDENTIALS_TYPE:PEM}"
# PEM server credentials.
pem:
# Path to the server certificate file (holds server certificate or certificate chain, may include server private key).
cert_file: "${LISTENER_SSL_PEM_CERT:mqttserver.pem}"
# Path to the server certificate private key file. Optional by default. Required if the private key is not present in the server certificate file.
key_file: "${LISTENER_SSL_PEM_KEY:mqttserver_key.pem}"
# Optional. Server certificate private key password.
key_password: "${LISTENER_SSL_PEM_KEY_PASSWORD:server_key_password}"
# Keystore server credentials.
keystore:
# Type of the key store. Accepted values: JKS, PKCS12.
type: "${LISTENER_SSL_KEY_STORE_TYPE:JKS}"
# Path to the key store that holds the SSL certificate.
store_file: "${LISTENER_SSL_KEY_STORE:mqttserver.jks}"
# Password used to access the key store.
store_password: "${LISTENER_SSL_KEY_STORE_PASSWORD:server_ks_password}"
# Optional. Alias of the private key. If not set, the platform will load the first private key from the keystore.
key_alias: "${LISTENER_SSL_KEY_ALIAS:}"
# Optional. Password to access the private key. If not set, the platform will attempt to load private keys that are not password-protected.
key_password: "${LISTENER_SSL_KEY_PASSWORD:server_key_password}"
netty:
# Number of Netty boss group threads.
boss_group_thread_count: "${SSL_NETTY_BOSS_GROUP_THREADS:1}"
# Number of Netty worker group threads.
worker_group_thread_count: "${SSL_NETTY_WORKER_GROUP_THREADS:12}"
# Maximum payload size (in bytes).
max_payload_size: "${SSL_NETTY_MAX_PAYLOAD_SIZE:65536}"
# Enables or disables the TCP keep-alive mechanism to periodically probe the other end of a connection.
so_keep_alive: "${SSL_NETTY_SO_KEEPALIVE:true}"
# Quiet period during graceful shutdown, in which no new tasks are submitted (in s).
shutdown_quiet_period: "${SSL_NETTY_SHUTDOWN_QUIET_PERIOD:0}"
# Maximum time to wait until the executor is stopped (in s).
shutdown_timeout: "${SSL_NETTY_SHUTDOWN_TIMEOUT:5}"
ws:
# Enables or disables MQTT WS port listener.
enabled: "${LISTENER_WS_ENABLED:true}"
# MQTT WS listener bind address.
bind_address: "${LISTENER_WS_BIND_ADDRESS:0.0.0.0}"
# MQTT WS listener bind port.
bind_port: "${LISTENER_WS_BIND_PORT:8084}"
# Enables or disables proxy protocol support for the MQTT WS listener. Unset by default — inherits the global MQTT_PROXY_PROTOCOL_ENABLED value.
# If explicitly set, supports both v1 and v2 and takes precedence over the global setting.
# Useful to get the real IP address of the client in the logs, for session details info and unauthorized clients feature.
proxy_enabled: "${MQTT_WS_PROXY_PROTOCOL_ENABLED:}"
# Enables or disables honoring HTTP forward headers (X-Forwarded-For, X-Real-IP) on the WebSocket upgrade request to derive the real client IP.
# Useful when TBMQ sits behind an HTTP reverse proxy (e.g. NGINX) that cannot send the PROXY protocol on HTTP location blocks.
# When enabled, X-Forwarded-For (leftmost IP) wins over X-Real-IP. Falls back to the raw socket address if no usable header is present.
# Ignored when proxy protocol is enabled for this listener (per-listener or via the global listener.proxy_enabled) — PROXY protocol takes precedence.
# SECURITY: only enable this when TBMQ is behind a trusted reverse proxy that overwrites these headers; otherwise clients can spoof their source IP.
forward_headers_enabled: "${MQTT_WS_FORWARD_HEADERS_ENABLED:false}"
netty:
# Comma-separated list of subprotocols that the WebSocket can negotiate. The subprotocol setting `mqtt` represents MQTT 3.1.1 and MQTT 5.
sub_protocols: "${WS_NETTY_SUB_PROTOCOLS:mqttv3.1,mqtt}"
# Number of Netty boss group threads.
boss_group_thread_count: "${WS_NETTY_BOSS_GROUP_THREADS:1}"
# Number of Netty worker group threads.
worker_group_thread_count: "${WS_NETTY_WORKER_GROUP_THREADS:12}"
# Maximum payload size (in bytes).
max_payload_size: "${WS_NETTY_MAX_PAYLOAD_SIZE:65536}"
# Enables or disables the TCP keep-alive mechanism to periodically probe the other end of a connection.
so_keep_alive: "${WS_NETTY_SO_KEEPALIVE:true}"
# Quiet period during graceful shutdown, in which no new tasks are submitted (in s).
shutdown_quiet_period: "${WS_NETTY_SHUTDOWN_QUIET_PERIOD:0}"
# Maximum time to wait until the executor is stopped (in s).
shutdown_timeout: "${WS_NETTY_SHUTDOWN_TIMEOUT:5}"
wss:
# Enables or disables MQTT WSS port listener.
enabled: "${LISTENER_WSS_ENABLED:false}"
# MQTT WSS listener bind address.
bind_address: "${LISTENER_WSS_BIND_ADDRESS:0.0.0.0}"
# MQTT WSS listener bind port.
bind_port: "${LISTENER_WSS_BIND_PORT:8085}"
# Enables or disables proxy protocol support for the MQTT WSS listener. Unset by default — inherits the global MQTT_PROXY_PROTOCOL_ENABLED value.
# If explicitly set, supports both v1 and v2 and takes precedence over the global setting.
# Useful to get the real IP address of the client in the logs, for session details info and unauthorized clients feature.
proxy_enabled: "${MQTT_WSS_PROXY_PROTOCOL_ENABLED:}"
# Enables or disables honoring HTTP forward headers (X-Forwarded-For, X-Real-IP) on the WebSocket upgrade request to derive the real client IP.
# Useful when TBMQ sits behind an HTTP reverse proxy (e.g. NGINX) that cannot send the PROXY protocol on HTTP location blocks.
# When enabled, X-Forwarded-For (leftmost IP) wins over X-Real-IP. Falls back to the raw socket address if no usable header is present.
# Ignored when proxy protocol is enabled for this listener (per-listener or via the global listener.proxy_enabled) — PROXY protocol takes precedence.
# SECURITY: only enable this when TBMQ is behind a trusted reverse proxy that overwrites these headers; otherwise clients can spoof their source IP.
forward_headers_enabled: "${MQTT_WSS_FORWARD_HEADERS_ENABLED:false}"
config:
# SSL protocol. See this link for accepted values.
protocol: "${LISTENER_WSS_PROTOCOL:TLSv1.2}"
# Comma-separated list of cipher suites enabled for the wss listener (e.g. TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256).
# Defaults to empty, meaning all cipher suites supported by the provider are used.
enabled_cipher_suites: "${LISTENER_WSS_ENABLED_CIPHER_SUITES:}"
# Server SSL credentials.
credentials:
# Server credentials type. Accepted values: PEM (PEM certificate file), KEYSTORE (Java keystore).
type: "${LISTENER_WSS_CREDENTIALS_TYPE:PEM}"
# PEM server credentials.
pem:
# Path to the server certificate file (holds server certificate or certificate chain, may include server private key).
cert_file: "${LISTENER_WSS_PEM_CERT:ws_mqtt_server.pem}"
# Path to the server certificate private key file. Optional by default. Required if the private key is not present in the server certificate file.
key_file: "${LISTENER_WSS_PEM_KEY:ws_mqtt_server_key.pem}"
# Optional. Server certificate private key password.
key_password: "${LISTENER_WSS_PEM_KEY_PASSWORD:ws_server_key_password}"
# Keystore server credentials.
keystore:
# Type of the key store. Accepted values: JKS, PKCS12.
type: "${LISTENER_WSS_KEY_STORE_TYPE:JKS}"
# Path to the key store that holds the SSL certificate.
store_file: "${LISTENER_WSS_KEY_STORE:ws_mqtt_server.jks}"
# Password used to access the key store.
store_password: "${LISTENER_WSS_KEY_STORE_PASSWORD:ws_server_ks_password}"
# Optional. Alias of the private key. If not set, the platform will load the first private key from the keystore.
key_alias: "${LISTENER_WSS_KEY_ALIAS:}"
# Optional. Password to access the private key. If not set, the platform will attempt to load private keys that are not password-protected.
key_password: "${LISTENER_WSS_KEY_PASSWORD:ws_server_key_password}"
netty:
# Comma-separated list of subprotocols that the WebSocket can negotiate. The subprotocol setting `mqtt` represents MQTT 3.1.1 and MQTT 5.
sub_protocols: "${WSS_NETTY_SUB_PROTOCOLS:mqttv3.1,mqtt}"
# Number of Netty boss group threads.
boss_group_thread_count: "${WSS_NETTY_BOSS_GROUP_THREADS:1}"
# Number of Netty worker group threads.
worker_group_thread_count: "${WSS_NETTY_WORKER_GROUP_THREADS:12}"
# Maximum payload size (in bytes).
max_payload_size: "${WSS_NETTY_MAX_PAYLOAD_SIZE:65536}"
# Enables or disables the TCP keep-alive mechanism to periodically probe the other end of a connection.
so_keep_alive: "${WSS_NETTY_SO_KEEPALIVE:true}"
# Quiet period during graceful shutdown, in which no new tasks are submitted (in s).
shutdown_quiet_period: "${WSS_NETTY_SHUTDOWN_QUIET_PERIOD:0}"
# Maximum time to wait until the executor is stopped (in s).
shutdown_timeout: "${WSS_NETTY_SHUTDOWN_TIMEOUT:5}"
# Kafka parameters
queue:
msg-all:
# Number of parallel consumers for `tbmq.msg.all` topic. Should not be more than the number of partitions in topic.
consumers-count: "${TB_MSG_ALL_CONSUMERS_COUNT:4}"
# Number of threads in the pool to process consumers tasks. Should not be less than number of consumers.
threads-count: "${TB_MSG_ALL_THREADS_COUNT:4}"
# Poll interval for messages from `tbmq.msg.all` topic (in ms).
poll-interval: "${TB_MSG_ALL_POLL_INTERVAL:100}"
# Timeout for processing a pack of messages from `tbmq.msg.all` topic (in ms).
pack-processing-timeout: "${TB_MSG_ALL_PACK_PROCESSING_TIMEOUT:20000}"
ack-strategy:
# Processing strategy for `tbmq.msg.all` topic. Accepted values: SKIP_ALL, RETRY_ALL.
type: "${TB_MSG_ALL_ACK_STRATEGY_TYPE:SKIP_ALL}"
# Number of retries. Use 0 for unlimited. Applies to the RETRY_ALL strategy.
retries: "${TB_MSG_ALL_ACK_STRATEGY_RETRIES:1}"
# Enables or disables parallel processing of consumed messages (grouped by publishing client ID to preserve order).
# Helpful when the same client publishes lots of messages in a short amount of time.
# It is recommended to measure the impact of this parameter before enabling it in production.
msg-parallel-processing: "${TB_MSG_ALL_PARALLEL_PROCESSING:false}"
application-persisted-msg:
# Poll interval for messages from Application topics (in ms).
poll-interval: "${TB_APP_PERSISTED_MSG_POLL_INTERVAL:100}"
# Timeout for processing a pack of messages (in ms).
pack-processing-timeout: "${TB_APP_PERSISTED_MSG_PACK_PROCESSING_TIMEOUT:20000}"
ack-strategy:
# Processing strategy for Application topics. Accepted values: SKIP_ALL, RETRY_ALL.
type: "${TB_APP_PERSISTED_MSG_ACK_STRATEGY_TYPE:RETRY_ALL}"
# Number of retries. Use 0 for unlimited. Applies to the RETRY_ALL strategy.
retries: "${TB_APP_PERSISTED_MSG_ACK_STRATEGY_RETRIES:3}"
# Enables or disables validation that the application client ID contains only alphanumeric characters (required for Kafka topic creation).
client-id-validation: "${TB_APP_PERSISTED_MSG_CLIENT_ID_VALIDATION:true}"
# Enables or disables validation that the application shared subscription topic filter contains only alphanumeric characters, `+`, or `#` (required for Kafka topic creation).
shared-topic-validation: "${TB_APP_PERSISTED_MSG_SHARED_TOPIC_VALIDATION:true}"
device-persisted-msg:
# Number of parallel consumers for `tbmq.msg.persisted` topic. Should not be more than the number of partitions in topic.
consumers-count: "${TB_DEVICE_PERSISTED_MSG_CONSUMERS_COUNT:3}"
# Number of threads in the pool to process consumers tasks.
threads-count: "${TB_DEVICE_PERSISTED_MSG_THREADS_COUNT:3}"
# Poll interval for messages from `tbmq.msg.persisted` topic (in ms).
poll-interval: "${TB_DEVICE_PERSISTED_MSG_POLL_INTERVAL:100}"
# Timeout for processing a pack of messages from `tbmq.msg.persisted` topic (in ms).
pack-processing-timeout: "${TB_DEVICE_PERSISTED_MSG_PACK_PROCESSING_TIMEOUT:20000}"
ack-strategy:
# Queue processing strategy. Accepted values: SKIP_ALL, RETRY_ALL.
type: "${TB_DEVICE_PERSISTED_MSG_ACK_STRATEGY_TYPE:RETRY_ALL}"
# Number of retries. Use 0 for unlimited. Applies to the RETRY_ALL strategy.
retries: "${TB_DEVICE_PERSISTED_MSG_ACK_STRATEGY_RETRIES:3}"
# Time to wait in the consumer thread before retrying (in s).
pause-between-retries: "${TB_DEVICE_PERSISTED_MSG_ACK_STRATEGY_PAUSE_BETWEEN_RETRIES:1}"
retained-msg:
# Poll interval for messages from `tbmq.msg.retained` topic (in ms).
poll-interval: "${TB_RETAINED_MSG_POLL_INTERVAL:100}"
# Wait timeout for system messages to be delivered to `tbmq.msg.retained` topic (in ms).
acknowledge-wait-timeout-ms: "${TB_RETAINED_MSG_ACK_WAIT_TIMEOUT_MS:500}"
client-session:
# Poll interval for messages from `tbmq.client.session` topic (in ms).
poll-interval: "${TB_CLIENT_SESSION_POLL_INTERVAL:100}"
# Wait timeout for system messages to be delivered to `tbmq.client.session` topic (in ms).
acknowledge-wait-timeout-ms: "${TB_CLIENT_SESSION_ACK_WAIT_TIMEOUT_MS:500}"
client-subscriptions:
# Poll interval for messages from `tbmq.client.subscriptions` topic (in ms).
poll-interval: "${TB_CLIENT_SUBSCRIPTIONS_POLL_INTERVAL:100}"
# Wait timeout for system messages to be delivered to `tbmq.client.subscriptions` topic (in ms).
acknowledge-wait-timeout-ms: "${TB_CLIENT_SUBSCRIPTIONS_ACK_WAIT_TIMEOUT_MS:500}"
client-session-event:
# Number of parallel consumers for `tbmq.client.session.event.request` topic.
consumers-count: "${TB_CLIENT_SESSION_EVENT_CONSUMERS_COUNT:2}"
# Maximum number of pending client session events.
max-pending-requests: "${TB_CLIENT_SESSION_EVENT_MAX_PENDING_REQUESTS:10000}"
# Poll interval for messages from `tbmq.client.session.event.request` topic (in ms).
poll-interval: "${TB_CLIENT_SESSION_EVENT_POLL_INTERVAL:100}"
# Maximum time to process `tbmq.client.session.event.request` messages after consuming them (in ms).
batch-wait-timeout-ms: "${TB_CLIENT_SESSION_EVENT_BATCH_WAIT_MS:15000}"
client-session-event-response:
# Number of threads for sending event responses to session event requests.
response-sender-threads: "${TB_CLIENT_SESSION_EVENT_RESPONSE_SENDER_THREADS:8}"
# Poll interval for messages from `tbmq.client.session.event.response` topics (in ms).
poll-interval: "${TB_CLIENT_SESSION_EVENT_RESPONSE_POLL_INTERVAL:100}"
# Maximum time before client session events expire (in ms).
max-request-timeout: "${TB_CLIENT_SESSION_EVENT_RESPONSE_MAX_REQUEST_TIMEOUT:100000}"
# Cleanup period for stale client session events (in ms).
cleanup-interval: "${TB_CLIENT_SESSION_EVENT_RESPONSE_CLEANUP_INTERVAL:100}"
disconnect-client-command:
# Poll interval for messages from `tbmq.client.disconnect` topics (in ms).
poll-interval: "${TB_DISCONNECT_CLIENT_COMMAND_POLL_INTERVAL:100}"
persisted-downlink-msg:
# Number of parallel consumers for `tbmq.msg.downlink.persisted` topics.
consumers-count: "${TB_PERSISTED_DOWNLINK_MSG_CONSUMERS_COUNT:2}"
# Number of threads in the pool to process consumers tasks.
threads-count: "${TB_PERSISTED_DOWNLINK_MSG_THREADS_COUNT:2}"
# Poll interval for messages from `tbmq.msg.downlink.persisted` topics (in ms).
poll-interval: "${TB_PERSISTED_DOWNLINK_MSG_POLL_INTERVAL:100}"
basic-downlink-msg:
# Number of parallel consumers for `tbmq.msg.downlink.basic` topics.
consumers-count: "${TB_BASIC_DOWNLINK_MSG_CONSUMERS_COUNT:2}"
# Number of threads in the pool to process consumers tasks.
threads-count: "${TB_BASIC_DOWNLINK_MSG_THREADS_COUNT:2}"
# Poll interval for messages from `tbmq.msg.downlink.basic` topics (in ms).
poll-interval: "${TB_BASIC_DOWNLINK_MSG_POLL_INTERVAL:100}"
application-removed-event:
# Poll interval for messages from `tbmq.sys.app.removed` topic (in ms).
poll-interval: "${TB_APPLICATION_REMOVED_EVENT_POLL_INTERVAL:100}"
processing:
# Cron expression defining when to consume and process messages.
cron: "${TB_APPLICATION_REMOVED_EVENT_PROCESSING_CRON:0 0 3 * * *}"
# Timezone for the processing cron-job.
zone: "${TB_APPLICATION_REMOVED_EVENT_PROCESSING_ZONE:UTC}"
historical-data-total:
# Poll interval for messages from `tbmq.sys.historical.data` topic (in ms).
poll-interval: "${TB_HISTORICAL_DATA_TOTAL_POLL_INTERVAL:100}"
integration-uplink:
# Poll interval for messages from `tbmq.ie.uplink` topic (in ms).
poll-interval: "${TB_IE_UPLINK_POLL_INTERVAL:100}"
# Timeout for processing a pack of messages from `tbmq.ie.uplink` topic (in ms).
pack-processing-timeout: "${TB_IE_UPLINK_PACK_PROCESSING_TIMEOUT:20000}"
integration-uplink-notifications:
# Poll interval for messages from `tbmq.ie.uplink.notifications` topics (in ms).
poll-interval: "${TB_IE_UPLINK_NOTIFICATIONS_POLL_INTERVAL:100}"
internode-notifications:
# Poll interval for messages from `tbmq.sys.internode.notifications` topics (in ms).
poll-interval: "${TB_NODE_NOTIFICATION_POLL_INTERVAL:100}"
blocked-client:
# Poll interval for messages from `tbmq.client.blocked` topic (in ms).
poll-interval: "${TB_BLOCKED_CLIENT_POLL_INTERVAL:100}"
# Wait timeout for system messages to be delivered to `tbmq.client.blocked` topic (in ms).
acknowledge-wait-timeout-ms: "${TB_BLOCKED_CLIENT_ACK_WAIT_TIMEOUT_MS:500}"
kafka:
# List of Kafka bootstrap servers used to establish connection.
bootstrap.servers: "${TB_KAFKA_SERVERS:localhost:9092}"
# Enables or disables deletion of Kafka topics created for Application MQTT Clients or Application Shared subscriptions.
# When true, TBMQ may automatically remove topics during cleanup (e.g., when an Application client or shared subscription is deleted).
# When false, TBMQ skips topic deletion and simply stops using them, preventing accidental data loss in production environments.
enable-topic-deletion: "${TB_KAFKA_ENABLE_TOPIC_DELETION:true}"
default:
# Base Kafka properties applied to admins, all producers and consumers, making it the ideal place for shared
# connection and security settings. Format is key:value;key:value. If a property value contains a semicolon
# (common in sasl.jaas.config), escape it with a backslash (e.g., `...username="user"\;password="pass"\;`).
config: "${TB_KAFKA_DEFAULT_PRODUCER_CONSUMER_CONFIG:}"
consumer:
# Additional Kafka properties specific only to consumers, merged with the global defaults —
# TB_KAFKA_DEFAULT_PRODUCER_CONSUMER_CONFIG (overriding them if keys conflict).
# Follows the standard key:value;key:value format. Ensure any internal semicolons in values are escaped as \;.
config: "${TB_KAFKA_DEFAULT_CONSUMER_CONFIG:}"
# List of partition assignment strategy class names or types, ordered by preference, used to distribute
# partition ownership amongst consumer instances when group management is used.
partition-assignment-strategy: "${TB_KAFKA_DEFAULT_CONSUMER_PARTITION_ASSIGNMENT_STRATEGY:org.apache.kafka.clients.consumer.StickyAssignor}"
# Timeout for detecting client failures when using Kafka’s group management facility (in ms).
session-timeout-ms: "${TB_KAFKA_DEFAULT_CONSUMER_SESSION_TIMEOUT_MS:10000}"
# Maximum delay between invocations of poll() when using consumer group management (in ms).
max-poll-interval-ms: "${TB_KAFKA_DEFAULT_CONSUMER_MAX_POLL_INTERVAL_MS:300000}"
# Maximum number of records returned in a single call to poll().
max-poll-records: "${TB_KAFKA_DEFAULT_CONSUMER_MAX_POLL_RECORDS:2000}"
# Maximum amount of data per partition the server will return (in bytes).
max-partition-fetch-bytes: "${TB_KAFKA_DEFAULT_CONSUMER_MAX_PARTITION_FETCH_BYTES:16777216}"
# Maximum amount of data the server should return for a fetch request (in bytes).
fetch-max-bytes: "${TB_KAFKA_DEFAULT_CONSUMER_FETCH_MAX_BYTES:134217728}"
# Expected time between heartbeats to the consumer coordinator when using Kafka’s group management facilities.
# Heartbeats ensure the consumer’s session stays active and facilitate rebalancing when consumers join or leave.
# Must be set lower than TB_KAFKA_DEFAULT_CONSUMER_SESSION_TIMEOUT_MS, but typically no higher than 1/3 of that value.
# Can be adjusted lower to control the expected time for normal rebalances (in ms). Defaults to 3 s.
heartbeat-interval-ms: "${TB_KAFKA_DEFAULT_CONSUMER_HEARTBEAT_INTERVAL_MS:3000}"
producer:
# Additional Kafka properties specific only to producers, merged with the global defaults —
# TB_KAFKA_DEFAULT_PRODUCER_CONSUMER_CONFIG (overriding them if keys conflict).
# Follows the standard key:value;key:value format. Ensure any internal semicolons in values are escaped as \;.
config: "${TB_KAFKA_DEFAULT_PRODUCER_CONFIG:}"
# Number of acknowledgments the producer requires the leader to have received before considering a request complete.
acks: "${TB_KAFKA_DEFAULT_PRODUCER_ACKS:1}"
# Number of retries for records whose send fails with a potentially transient error.
retries: "${TB_KAFKA_DEFAULT_PRODUCER_RETRIES:1}"
# Batch size for grouping records sent to the same partition (in bytes).
batch-size: "${TB_KAFKA_DEFAULT_PRODUCER_BATCH_SIZE:16384}"
# Delay for grouping records arriving between request transmissions into a batched request (in ms).
linger-ms: "${TB_KAFKA_DEFAULT_PRODUCER_LINGER_MS:5}"
# Total memory the producer can use to buffer records waiting to be sent to the server (in bytes).
buffer-memory: "${TB_KAFKA_DEFAULT_PRODUCER_BUFFER_MEMORY:33554432}"
# Compression type for all data generated by the producer. Accepted values: none, gzip, snappy, lz4, zstd.
compression-type: "${TB_KAFKA_DEFAULT_COMPRESSION_TYPE:none}"
admin:
# Additional configs separated by semicolon for the admin Kafka client, merged with the global defaults —
# TB_KAFKA_DEFAULT_PRODUCER_CONSUMER_CONFIG (overriding them if keys conflict).
config: "${TB_KAFKA_ADMIN_CONFIG:retries:1}"
# Kafka Admin client command timeout (in s). Applies to operations like describeCluster, listTopics, etc.
command-timeout: "${TB_KAFKA_ADMIN_COMMAND_TIMEOUT_SEC:30}"
# Kafka topics cache TTL (in ms). Defines how long the list of topics is kept in memory before reloading from Kafka. Defaults to 5 minutes.
topics-cache-ttl-ms: "${TB_KAFKA_ADMIN_TOPICS_CACHE_TTL_MS:300000}"
consumer-stats:
# Enables or disables printing of consumer group lag between consumer offsets and the latest Kafka topic offsets.
enabled: "${TB_KAFKA_CONSUMER_STATS_ENABLED:true}"
# Print interval for Kafka consumer group statistics (in ms).
print-interval-ms: "${TB_KAFKA_CONSUMER_STATS_PRINT_INTERVAL_MS:60000}"
# Time to wait for stats-loading requests to Kafka to finish (in ms).
kafka-response-timeout-ms: "${TB_KAFKA_CONSUMER_STATS_RESPONSE_TIMEOUT_MS:1000}"
# Additional configs separated by semicolon for the Kafka stats consumer, merged with the consumer defaults —
# TB_KAFKA_DEFAULT_CONSUMER_CONFIG (overriding them if keys conflict).
consumer-config: "${TB_KAFKA_CONSUMER_STATS_CONSUMER_CONFIG:}"
home-page:
# Additional configs separated by semicolon for the Kafka admin client used on the home page, merged with the consumer defaults —
# TB_KAFKA_DEFAULT_CONSUMER_CONFIG (overriding them if keys conflict).
consumer-config: "${TB_KAFKA_HOME_PAGE_CONSUMER_CONFIG:}"
# Time to wait for home page requests to Kafka to finish (in ms).
kafka-response-timeout-ms: "${TB_KAFKA_HOME_PAGE_RESPONSE_TIMEOUT_MS:30000}"
msg-all:
# Topic for persisting incoming PUBLISH messages.
topic: "${TB_KAFKA_MSG_ALL_TOPIC:tbmq.msg.all}"
# Kafka topic properties separated by semicolon for the `tbmq.msg.all` topic.
topic-properties: "${TB_KAFKA_MSG_ALL_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:2147483648;partitions:16;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.msg.all` topic.
additional-consumer-config: "${TB_KAFKA_MSG_ALL_ADDITIONAL_CONSUMER_CONFIG:}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.msg.all` topic.
additional-producer-config: "${TB_KAFKA_MSG_ALL_ADDITIONAL_PRODUCER_CONFIG:}"
application-persisted-msg:
# Kafka topic properties separated by semicolon for the `tbmq.msg.app` topics.
topic-properties: "${TB_KAFKA_APP_PERSISTED_MSG_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.msg.app` topics.
additional-consumer-config: "${TB_KAFKA_APP_PERSISTED_MSG_ADDITIONAL_CONSUMER_CONFIG:max.poll.records:200}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.msg.app` topics.
additional-producer-config: "${TB_KAFKA_APP_PERSISTED_MSG_ADDITIONAL_PRODUCER_CONFIG:}"
shared-topic:
# Kafka topic properties separated by semicolon for application shared subscription topics.
topic-properties: "${TB_KAFKA_APP_PERSISTED_MSG_SHARED_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for application shared subscription topics.
additional-consumer-config: "${TB_KAFKA_APP_PERSISTED_MSG_SHARED_ADDITIONAL_CONSUMER_CONFIG:max.poll.records:500}"
# Additional Kafka producer configs separated by semicolon for application shared subscription topics.
additional-producer-config: "${TB_KAFKA_APP_PERSISTED_MSG_SHARED_ADDITIONAL_PRODUCER_CONFIG:}"
device-persisted-msg:
# Topic for persisting messages related to Device clients before saving them in the database.
topic: "${TB_KAFKA_DEVICE_PERSISTED_MSG_TOPIC:tbmq.msg.persisted}"
# Kafka topic properties separated by semicolon for the `tbmq.msg.persisted` topic.
topic-properties: "${TB_KAFKA_DEVICE_PERSISTED_MSG_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:12;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.msg.persisted` topic.
additional-consumer-config: "${TB_KAFKA_DEVICE_PERSISTED_MSG_ADDITIONAL_CONSUMER_CONFIG:}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.msg.persisted` topic.
additional-producer-config: "${TB_KAFKA_DEVICE_PERSISTED_MSG_ADDITIONAL_PRODUCER_CONFIG:}"
retained-msg:
# Topic for retained messages.
topic: "${TB_KAFKA_RETAINED_MSG_TOPIC:tbmq.msg.retained}"
# Kafka topic properties separated by semicolon for the `tbmq.msg.retained` topic.
topic-properties: "${TB_KAFKA_RETAINED_MSG_TOPIC_PROPERTIES:segment.bytes:26214400;partitions:1;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.msg.retained` topic.
additional-consumer-config: "${TB_KAFKA_RETAINED_MSG_ADDITIONAL_CONSUMER_CONFIG:}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.msg.retained` topic.
additional-producer-config: "${TB_KAFKA_RETAINED_MSG_ADDITIONAL_PRODUCER_CONFIG:}"
client-session:
# Topic for persisting client sessions.
topic: "${TB_KAFKA_CLIENT_SESSION_TOPIC:tbmq.client.session}"
# Kafka topic properties separated by semicolon for the `tbmq.client.session` topic.
topic-properties: "${TB_KAFKA_CLIENT_SESSION_TOPIC_PROPERTIES:segment.bytes:26214400;partitions:1;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.client.session` topic.
additional-consumer-config: "${TB_KAFKA_CLIENT_SESSION_ADDITIONAL_CONSUMER_CONFIG:}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.client.session` topic.
additional-producer-config: "${TB_KAFKA_CLIENT_SESSION_ADDITIONAL_PRODUCER_CONFIG:}"
client-subscriptions:
# Topic for persisting client subscriptions.
topic: "${TB_KAFKA_CLIENT_SUBSCRIPTIONS_TOPIC:tbmq.client.subscriptions}"
# Kafka topic properties separated by semicolon for the `tbmq.client.subscriptions` topic.
topic-properties: "${TB_KAFKA_CLIENT_SUBSCRIPTIONS_TOPIC_PROPERTIES:segment.bytes:26214400;partitions:1;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.client.subscriptions` topic.
additional-consumer-config: "${TB_KAFKA_CLIENT_SUBSCRIPTIONS_ADDITIONAL_CONSUMER_CONFIG:}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.client.subscriptions` topic.
additional-producer-config: "${TB_KAFKA_CLIENT_SUBSCRIPTIONS_ADDITIONAL_PRODUCER_CONFIG:}"
client-session-event:
# Topic for sending client session event requests.
topic: "${TB_KAFKA_CLIENT_SESSION_EVENT_TOPIC:tbmq.client.session.event.request}"
# Kafka topic properties separated by semicolon for the `tbmq.client.session.event.request` topic.
topic-properties: "${TB_KAFKA_CLIENT_SESSION_EVENT_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:24;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.client.session.event.request` topic.
additional-consumer-config: "${TB_KAFKA_CLIENT_SESSION_EVENT_ADDITIONAL_CONSUMER_CONFIG:max.poll.records:1000}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.client.session.event.request` topic.
additional-producer-config: "${TB_KAFKA_CLIENT_SESSION_EVENT_ADDITIONAL_PRODUCER_CONFIG:}"
client-session-event-response:
# Prefix for topics used to send client session event responses to Broker nodes.
topic-prefix: "${TB_KAFKA_CLIENT_SESSION_EVENT_RESPONSE_TOPIC_PREFIX:tbmq.client.session.event.response}"
# Kafka topic properties separated by semicolon for the `tbmq.client.session.event.response` topics.
topic-properties: "${TB_KAFKA_CLIENT_SESSION_EVENT_RESPONSE_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:1;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.client.session.event.response` topics.
additional-consumer-config: "${TB_KAFKA_CLIENT_SESSION_EVENT_RESPONSE_ADDITIONAL_CONSUMER_CONFIG:}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.client.session.event.response` topics.
additional-producer-config: "${TB_KAFKA_CLIENT_SESSION_EVENT_RESPONSE_ADDITIONAL_PRODUCER_CONFIG:}"
disconnect-client-command:
# Prefix for topics used to send disconnect client commands to Broker nodes.
topic-prefix: "${TB_KAFKA_DISCONNECT_CLIENT_COMMAND_TOPIC_PREFIX:tbmq.client.disconnect}"
# Kafka topic properties separated by semicolon for the `tbmq.client.disconnect` topics.
topic-properties: "${TB_KAFKA_DISCONNECT_CLIENT_COMMAND_RESPONSE_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:1;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.client.disconnect` topics.
additional-consumer-config: "${TB_KAFKA_DISCONNECT_CLIENT_COMMAND_ADDITIONAL_CONSUMER_CONFIG:}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.client.disconnect` topics.
additional-producer-config: "${TB_KAFKA_DISCONNECT_CLIENT_COMMAND_ADDITIONAL_PRODUCER_CONFIG:}"
basic-downlink-msg:
# Prefix for topics for non-persistent Device messages that should be transferred to other Broker nodes.
topic-prefix: "${TB_KAFKA_BASIC_DOWNLINK_MSG_TOPIC_PREFIX:tbmq.msg.downlink.basic}"
# Kafka topic properties separated by semicolon for the `tbmq.msg.downlink.basic` topics.
topic-properties: "${TB_KAFKA_BASIC_DOWNLINK_MSG_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:12;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.msg.downlink.basic` topics.
additional-consumer-config: "${TB_KAFKA_BASIC_DOWNLINK_MSG_ADDITIONAL_CONSUMER_CONFIG:}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.msg.downlink.basic` topics.
additional-producer-config: "${TB_KAFKA_BASIC_DOWNLINK_MSG_ADDITIONAL_PRODUCER_CONFIG:batch.size:32768}"
persisted-downlink-msg:
# Prefix for topics for persistent Device messages that should be transferred to other Broker nodes.
topic-prefix: "${TB_KAFKA_PERSISTED_DOWNLINK_MSG_TOPIC_PREFIX:tbmq.msg.downlink.persisted}"
# Kafka topic properties separated by semicolon for the `tbmq.msg.downlink.persisted` topics.
topic-properties: "${TB_KAFKA_PERSISTED_DOWNLINK_MSG_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:12;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.msg.downlink.persisted` topics.
additional-consumer-config: "${TB_KAFKA_PERSISTED_DOWNLINK_MSG_ADDITIONAL_CONSUMER_CONFIG:}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.msg.downlink.persisted` topics.
additional-producer-config: "${TB_KAFKA_PERSISTED_DOWNLINK_MSG_ADDITIONAL_PRODUCER_CONFIG:}"
application-removed-event:
# Topic for sending events to remove application topics when application clients are changed to device clients.
topic: "${TB_KAFKA_APPLICATION_REMOVED_EVENT_TOPIC:tbmq.sys.app.removed}"
# Kafka topic properties separated by semicolon for the `tbmq.sys.app.removed` topic.
topic-properties: "${TB_KAFKA_APPLICATION_REMOVED_EVENT_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:1;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.sys.app.removed` topic.
additional-consumer-config: "${TB_KAFKA_APPLICATION_REMOVED_EVENT_ADDITIONAL_CONSUMER_CONFIG:}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.sys.app.removed` topic.
additional-producer-config: "${TB_KAFKA_APPLICATION_REMOVED_EVENT_ADDITIONAL_PRODUCER_CONFIG:}"
historical-data-total:
# Topic for sending historical data stats to be summed from each broker.
topic: "${TB_KAFKA_HISTORICAL_DATA_TOTAL_TOPIC:tbmq.sys.historical.data}"
# Kafka topic properties separated by semicolon for the `tbmq.sys.historical.data` topic.
topic-properties: "${TB_KAFKA_HISTORICAL_DATA_TOTAL_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:1;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.sys.historical.data` topic.
additional-consumer-config: "${TB_KAFKA_HISTORICAL_DATA_TOTAL_ADDITIONAL_CONSUMER_CONFIG:}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.sys.historical.data` topic.
additional-producer-config: "${TB_KAFKA_HISTORICAL_DATA_TOTAL_ADDITIONAL_PRODUCER_CONFIG:}"
integration-downlink:
# Prefix for topics used to send integration configurations and validation requests from TBMQ to integration executors.
topic-prefix: "${TB_KAFKA_IE_DOWNLINK_TOPIC_PREFIX:tbmq.ie.downlink}"
http:
# Kafka topic properties separated by semicolon for the `tbmq.ie.downlink.http` topic.
topic-properties: "${TB_KAFKA_IE_DOWNLINK_HTTP_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:6;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.ie.downlink.http` topic.
additional-consumer-config: "${TB_KAFKA_IE_DOWNLINK_HTTP_ADDITIONAL_CONSUMER_CONFIG:}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.ie.downlink.http` topic.
additional-producer-config: "${TB_KAFKA_IE_DOWNLINK_HTTP_ADDITIONAL_PRODUCER_CONFIG:}"
kafka:
# Kafka topic properties separated by semicolon for the `tbmq.ie.downlink.kafka` topic.
topic-properties: "${TB_KAFKA_IE_DOWNLINK_KAFKA_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:6;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.ie.downlink.kafka` topic.
additional-consumer-config: "${TB_KAFKA_IE_DOWNLINK_KAFKA_ADDITIONAL_CONSUMER_CONFIG:}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.ie.downlink.kafka` topic.
additional-producer-config: "${TB_KAFKA_IE_DOWNLINK_KAFKA_ADDITIONAL_PRODUCER_CONFIG:}"
mqtt:
# Kafka topic properties separated by semicolon for the `tbmq.ie.downlink.mqtt` topic.
topic-properties: "${TB_KAFKA_IE_DOWNLINK_MQTT_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:6;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.ie.downlink.mqtt` topic.
additional-consumer-config: "${TB_KAFKA_IE_DOWNLINK_MQTT_ADDITIONAL_CONSUMER_CONFIG:}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.ie.downlink.mqtt` topic.
additional-producer-config: "${TB_KAFKA_IE_DOWNLINK_MQTT_ADDITIONAL_PRODUCER_CONFIG:}"
integration-uplink:
# Topic for sending messages and events from integration executors to TBMQ.
topic: "${TB_KAFKA_IE_UPLINK_TOPIC:tbmq.ie.uplink}"
# Kafka topic properties separated by semicolon for the `tbmq.ie.uplink` topic.
topic-properties: "${TB_KAFKA_IE_UPLINK_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:6;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.ie.uplink` topic.
# A pack's events are processed one at a time per integration to keep their order, so max.poll.records bounds
# how long a single integration's chain can get within one pack, and with it the pack processing time.
additional-consumer-config: "${TB_KAFKA_IE_UPLINK_ADDITIONAL_CONSUMER_CONFIG:max.poll.records:50}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.ie.uplink` topic.
additional-producer-config: "${TB_KAFKA_IE_UPLINK_ADDITIONAL_PRODUCER_CONFIG:}"
integration-uplink-notifications:
# Prefix for topics used to send notifications or replies from integration executors to specific TBMQ nodes.
topic-prefix: "${TB_KAFKA_IE_UPLINK_NOTIF_TOPIC_PREFIX:tbmq.ie.uplink.notifications}"
# Kafka topic properties separated by semicolon for the `tbmq.ie.uplink.notifications` topics.
topic-properties: "${TB_KAFKA_IE_UPLINK_NOTIF_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:1;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.ie.uplink.notifications` topic.
additional-consumer-config: "${TB_KAFKA_IE_UPLINK_NOTIF_ADDITIONAL_CONSUMER_CONFIG:}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.ie.uplink.notifications` topic.
additional-producer-config: "${TB_KAFKA_IE_UPLINK_NOTIF_ADDITIONAL_PRODUCER_CONFIG:}"
integration-msg:
# Kafka topic properties separated by semicolon for the `tbmq.msg.ie` topics.
topic-properties: "${TB_KAFKA_IE_MSG_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.msg.ie` topics.
additional-consumer-config: "${TB_KAFKA_IE_MSG_ADDITIONAL_CONSUMER_CONFIG:max.poll.records:50}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.msg.ie` topics.
additional-producer-config: "${TB_KAFKA_IE_MSG_ADDITIONAL_PRODUCER_CONFIG:}"
integration-event:
# Kafka topic properties separated by semicolon for the dedicated `tbmq.ie.event` lifecycle-event topics.
# Retention defaults shorter than the data topic since events are best-effort hints.
topic-properties: "${TB_KAFKA_IE_EVENT_MSG_TOPIC_PROPERTIES:retention.ms:86400000;segment.bytes:26214400;retention.bytes:104857600;partitions:1;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.ie.event` topics.
additional-consumer-config: "${TB_KAFKA_IE_EVENT_MSG_ADDITIONAL_CONSUMER_CONFIG:max.poll.records:50}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.ie.event` topics.
# Lifecycle events are produced synchronously on the MQTT processing thread. Before the first send to a given
# integration's event topic, the producer provisions it through the admin client, which can block on
# queue.kafka.admin.command-timeout (30 s default) twice - once to list existing topics, once to create the
# missing one - a bound that dwarfs max.block.ms below it. A failed topic listing during a Kafka outage is
# cached empty for queue.kafka.admin.topics-cache-ttl-ms (300 s default, floored at 60 s), so every event sent
# in that window still pays a fresh topic-creation attempt. Lower max.block.ms to tighten the smaller,
# producer-side bound at the cost of more dropped events under Kafka pressure.
additional-producer-config: "${TB_KAFKA_IE_EVENT_MSG_ADDITIONAL_PRODUCER_CONFIG:max.block.ms:5000}"
internode-notifications:
# Prefix for topics used to send system notifications to Broker nodes.
topic-prefix: "${TB_KAFKA_INTERNODE_NOTIFICATIONS_TOPIC_PREFIX:tbmq.sys.internode.notifications}"
# Kafka topic properties separated by semicolon for the `tbmq.sys.internode.notifications` topics.
topic-properties: "${TB_KAFKA_INTERNODE_NOTIFICATIONS_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:1;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.sys.internode.notifications` topics.
additional-consumer-config: "${TB_KAFKA_INTERNODE_NOTIFICATIONS_ADDITIONAL_CONSUMER_CONFIG:}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.sys.internode.notifications` topics.
additional-producer-config: "${TB_KAFKA_INTERNODE_NOTIFICATIONS_ADDITIONAL_PRODUCER_CONFIG:}"
blocked-client:
# Topic for blocked clients.
topic: "${TB_KAFKA_BLOCKED_CLIENT_TOPIC:tbmq.client.blocked}"
# Kafka topic properties separated by semicolon for the `tbmq.client.blocked` topic.
topic-properties: "${TB_KAFKA_BLOCKED_CLIENT_TOPIC_PROPERTIES:segment.bytes:26214400;partitions:1;replication.factor:1}"
# Additional Kafka consumer configs separated by semicolon for the `tbmq.client.blocked` topic.
additional-consumer-config: "${TB_KAFKA_BLOCKED_CLIENT_ADDITIONAL_CONSUMER_CONFIG:}"
# Additional Kafka producer configs separated by semicolon for the `tbmq.client.blocked` topic.
additional-producer-config: "${TB_KAFKA_BLOCKED_CLIENT_ADDITIONAL_PRODUCER_CONFIG:}"
# Common prefix for all Kafka topics, producers, consumer groups, and consumers. Defaults to empty string, meaning no prefix is applied.
kafka-prefix: "${TB_KAFKA_PREFIX:}"
# General service parameters
service:
# Microservice type. Accepted values: tbmq.
type: "${TB_SERVICE_TYPE:tbmq}"
# Unique ID for this service. Autogenerated if empty.
id: "${TB_SERVICE_ID:}"
node-drain:
# Maximum number of MQTT sessions asked to disconnect in one drain batch.
batch-size: "${NODE_DRAIN_BATCH_SIZE:1000}"
# Delay between drain batches (in ms).
batch-interval-ms: "${NODE_DRAIN_BATCH_INTERVAL_MS:1000}"
# Grace period for load balancers to stop routing traffic after the node becomes unhealthy (in ms).
load-balancer-wait-ms: "${NODE_DRAIN_LOAD_BALANCER_WAIT_MS:20000}"
# Maximum drain duration before the operation is marked as timed out (in ms).
timeout-ms: "${NODE_DRAIN_TIMEOUT_MS:300000}"
# Actor system parameters
actors:
system:
# Number of messages the actor system will process per actor before switching to processing messages for the next actor.
throughput: "${ACTORS_SYSTEM_THROUGHPUT:5}"
# Thread pool size for the actor system scheduler.
scheduler-pool-size: "${ACTORS_SYSTEM_SCHEDULER_POOL_SIZE:1}"
# Maximum number of attempts to initialize the actor before disabling it.
max-actor-init-attempts: "${ACTORS_SYSTEM_MAX_ACTOR_INIT_ATTEMPTS:10}"
# Time the actor system waits during TBMQ node shutdown to process client disconnections (in ms).
disconnect-wait-timeout-ms: "${ACTORS_SYSTEM_DISCONNECT_WAIT_TIMEOUT_MS:15000}"
persisted-device:
# Number of threads processing the Device actor's messages.
dispatcher-pool-size: "${ACTORS_SYSTEM_PERSISTED_DEVICE_DISPATCHER_POOL_SIZE:8}"
# Time to wait before deleting the Device actor after disconnect (in minutes).
wait-before-actor-stop-minutes: "${ACTORS_SYSTEM_PERSISTED_DEVICE_WAIT_BEFORE_ACTOR_STOP_MINUTES:5}"
client:
# Number of threads processing the MQTT client actor messages.
dispatcher-pool-size: "${ACTORS_SYSTEM_CLIENT_DISPATCHER_POOL_SIZE:8}"
# Time to wait before stopping the actor for clients that did not specify a client ID (in s).
wait-before-generated-actor-stop-seconds: "${ACTORS_SYSTEM_CLIENT_WAIT_BEFORE_GENERATED_ACTOR_STOP_SECONDS:10}"
# Time to wait before stopping the actor for clients that specified a client ID (in s).
wait-before-named-actor-stop-seconds: "${ACTORS_SYSTEM_CLIENT_WAIT_BEFORE_NAMED_ACTOR_STOP_SECONDS:60}"
rule:
# Thread pool size for the mail sender executor service.
mail_thread_pool_size: "${ACTORS_RULE_MAIL_THREAD_POOL_SIZE:4}"
# Thread pool size for the password reset emails executor service.
mail_password_reset_thread_pool_size: "${ACTORS_RULE_MAIL_PASSWORD_RESET_THREAD_POOL_SIZE:4}"
# Platform integrations parameters
integrations:
init:
# Timeout for API connection check requests (in s).
connection-check-api-request-timeout-sec: "${INTEGRATIONS_INIT_CONNECTION_CHECK_API_REQUEST_TIMEOUT_SEC:20}"
cleanup:
# Execution period of the cleanup task for disconnected integrations (in s). Defaults to three hours.
period: "${INTEGRATIONS_CLEANUP_PERIOD_SEC:10800}"
# Administration TTL for cleaning up disconnected integrations (in s). The cleanup deletes both of the
# integration's topics, clears its subscriptions, and evicts its lifecycle event types cluster-wide - the
# integration stops producing altogether, not just loses its topics. Defaults to one week. A value of 0 or
# negative disables this TTL.
ttl: "${INTEGRATIONS_CLEANUP_TTL_SEC:604800}"
# Database time series parameters
database:
# Maximum number of DB queries generated by a single API call to fetch time series records.
ts_max_intervals: "${DATABASE_TS_MAX_INTERVALS:700}"
# SQL configuration parameters
sql:
# Enables or disables sorting of entities before batch update. Should be enabled in cluster mode to avoid deadlocks.
batch_sort: "${SQL_BATCH_SORT:true}"
# Partitioning size for timestamp key-value storage. Accepted values: DAYS, MONTHS, YEARS, INDEFINITE.
ts_key_value_partitioning: "${SQL_TS_KV_PARTITIONING:DAYS}"
# Enables or disables removal of null characters from strValue before insert.
remove_null_chars: "${SQL_REMOVE_NULL_CHARS:true}"
ts:
# Batch size for persisting time series inserts.
batch_size: "${SQL_TS_BATCH_SIZE:1000}"
# Maximum timeout for time series entries queue polling (in ms).
batch_max_delay: "${SQL_TS_BATCH_MAX_DELAY_MS:100}"
# Number of threads that execute batch insert/update statements for time series data. Must be a prime number (e.g., 3 or 5) for optimal hash distribution.
batch_threads: "${SQL_TS_BATCH_THREADS:3}"
ts_latest:
# Batch size for persisting latest time series inserts.
batch_size: "${SQL_TS_LATEST_BATCH_SIZE:1000}"
# Maximum timeout for latest time series entries queue polling (in ms).
batch_max_delay: "${SQL_TS_LATEST_BATCH_MAX_DELAY_MS:50}"
# Number of threads that execute batch insert/update statements for latest time series data. Must be a prime number (e.g., 3 or 5) for optimal hash distribution.
batch_threads: "${SQL_TS_LATEST_BATCH_THREADS:3}"
unauthorized-client:
insert:
# Batch size for persisting unauthorized client inserts.
batch_size: "${SQL_UNAUTHORIZED_CLIENT_INSERT_BATCH_SIZE:1000}"
# Maximum timeout for unauthorized client insert entries queue polling (in ms).
batch_max_delay: "${SQL_UNAUTHORIZED_CLIENT_INSERT_BATCH_MAX_DELAY_MS:50}"
# Number of threads that execute batch insert/update statements for unauthorized client data. Must be a prime number (e.g., 3 or 5) for optimal hash distribution.
batch_threads: "${SQL_UNAUTHORIZED_CLIENT_INSERT_BATCH_THREADS:3}"
delete:
# Batch size for processing unauthorized client deletes.
batch_size: "${SQL_UNAUTHORIZED_CLIENT_DELETE_BATCH_SIZE:1000}"
# Maximum timeout for unauthorized client delete entries queue polling (in ms).
batch_max_delay: "${SQL_UNAUTHORIZED_CLIENT_DELETE_BATCH_MAX_DELAY_MS:50}"
# Number of threads that execute batch delete statements for unauthorized client data. Must be a prime number (e.g., 3 or 5) for optimal hash distribution.
batch_threads: "${SQL_UNAUTHORIZED_CLIENT_DELETE_BATCH_THREADS:3}"
events:
# Batch size for persisting events updates.
batch_size: "${SQL_EVENTS_BATCH_SIZE:10000}"
# Maximum timeout for events entries queue polling (in ms).
batch_max_delay: "${SQL_EVENTS_BATCH_MAX_DELAY_MS:100}"
# Number of threads that execute batch insert/update statements for events. Must be a prime number (e.g., 3 or 5) for optimal hash distribution.
batch_threads: "${SQL_EVENTS_BATCH_THREADS:3}"
# Number of hours per events partition. Defaults to one week (168 h).
partition_size: "${SQL_EVENTS_REGULAR_PARTITION_SIZE_HOURS:168}"
# Maximum number of symbols per event. Event content will be truncated if it exceeds this limit.
max-symbols: "${SQL_EVENTS_MAX_SYMBOLS:4096}"
ttl:
ts:
# Enables or disables TTL (Time To Live) for time series records.
enabled: "${SQL_TTL_TS_ENABLED:true}"
# Execution period of the TTL task for time series records (in ms). Defaults to one day.
execution_interval_ms: "${SQL_TTL_TS_EXECUTION_INTERVAL_MS:86400000}"
# System TTL value for time series records (in s). Defaults to seven days. Use 0 to disable expiration.
ts_key_value_ttl: "${SQL_TTL_TS_KEY_VALUE_TTL:604800}"
unauthorized_client:
# Enables or disables TTL (Time To Live) for unauthorized clients.
enabled: "${SQL_TTL_UNAUTHORIZED_CLIENT_ENABLED:true}"
# Execution period of the TTL task for unauthorized clients (in ms). Defaults to one day.
execution_interval_ms: "${SQL_TTL_UNAUTHORIZED_CLIENT_EXECUTION_INTERVAL_MS:86400000}"
# System TTL value for unauthorized clients (in s). Defaults to three days. Use 0 to disable expiration.
ttl: "${SQL_TTL_UNAUTHORIZED_CLIENT_TTL:259200}"
events:
# Enables or disables TTL (Time To Live) for event records.
enabled: "${SQL_TTL_EVENTS_ENABLED:true}"
# Execution interval for the TTL cleanup task for events (in ms). Defaults to 1 hour.
execution_interval_ms: "${SQL_TTL_EVENTS_EXECUTION_INTERVAL_MS:3600000}"
# TTL for events (in s). Defaults to 14 days. Cleanup accuracy depends on the sql.events.partition_size parameter.
events_ttl: "${SQL_TTL_EVENTS_TTL_SEC:1209600}"
# Redis lettuce configuration parameters
lettuce:
# Enables or disables auto-flush. If disabled, commands are buffered and flushed based on cmd count or time interval.
auto-flush: "${REDIS_LETTUCE_CMDS_AUTO_FLUSH_ENABLED:true}"
# Number of buffered commands before flush is triggered. Used when auto-flush is disabled.
buffered-cmd-count: "${REDIS_LETTUCE_BUFFERED_CMDS_COUNT:5}"
# Maximum time to buffer commands before flushing, regardless of cmd count (in ms).
flush-interval-ms: "${REDIS_LETTUCE_FLUSH_INTERVAL_MS:5}"
config:
# Maximum time to wait for a Lettuce command to complete (in s).
# Affects health checks and any command execution (e.g. GET, SET, PING).
# Reduce this value to fail fast if Redis is unresponsive.
command-timeout: "${REDIS_LETTUCE_COMMAND_TIMEOUT_SEC:30}"
# Quiet period for the Lettuce client shutdown (in s).
shutdown-quiet-period: "${REDIS_LETTUCE_SHUTDOWN_QUIET_PERIOD_SEC:1}"
# Shutdown timeout for the Lettuce client (in s).
shutdown-timeout: "${REDIS_LETTUCE_SHUTDOWN_TIMEOUT_SEC:10}"
cluster:
topology-refresh:
# Enables or disables periodic cluster topology updates.
# Useful for Redis Cluster setup to handle topology changes,
# such as node failover, restarts, or IP address changes.
enabled: "${REDIS_LETTUCE_CLUSTER_TOPOLOGY_REFRESH_ENABLED:false}"
# Interval for periodic cluster topology updates (in s).
period: "${REDIS_LETTUCE_CLUSTER_TOPOLOGY_REFRESH_PERIOD_SEC:60}"
# SQL DAO configuration parameters
spring:
data:
jpa:
repositories:
# Enables or disables the Spring Data JPA repositories support.
enabled: "${SPRING_DATA_JPA_REPOSITORIES_ENABLED:true}"
jpa:
# Enables or disables OSIV.
open-in-view: "${SPRING_JPA_OPEN_IN_VIEW:false}"
hibernate:
# Hibernate DDL behavior. Accepted values: none, validate, update, create-drop.
# Spring Boot chooses a default based on whether it thinks your database is embedded (default create-drop) or not (default none).
ddl-auto: "${SPRING_JPA_HIBERNATE_DDL_AUTO:none}"
datasource:
# Database driver for Spring JPA.
driverClassName: "${SPRING_DRIVER_CLASS_NAME:org.postgresql.Driver}"
# Database connection URL.
url: "${SPRING_DATASOURCE_URL:jdbc:postgresql://localhost:5432/thingsboard_mqtt_broker}"
# Database username.
username: "${SPRING_DATASOURCE_USERNAME:postgres}"
# Database user password.
password: "${SPRING_DATASOURCE_PASSWORD:postgres}"
hikari:
# Maximum number of connections in the pool. Grows with demand to prevent resource exhaustion affecting performance and availability.
maximumPoolSize: "${SPRING_DATASOURCE_MAXIMUM_POOL_SIZE:16}"
# Maximum lifetime of a connection (in ms). The connection is removed only when closed. Defaults to 10 minutes.
maxLifetime: "${SPRING_DATASOURCE_MAX_LIFETIME:600000}"
# Maximum time HikariCP will wait to acquire a connection from the pool (in ms).
# If exceeded, an exception is thrown. Defaults to 30 s.
connectionTimeout: "${SPRING_DATASOURCE_CONNECTION_TIMEOUT_MS:30000}"
# General Spring parameters
spring.lifecycle.timeout-per-shutdown-phase: "${SPRING_LIFECYCLE_TIMEOUT_PER_SHUTDOWN_PHASE:1m}" # The server waits for active requests to finish up to the specified time before graceful shutdown.
spring.jpa.properties.hibernate.jdbc.lob.non_contextual_creation: "${SPRING_JPA_HIBERNATE_JDBC_LOB_NON_CONTEXTUAL_CREATION:true}" # Enables or disables Hibernate's own (non-contextual) LOB implementation. When enabled, replaces JDBC contextual LOB creation to fix a Postgres JPA error.
spring.jpa.properties.hibernate.order_by.default_null_ordering: "${SPRING_JPA_HIBERNATE_ORDER_BY_DEFAULT_NULL_ORDERING:last}" # Default ordering for null values.
spring.data.redis.repositories.enabled: "${SPRING_DATA_REDIS_REPOSITORIES_ENABLED:false}" # Enables or disables Spring Data Redis repositories scanning.
spring.freemarker.checkTemplateLocation: "${SPRING_FREEMARKER_CHECK_TEMPLATE_LOCATION:false}" # Enables or disables the Spring Freemarker check that the template location exists.
spring.mvc.async.request-timeout: "${SPRING_MVC_ASYNC_REQUEST_TIMEOUT:30000}" # Default timeout for asynchronous requests (in ms).
spring.mvc.pathmatch.matching-strategy: "${SPRING_MVC_PATH_MATCH_MATCHING_STRATEGY:ANT_PATH_MATCHER}" # Path matching strategy used for Swagger endpoints.
# Security parameters
security:
# JWT Token parameters.
jwt:
# User JWT Token expiration time (in s). Defaults to 2.5 hours.
tokenExpirationTime: "${JWT_TOKEN_EXPIRATION_TIME:9000}"
# User JWT Refresh Token expiration time (in s). Defaults to 1 week.
refreshTokenExpTime: "${JWT_REFRESH_TOKEN_EXPIRATION_TIME:604800}"
# User JWT Token issuer.
tokenIssuer: "${JWT_TOKEN_ISSUER:thingsboard.io}"
# User JWT Token sign key.
tokenSigningKey: "${JWT_TOKEN_SIGNING_KEY:Qk1xUnloZ0VQTlF1VlNJQXZ4cWhiNWt1cVd1ZzQ5cWpENUhMSHlaYmZIM0JrZ2pPTVlhQ3N1Z0ZMUnd0SDBieg==}"
# Enables or disables access to other Administrators' JWT tokens by the System Administrator.
user_token_access_enabled: "${SECURITY_USER_TOKEN_ACCESS_ENABLED:true}"
# Enables or disables case-sensitive username login.
user_login_case_sensitive: "${SECURITY_USER_LOGIN_CASE_SENSITIVE:true}"
# Unauthorized Clients configuration.
unauth-clients:
# Enables or disables persistence of unauthorized client connection attempts.
# When disabled, unauthorized clients are logged only and are not stored.
# When enabled, unauthorized client entries are persisted to the database.
enabled: "${SECURITY_UNAUTH_CLIENTS_ENABLED:true}"
# HTTP authentication provider parameters.
http-auth:
# Connection pool of the HTTP client that sends requests to the external authentication service.
pool:
# Maximum number of connections in the pool. Defaults to 0, which uses the Reactor Netty default:
# twice the number of available processors, but at least 16.
max-connections: "${TB_HTTP_AUTH_CLIENT_POOL_MAX_CONNECTIONS:0}"
# Maximum time a connection may stay idle in the pool before it is closed (in ms). Keep it below the idle timeout
# of the authentication service and of any load balancer or proxy in between. Defaults to 30000 (30 s).
# 0 disables the limit.
max-idle-time-ms: "${TB_HTTP_AUTH_CLIENT_POOL_MAX_IDLE_TIME_MS:30000}"
# Maximum lifetime of a connection in the pool, regardless of activity (in ms). Defaults to 300000 (5 min).
# 0 disables the limit.
max-life-time-ms: "${TB_HTTP_AUTH_CLIENT_POOL_MAX_LIFE_TIME_MS:300000}"
# MQTT parameters
mqtt:
connect:
# Number of threads for the client connection thread pool.
threads: "${MQTT_CONNECT_THREADS:4}"
# Enables or disables parallel processing of subscriptions for published messages.
# Helpful when the PUBLISH message should be delivered to lots of subscribers.
# It is recommended to measure the impact of this parameter before enabling it in production.
msg-subscriptions-parallel-processing: "${MQTT_MSG_SUBSCRIPTIONS_PARALLEL_PROCESSING:false}"
pre-connect-queue:
# Maximum number of messages stored in the queue before the client connects and starts processing them.
max-size: "${MQTT_PRE_CONNECT_QUEUE_MAX_SIZE:1000}"
# Maximum number of PUBLISH messages not yet acknowledged.
max-in-flight-msgs: "${MQTT_MAX_IN_FLIGHT_MSGS:1000}"
flow-control:
# Enables or disables the MQTT 5 flow control feature for the server. If disabled, the server will not control the number of messages sent to subscribers via `Receive Maximum`.
# Also applies to MQTT 3.x clients when enabled. `Receive Maximum` for MQTT 3.x clients can be configured using MQTT_FLOW_CONTROL_MQTT_3X_RECEIVE_MAX.
enabled: "${MQTT_FLOW_CONTROL_ENABLED:true}"
# Interval between sweeps of the per-client delayed-message buffer that drops messages whose age exceeds `ttl` (in ms).
# Drain on ACK/writability is event-driven, so this sweeper only handles TTL expiry. Defaults to 10 s.
# The legacy YAML key `mqtt.flow-control.timeout` and env var MQTT_FLOW_CONTROL_TIMEOUT remain honoured as fallbacks
# for upgrade compatibility.
ttl-sweep-interval-ms: "${MQTT_FLOW_CONTROL_TTL_SWEEP_INTERVAL_MS:${mqtt.flow-control.timeout:${MQTT_FLOW_CONTROL_TIMEOUT:10000}}}"
# Time to store delayed messages for subscribers (in s). Delayed messages are those that cannot be sent immediately due to flow control restrictions.
# Defaults to 10 minutes.
ttl: "${MQTT_FLOW_CONTROL_TTL:600}"
# Maximum allowed queue length for delayed messages — published to the client when the in-flight window is full.
delayed-queue-max-size: "${MQTT_FLOW_CONTROL_DELAYED_QUEUE_MAX_SIZE:1000}"
# Receive maximum value for MQTT 3.x clients.
mqtt3x-receive-max: "${MQTT_FLOW_CONTROL_MQTT_3X_RECEIVE_MAX:65535}"
keep-alive:
# Interval between subsequent checks for inactive clients (in ms).
monitoring-delay-ms: "${MQTT_KEEP_ALIVE_MONITORING_DELAY_MS:1000}"
# Maximum keep-alive value allowed by the server (in s). Applies to MQTT v5 clients. Defaults to 10 minutes.
max-keep-alive: "${MQTT_KEEP_ALIVE_MAX_KEEP_ALIVE_SEC:600}"
topic:
# Maximum number of segments in topic names and topic filters. Segments are separated by "/", so a topic with N slashes
# has N + 1 segments (e.g., a/b/c has 3 segments). Topics with more segments than the limit are rejected.
# Excessively large values may cause processing errors. Defaults to 0, which disables the limit.
max-segments-count: "${MQTT_TOPIC_MAX_SEGMENTS_COUNT:0}"
# Maximum number of topic aliases per connection. Set to 0 to disable the Topic Alias feature. Defaults to 10.
alias-max: "${MQTT_TOPIC_ALIAS_MAX:10}"
# Minimum topic name length that the broker may replace with a topic alias (e.g., topics with more than 50 characters).
min-length-for-alias-replacement: "${MQTT_TOPIC_MIN_LENGTH_FOR_ALIAS_REPLACEMENT:50}"
subscription:
# Enables or disables client subscriptions to the root multi-level wildcard `#`.
# When true (default), clients can subscribe to `#` and receive a copy of every message published to the broker.
# Useful for debugging or firehose-style monitoring services.
# When false, clients are denied subscription to the exact topic `#` but can still subscribe to specific paths
# (e.g., `sensors/#`) or individual topics. Recommended for production to prevent accidental or malicious data leakage.
allow-root-multi-level-wildcard: "${MQTT_SUBSCRIPTION_ROOT_MULTI_LVL_WILDCARD:true}"
shared-subscriptions:
# Processing strategy for distributing messages among clients in a shared subscription. Accepted values: ROUND_ROBIN.
processing-type: "${MQTT_SHARED_SUBSCRIPTIONS_PROCESSING_TYPE:ROUND_ROBIN}"
subscription-trie:
# Maximum pause for clearing subscription storage from empty nodes (in ms).
# If a wait is unsuccessful, subscribing clients will be resumed, but the clear will fail.
wait-for-clear-lock-ms: "${MQTT_SUB_TRIE_WAIT_FOR_CLEAR_LOCK_MS:100}"
# Cron job to schedule clearing of empty subscription nodes. Defaults to 'every day at midnight'.
clear-nodes-cron: "${MQTT_SUB_TRIE_CLEAR_NODES_CRON:0 0 0 * * *}"
# Timezone for the subscription clearing cron-job.
clear-nodes-zone: "${MQTT_SUB_TRIE_CLEAR_NODES_ZONE:UTC}"
retain-msg-trie:
# Maximum pause for clearing retain msg storage from empty nodes (in ms).
# If a wait is unsuccessful, retain messages processing will be resumed, but the clear will fail.
wait-for-clear-lock-ms: "${MQTT_RETAIN_MSG_TRIE_WAIT_FOR_CLEAR_LOCK_MS:100}"
# Cron job to schedule clearing of empty retain msg nodes. Defaults to 'every day at midnight'.
clear-nodes-cron: "${MQTT_RETAIN_MSG_TRIE_CLEAR_NODES_CRON:0 0 0 * * *}"
# Timezone for the retain msg clearing cron-job.
clear-nodes-zone: "${MQTT_RETAIN_MSG_TRIE_CLEAR_NODES_ZONE:UTC}"
retain-msg:
# Processing period for clearing retained messages by the MQTT expiry feature (in ms).
expiry-processing-period-ms: "${MQTT_RETAIN_MSG_EXPIRY_PROCESSING_PERIOD_MS:60000}"
client-session-expiry:
# Cron job to schedule clearing of expired and inactive client sessions. Defaults to 'every hour', e.g. at 20:00:00 UTC.
cron: "${MQTT_CLIENT_SESSION_EXPIRY_CRON:0 0 * ? * *}"
# Timezone for the client sessions clearing cron-job.
zone: "${MQTT_CLIENT_SESSION_EXPIRY_ZONE:UTC}"
# Maximum allowed expiry interval for inactive sessions (in s). Defaults to one week.
max-expiry-interval: "${MQTT_CLIENT_SESSION_EXPIRY_MAX_EXPIRY_INTERVAL:604800}"
# Administration TTL for clearing sessions that do not expire by session expiry interval (in s).
# (e.g. MQTTv3 cleanSession=false or MQTTv5 cleanStart=false && sessionExpiryInterval == 0).
# Defaults to one week. A value of 0 or negative disables this TTL.
ttl: "${MQTT_CLIENT_SESSION_EXPIRY_TTL:604800}"
version-3-1:
# Maximum client ID length for MQTT 3.1.
max-client-id-length: "${MQTT_3_1_MAX_CLIENT_ID_LENGTH:1024}"
# Enables or disables immediate flush of each message published to non-persistent subscribers. When disabled, messages are buffered and flushed periodically.
write-and-flush: "${MQTT_MSG_WRITE_AND_FLUSH:true}"
# Number of messages buffered in the channel before the flush is made. Used when `MQTT_MSG_WRITE_AND_FLUSH` = false.
buffered-msg-count: "${MQTT_BUFFERED_MSG_COUNT:5}"
buffered-delivery:
# When either `MQTT_MSG_WRITE_AND_FLUSH` or `MQTT_PERSISTENT_MSG_WRITE_AND_FLUSH` is set to false,
# the broker buffers outgoing messages in the outbound channel to improve throughput.
# The respective buffer sizes are controlled by `MQTT_BUFFERED_MSG_COUNT` (for non-persistent clients)
# and `MQTT_PERSISTENT_BUFFERED_MSG_COUNT` (for persistent clients).
# Maximum number of session entries stored in the flush state cache.
# When the cache exceeds this size, the least recently used sessions are evicted
# and their pending message buffers are flushed automatically.
session-cache-max-size: "${MQTT_BUFFERED_CACHE_MAX_SIZE:10000}"
# Expiry time for an inactive session entry in the flush cache (in ms).
# A session is considered inactive if it receives no new messages during this period.
# Upon expiration, the session is evicted from the cache and its buffer is flushed.
# Defaults to 5 minutes.
session-cache-expiration-ms: "${MQTT_BUFFERED_CACHE_EXPIRY_MS:300000}"
# Interval at which the scheduler checks all sessions in the cache for potential flushing (in ms).
# A smaller value results in more frequent flush checks.
scheduler-execution-interval-ms: "${MQTT_BUFFERED_SCHEDULER_INTERVAL_MS:100}"
# Maximum time a session can remain idle before its message buffer is automatically flushed to the client (in ms).
# A flush occurs either when the buffer limit is reached or when this timeout elapses.
idle-session-flush-timeout-ms: "${MQTT_BUFFERED_IDLE_FLUSH_MS:200}"
persistent-session:
device:
persisted-messages:
# Maximum number of PUBLISH messages stored for each persisted DEVICE client.
limit: "${MQTT_PERSISTENT_SESSION_DEVICE_PERSISTED_MESSAGES_LIMIT:10000}"
# TTL of persisted DEVICE messages (in s). Defaults to one week.
ttl: "${MQTT_PERSISTENT_SESSION_DEVICE_PERSISTED_MESSAGES_TTL:604800}"
# Enables or disables immediate flush of each message published to persistent DEVICE client subscribers. When disabled, messages are buffered and flushed periodically.
write-and-flush: "${MQTT_PERSISTENT_MSG_WRITE_AND_FLUSH:true}"
# Number of messages buffered in the channel before the flush is made. Used when `MQTT_PERSISTENT_MSG_WRITE_AND_FLUSH` = false.
buffered-msg-count: "${MQTT_PERSISTENT_BUFFERED_MSG_COUNT:5}"
app:
persisted-messages:
# Enables or disables immediate flush of each message published to persistent APPLICATION client subscribers. When disabled, messages are buffered and flushed periodically.
write-and-flush: "${MQTT_APP_MSG_WRITE_AND_FLUSH:false}"
# Number of messages buffered in the channel before the flush is made. Used when `MQTT_APP_MSG_WRITE_AND_FLUSH` = false.
buffered-msg-count: "${MQTT_APP_BUFFERED_MSG_COUNT:10}"
rate-limits:
total:
# Enables or disables the cluster-wide total throughput quota.
enabled: "${MQTT_TOTAL_RATE_LIMITS_ENABLED:false}"
# Quota bucket definition. Comma-separated list of capacity:seconds bandwidths.
# The default sustains ~833 messages per second and allows a 50000-packet burst.
# Capacity is also the most a single publish can charge, so keep it above your widest fan-out.
# Applied on broker start.
config: "${MQTT_TOTAL_RATE_LIMITS_CONFIG:50000:60}"
# Number of quota tokens a node draws from Redis per round trip. 0 derives max(1, sustainedRate / 10).
block-size: "${MQTT_TOTAL_RATE_LIMITS_BLOCK_SIZE:0}"
# Period of the tick returning a node's unused drawn tokens to the shared bucket (in ms). 0 disables the tick.
lease-return-ms: "${MQTT_TOTAL_RATE_LIMITS_LEASE_RETURN_MS:1000}"
# How long the quota keeps granting after it loses the shared Redis bucket (in ms). 0 refuses on the first failed draw.
degraded-grace-ms: "${MQTT_TOTAL_RATE_LIMITS_DEGRADED_GRACE_MS:30000}"
incoming-publish:
# Enables or disables publish rate limits per client for incoming messages to the broker.
enabled: "${MQTT_INCOMING_RATE_LIMITS_ENABLED:false}"
# Limits the count of publish messages per publisher per time interval (in s). Comma-separated list of limit:seconds pairs.
# Example: 10 messages per second or 300 messages per minute.
client-config: "${MQTT_INCOMING_RATE_LIMITS_CLIENT_CONFIG:10:1,300:60}"
outgoing-publish:
# Enables or disables publish rate limits per client for outgoing messages to subscribers. Applies only to non-persistent subscribers with QoS = 0 (`AT_MOST_ONCE`).
enabled: "${MQTT_OUTGOING_RATE_LIMITS_ENABLED:false}"
# Limits the count of publish messages per subscriber per time interval (in s). Comma-separated list of limit:seconds pairs.
# Example: 10 messages per second or 300 messages per minute.
client-config: "${MQTT_OUTGOING_RATE_LIMITS_CLIENT_CONFIG:10:1,300:60}"
device-persisted-messages:
# Enables or disables Device clients persisted messages rate limits for the broker (per whole cluster).
enabled: "${MQTT_DEVICE_PERSISTED_MSGS_RATE_LIMITS_ENABLED:false}"
# Limits the count of Device clients persisted messages per time interval (in s). Comma-separated list of limit:seconds pairs.
# Example: 100 messages per second or 1000 messages per minute.
# Applied on broker start. Changing this value resets the token counters across the cluster when more than one
# limit:seconds pair is configured, granting one full interval of fresh budget.
config: "${MQTT_DEVICE_PERSISTED_MSGS_RATE_LIMITS_CONFIG:100:1,1000:60}"
# Total limit of sessions (connected + disconnected) stored on the broker, applied collectively across the cluster, not per node.
# For example, when set to 1000, the entire cluster can store 1000 sessions in total. This is a soft limit, meaning slightly more sessions may be stored.
# Defaults to 0, which disables the limit.
sessions-limit: "${MQTT_SESSIONS_LIMIT:0}"
# Total limit for Application persistent clients and external system integrations. Defaults to 0, which disables the limit.
application-clients-limit: "${MQTT_APPLICATION_CLIENTS_LIMIT:0}"
handler:
# Number of threads in the pool for processing all publish messages callbacks after sending them to Kafka.
all_msg_callback_threads: "${MQTT_HANDLER_ALL_MSG_CALLBACK_THREADS:2}"
# Number of threads in the pool for processing device persisted publish messages callbacks after sending them to Kafka.
device_msg_callback_threads: "${MQTT_HANDLER_DEVICE_MSG_CALLBACK_THREADS:2}"
# Number of threads in the pool for processing application persisted publish messages callbacks after sending them to Kafka.
app_msg_callback_threads: "${MQTT_HANDLER_APP_MSG_CALLBACK_THREADS:2}"
# Number of threads in the pool for processing downlink messages callbacks after sending them to Kafka.
downlink_msg_callback_threads: "${MQTT_HANDLER_DOWNLINK_MSG_CALLBACK_THREADS:2}"
# Response info value for the MQTT 5 request-response feature, returned to clients that request it.
# If not set, the broker will not reply with response info to MQTT 5 clients that connect with `request response info` = 1.
# Set it to the topic to be used for the request-response feature, e.g. `example/`.
response-info: "${MQTT_RESPONSE_INFO:}"
blocked-client:
cleanup:
# Execution period of the cleanup task for expired blocked clients (in minutes). Defaults to five minutes.
period: "${BLOCKED_CLIENT_CLEANUP_PERIOD_MINUTES:5}"
# TTL for expired blocked clients (in minutes). After this time, the expired blocked client is removed completely. Defaults to one week.
ttl: "${BLOCKED_CLIENT_CLEANUP_TTL_MINUTES:10080}"
# Connectivity properties
device:
connectivity:
mqtts:
# Path to the MQTT root CA certificate file.
pem_cert_file: "${MQTTS_CA_CERT:cafile.pem}"
# Filename for the downloaded MQTT root CA certificate.
pem_cert_file_name: "${MQTTS_CA_CERT_NAME:tbmq-ca-cert.pem}"
# Cache parameters
cache:
stats:
# Enables or disables cache stats logging.
enabled: "${CACHE_STATS_ENABLED:true}"
# Cache stats logging interval (in s).
intervalSec: "${CACHE_STATS_INTERVAL_SEC:60}"
# Common prefix for all cache keys. Defaults to empty string, meaning no prefix is applied.
cache-prefix: "${CACHE_PREFIX:}"
specs:
mqttClientCredentials:
# Cache TTL (in minutes). Defaults to 1 day.
timeToLiveInMinutes: "${CACHE_SPECS_MQTT_CLIENT_CREDENTIALS_TTL:1440}"
basicCredentialsPassword:
# Cache TTL (in minutes). Recommended to set a small value to limit credential storage duration (e.g., 1-5 minutes).
timeToLiveInMinutes: "${CACHE_SPECS_BASIC_CREDENTIALS_PASSWORD_TTL:1}"
sslRegexBasedCredentials:
# Cache TTL (in minutes). Defaults to 1 day.
timeToLiveInMinutes: "${CACHE_SPECS_SSL_REGEX_BASED_CREDENTIALS_TTL:1440}"
clientSessionCredentials:
# Cache TTL (in minutes). Defaults to 0, meaning the cache is eternal.
timeToLiveInMinutes: "${CACHE_SPECS_CLIENT_SESSION_CREDENTIALS_TTL:0}"
clientMqttVersion:
# Cache TTL (in minutes). Defaults to 0, meaning the cache is eternal.
timeToLiveInMinutes: "${CACHE_SPECS_CLIENT_MQTT_VERSION_TTL:0}"
# Redis configuration parameters
redis:
connection:
# Connection type. Accepted values: standalone, cluster, sentinel.
type: "${REDIS_CONNECTION_TYPE:standalone}"
standalone:
# Redis connection host.
host: "${REDIS_HOST:localhost}"
# Redis connection port.
port: "${REDIS_PORT:6379}"
# Enables or disables the default Redis client configuration.
useDefaultClientConfig: "${REDIS_USE_DEFAULT_CLIENT_CONFIG:true}"
# Client name. Applies only when not using the default ClientConfig.
clientName: "${REDIS_CLIENT_NAME:standalone}"
# Connection timeout (in ms). Applies only when not using the default ClientConfig.
connectTimeout: "${REDIS_CLIENT_CONNECT_TIMEOUT:30000}"
# Read timeout (in ms). Applies only when not using the default ClientConfig.
readTimeout: "${REDIS_CLIENT_READ_TIMEOUT:60000}"
# Enables or disables pool config. Applies only when not using the default ClientConfig.
usePoolConfig: "${REDIS_CLIENT_USE_POOL_CONFIG:false}"
cluster:
# Comma-separated list of `host:port` pairs to bootstrap from.
nodes: "${REDIS_NODES:}"
# Maximum number of redirects to follow when executing commands across the cluster.
maxRedirects: "${REDIS_MAX_REDIRECTS:12}"
# Enables or disables use of the default pool config. When false, the pool config is built from the `pool_config` section values.
useDefaultPoolConfig: "${REDIS_CLUSTER_USE_DEFAULT_POOL_CONFIG:true}"
sentinel:
# Name of the master node.
master: "${REDIS_MASTER:}"
# Comma-separated list of `host:port` pairs of sentinels.
sentinels: "${REDIS_SENTINELS:}"
# Optional. Username to authenticate with the Sentinel (Sentinel ACL).
username: "${REDIS_SENTINEL_USERNAME:}"
# Password to authenticate with the Sentinel.
password: "${REDIS_SENTINEL_PASSWORD:}"
# Enables or disables use of the default pool config. When false, the pool config is built from the `pool_config` section values.
useDefaultPoolConfig: "${REDIS_SENTINEL_USE_DEFAULT_POOL_CONFIG:true}"
# DB index.
db: "${REDIS_DB:0}"
# Optional. Username for Redis ACL authentication (Redis 6+).
username: "${REDIS_USERNAME:}"
# DB password.
password: "${REDIS_PASSWORD:}"
# SSL/TLS configuration parameters.
ssl:
# Enables or disables TLS for Redis connections. Applies to all connection types: standalone, sentinel, cluster.
enabled: "${REDIS_SSL_ENABLED:false}"
credentials:
# Path to the CA certificate PEM file used to verify the Redis server certificate. Required when SSL is enabled.
cert_file: "${REDIS_SSL_CERT_FILE:}"
# Optional. Path to the client certificate PEM file. Required only for mutual TLS (mTLS).
user_cert_file: "${REDIS_SSL_USER_CERT_FILE:}"
# Optional. Path to the client private key PEM file. Required only for mutual TLS (mTLS).
user_key_file: "${REDIS_SSL_USER_KEY_FILE:}"
# Pool config.
pool_config:
# Maximum number of connections that can be allocated by the connection pool.
maxTotal: "${REDIS_POOL_CONFIG_MAX_TOTAL:128}"
# Maximum number of idle connections that can be maintained in the pool without being closed.
maxIdle: "${REDIS_POOL_CONFIG_MAX_IDLE:128}"
# Minimum number of idle connections that can be maintained in the pool without being closed.
minIdle: "${REDIS_POOL_CONFIG_MIN_IDLE:16}"
# Enables or disables the PING command sent when a connection is borrowed.
testOnBorrow: "${REDIS_POOL_CONFIG_TEST_ON_BORROW:true}"
# Enables or disables testing the connection before returning it to the pool.
testOnReturn: "${REDIS_POOL_CONFIG_TEST_ON_RETURN:true}"
# Enables or disables using the PING command to monitor connection validity during idle resource monitoring. Invalid connections are destroyed.
testWhileIdle: "${REDIS_POOL_CONFIG_TEST_WHILE_IDLE:true}"
# Minimum time a connection must be idle before it can be evicted from the pool (in ms).
minEvictableMs: "${REDIS_POOL_CONFIG_MIN_EVICTABLE_MS:60000}"
# Time interval between two consecutive eviction runs (in ms).
evictionRunsMs: "${REDIS_POOL_CONFIG_EVICTION_RUNS_MS:30000}"
# Maximum time a client is willing to wait for a connection from the pool when all connections are exhausted (in ms).
maxWaitMills: "${REDIS_POOL_CONFIG_MAX_WAIT_MS:60000}"
# Number of connections to test for eviction during each eviction run.
numberTestsPerEvictionRun: "${REDIS_POOL_CONFIG_NUMBER_TESTS_PER_EVICTION_RUN:3}"
# Enables or disables blocking when a thread requests a connection from an exhausted pool.
blockWhenExhausted: "${REDIS_POOL_CONFIG_BLOCK_WHEN_EXHAUSTED:true}"
# Statistics parameters
stats:
# Enables or disables stats printing to the logs.
enabled: "${STATS_ENABLED:true}"
# Print interval for statistics (in ms). Defaults to 1 minute.
print-interval-ms: "${STATS_PRINT_INTERVAL_MS:60000}"
timer:
# Metrics percentiles returned by actuator for timer metrics. List of comma-separated double values.
percentiles: "${STATS_TIMER_PERCENTILES:0.5}"
application-processor:
# Enables or disables per-Application-client processing stats. When enabled, each Application client gets its own set
# of counters tagged with `clientId` (deregistered when the client disconnects); the appProcessor.latency timers are
# aggregated globally (keyed only by packetType, with no per-client tag). On a broker with very many Application
# clients the per-client counter cardinality can be high, so enable only when per-client stats are needed.
enabled: "${APPLICATION_PROCESSOR_STATS_ENABLED:true}"
system-info:
# Persistence frequency of system info such as CPU and memory usage (in s).
persist-frequency: "${STATS_SYSTEM_INFO_PERSIST_FREQUENCY_SEC:60}"
# Historical data statistics parameters
historical-data-report:
# Enables or disables historical data stats reporting and persistence to the time series.
enabled: "${HISTORICAL_DATA_REPORT_ENABLED:true}"
# Collection period for per-broker statistics (in minutes, range 1-60). Used in the cron expression.
interval: "${HISTORICAL_DATA_REPORT_INTERVAL:1}"
# Timezone for the historical data stats processing.
zone: "${HISTORICAL_DATA_REPORT_ZONE:UTC}"
# Metrics management parameters
management:
health:
diskspace:
# Enables or disables disk space health check.
enabled: "${HEALTH_DISKSPACE_ENABLED:false}"
endpoint:
health:
# Visibility of full component details in the health endpoint response (e.g., Redis, DB, TBMQ). Accepted values:
# never - always hide details (default if security is enabled).
# when-authorized - show details only to authenticated users.
# always - always include full health details in the response.
show-details: "${HEALTH_SHOW_DETAILS:never}"
endpoints:
web:
exposure:
# Actuator endpoints exposed via HTTP. Use `health,info` to expose only basic health and information endpoints.
# To expose Prometheus metrics, include `prometheus` in the list (e.g., `health,info,prometheus`).
include: "${METRICS_ENDPOINTS_EXPOSE:health,info,prometheus}"
# Spring CORS configuration
spring.mvc.cors:
mappings:
# Intercept path.
"[/api/**]":
# Comma-separated list of origins to allow. `*` allows all origins. When not set, CORS support is disabled.
allowed-origin-patterns: "${MVC_CORS_API_ALLOWED_ORIGIN_PATTERNS:*}"
# Comma-separated list of methods to allow. `*` allows all methods.
allowed-methods: "${MVC_CORS_API_ALLOWED_METHODS:*}"
# Comma-separated list of headers to allow in a request. `*` allows all headers.
allowed-headers: "${MVC_CORS_API_ALLOWED_HEADERS:*}"
# How long the response from a pre-flight request can be cached by clients (in s).
max-age: "${MVC_CORS_API_MAX_AGE:1800}"
# Enables or disables credentials support. Defaults to not supported when not set.
allow-credentials: "${MVC_CORS_API_ALLOW_CREDENTIALS:true}"
# Spring doc common parameters
springdoc:
# Enables or disables Swagger API docs.
api-docs.enabled: "${SWAGGER_ENABLED:true}"
# Swagger default produces media-type.
default-produces-media-type: "${SWAGGER_DEFAULT_PRODUCES_MEDIA_TYPE:application/json}"
# Swagger common parameters
swagger:
# General Swagger match pattern for Swagger UI links.
api_path: "${SWAGGER_API_PATH:/api/**}"
# General Swagger security match pattern path for Swagger UI links.
security_path_regex: "${SWAGGER_SECURITY_PATH_REGEX:/api/.*}"
# Non-security API path match pattern for Swagger UI links.
non_security_path_regex: "${SWAGGER_NON_SECURITY_PATH_REGEX:/api/noauth.*}"
# Title on the API doc UI page.
title: "${SWAGGER_TITLE:TBMQ REST API}"
# Description on the API doc UI page.
description: "${SWAGGER_DESCRIPTION:TBMQ open-source REST API documentation}"
contact:
# Contact name on the API doc UI page.
name: "${SWAGGER_CONTACT_NAME:TBMQ team}"
# Contact URL on the API doc UI page.
url: "${SWAGGER_CONTACT_URL:https://tbmq.io/}"
# Contact email on the API doc UI page.
email: "${SWAGGER_CONTACT_EMAIL:info@thingsboard.io}"
license:
# License title on the API doc UI page.
title: "${SWAGGER_LICENSE_TITLE:Apache License Version 2.0}"
# Link to the license body on the API doc UI page.
url: "${SWAGGER_LICENSE_URL:https://github.com/thingsboard/tbmq/blob/main/LICENSE}"
# Version of the API doc to display. Defaults to the package version.
version: "${SWAGGER_VERSION:}"
# Group name (definition) on the API doc UI page.
group_name: "${SWAGGER_GROUP_NAME:TBMQ}"
# Application info parameters
app:
# Application version.
version: "@project.version@"
# Analysis parameters
analysis:
log:
# Enables or disables analysis logging.
enabled: "${ANALYSIS_LOG_ENABLED:true}"
# Enables or disables logging events for all clients. When true, ignores the `analyzed-client-ids` list.
all-clients: "${ANALYSIS_LOG_ALL_CLIENTS:false}"
# Comma-separated list of client IDs for which additional events will be logged.
# Example env var: ANALYSIS_LOG_CLIENT_IDS=client1,client2.
analyzed-client-ids: "${ANALYSIS_LOG_CLIENT_IDS:}"