TBMQ 2.1: New chapter in MQTT messaging with embedded Integrations

We’re excited to announce the release of TBMQ 2.1.0! This version marks a major milestone by introducing the Integration Executor microservice, which is responsible for managing integrations. It powers scalable and multi-protocol message delivery to external systems, starting with support for HTTP, Kafka, and MQTT outbound integrations. We’ve also released the official Helm Chart for TBMQ, simplifying deployment and management of the infrastructure in K8s environments.

Integration Executor

At the heart of TBMQ 2.1 is the Integration Executor — a new dedicated microservice that launches and manages integrations in a scalable and resilient way, all built upon a no data loss architecture for maximum reliability.

Rather than embedding integration logic inside the broker, TBMQ delegates this responsibility to the Integration Executor. This architecture ensures clean responsibility segregation, allowing the broker to focus on MQTT protocol handling while the executor takes care of message delivery to external systems. The result: better performance, isolation, and scalability.

The Integration Executor communicates with TBMQ via Kafka, which acts as a buffer and transport layer. When an MQTT message matches an integration subscription, TBMQ transforms it into an integration event and routes it through Kafka to the appropriate executor instance. The executor then forwards it to the configured destination, such as an HTTP endpoint, a Kafka topic, or another MQTT broker.

Highlights:

• Clear separation between MQTT protocol logic and integration delivery.
• Built-in support for HTTP, Kafka, and MQTT outbound integrations.
• Horizontally scalable: run multiple executors in parallel.
• Each integration uses a dedicated Kafka topic for message processing isolation and high throughput.
• Advanced error handling with retry strategies and rich monitoring metrics.

This architecture ensures fault-tolerant, no-loss message delivery, powered by Kafka-backed buffering and resilient processing. Learn more about how the Integration Executor works in our official documentation.

Integrations

TBMQ 2.1 introduces a robust and extensible integration system, allowing you to forward MQTT messages to external systems for storage, processing, or real-time workflows.

This release includes three outbound integration types:

• HTTP Integration – Send MQTT messages to REST APIs or Webhooks over HTTP(S).
• Kafka Integration – Forward messages to Kafka topics using the native Kafka protocol over TCP(TLS).
• MQTT Integration – Bridge TBMQ to other MQTT brokers, enabling cross-broker communication over MQTT(S).

Each integration is easy to configure through the TBMQ Web UI or REST API. You can define topic filters, connection parameters, and enable/disable integrations independently. When messages match the defined filters, they’re automatically routed to the correct external system, all handled asynchronously through the Integration Executor microservice.

These integrations empower developers to:

• Build event-driven pipelines across systems.
• Stream IoT data to analytics platforms or data lakes.
• Connect TBMQ with legacy systems, cloud services, or third-party platforms.

With support for multiple integrations running in parallel, a scalable execution model, and guaranteed message delivery, TBMQ makes it easy to integrate MQTT data into your broader infrastructure.

HTTP Integration

The HTTP Integration allows you to forward MQTT messages to REST APIs and Webhooks in real time. This is ideal for integrating TBMQ with cloud platforms, serverless functions, or any service that exposes an HTTP(S) endpoint.

Key highlights:

• Supports HTTP and HTTPS protocols.
• Customizable headers, payload format, and authentication options.
• Great for notifying external systems or activating business logic.

Thanks to its simplicity and versatility, HTTP Integration is one of the most popular and widely applicable options for IoT and messaging pipelines.

MQTT Integration

The MQTT Integration lets you forward messages from TBMQ to external MQTT brokers, enabling broker-to-broker communication. This is useful in multi-tier or multi-region architectures.

This integration makes it easy to connect TBMQ with other MQTT ecosystems, whether you’re relaying messages between cloud and edge, syncing environments, or bridging to legacy platforms.

Key highlights:

• Connects to other brokers using MQTT or MQTTS.
• Ideal for cross-broker communication, data replication, or interconnecting isolated clusters.
• Supports topic filters and customizable forwarding rules.
• Can act as a bridge between TBMQ and third-party brokers like Mosquitto, or ThingsBoard MQTT transport.

Use this integration to extend TBMQ’s reach across environments — securely and efficiently.

Kafka Integration

The Kafka Integration enables TBMQ to stream messages directly into Kafka topics using the Kafka binary protocol (TCP/TLS). It’s designed for high-throughput, event-driven data pipelines, and real-time processing.

Key highlights:

• Supports native Kafka connectivity.
• Automatically maps MQTT topics to Kafka topics.
• Ideal for big data, analytics, and stream processing use cases.
• Compatible with any Kafka deployment like Confluent, MSK, or self-managed clusters.

This integration bridges the MQTT world with modern event streaming systems and allows for scalable downstream processing.

Helm chart

Helm is the most widely adopted package manager for Kubernetes. It simplifies the deployment and management of complex applications by bundling all Kubernetes manifests and configuration options into reusable charts. With our Helm chart, TBMQ users can deploy the entire stack, including Broker nodes, Integration Executors, and dependencies, in a repeatable and standardized way using just a few commands.

Benefits of Using Helm

• Faster deployments: Helm enables quick, consistent setup of TBMQ in both development and production environments.
• Configurability: Users can easily override settings (e.g., database credentials, resource limits, and MQTT settings) via a values.yaml file without editing templates.
• Environment-specific setups: Maintain tailored configurations for development, staging, or production, reducing deployment errors.
• Upgrades and rollbacks: Helm tracks release history, making it easy to roll back to a stable version if something goes wrong.
• CI/CD integration: Helm naturally fits into GitOps workflows and automates cluster deployments in CI/CD pipelines.

What’s Included in the TBMQ Helm Chart?

Our official chart provides everything you need to run TBMQ in a cloud-native way:

• Core TBMQ broker deployment with support for MQTT and MQTT over TLS.
• Integration Executor microservice with configuration for supported integration types (HTTP, MQTT, Kafka).
• Built-in sub-charts deployment of PostgreSQL, Redis, and Kafka.
• Configurable Ingress with TLS, LoadBalancer services with TLS support, Kubernetes readiness/liveness probes, and persistent storage for stateful components.

Angular 19

We’ve upgraded the TBMQ UI from Angular 15 to Angular 19, bringing significant improvements in performance, user experience, and long-term maintainability. This upgrade also improves compatibility with modern libraries and tooling, ensuring that the platform remains future-ready. Alongside the version bump, we’ve replaced Angular Flex-Layout with Tailwind CSS for cleaner and faster styling and switched to Angular’s esbuild builder for improved build performance. These changes collectively result in a more responsive, polished, and maintainable interface.

Final words

We’re thrilled to bring you this powerful update, and we can’t wait to see what you build with it.
Check out the full documentation on Integrations and deploy TBMQ 2.1 using our official Helm Chart on ArtifactHub.
Support us by starring the TBMQ GitHub repository, sharing feedback, and opening issues or PRs.