Tool Relations

QuestDB provides a PostgreSQL wire protocol interface that allows Grafana to connect using the native PostgreSQL data source plugin.

Apache StreamPipes

→

Apache Pulsar

Integrates with

StreamPipes can consume and produce data streams via Apache Pulsar, using Pulsar as a high-performance message broker for IIoT data ingestion and distribution.

Node-RED can produce and consume Kafka messages through Confluent Platform, enabling visual flow-based integration with industrial protocols and enterprise systems.

Confluent Platform integrates with InfluxDB through Kafka Connect sink connectors, enabling real-time streaming of sensor and event data into time-series storage.

RabbitMQ can feed time-series data to InfluxDB through consumer applications or middleware like Telegraf, enabling IoT data pipelines.

RabbitMQ integrates with Node-RED through the AMQP and MQTT nodes, enabling visual flow-based programming for message routing and processing.

Strimzi integrates with Grafana through Prometheus metrics. The Strimzi Metrics Reporter exposes Kafka metrics in Prometheus format, which can be visualized in Grafana dashboards for monitoring cluster health, throughput, and performance.

Apache Flink and Node-RED can be integrated to combine visual flow-based programming with powerful stream processing capabilities for industrial IoT applications.

Apache Flink can write processed time-series data to InfluxDB via JDBC connector or custom sinks, enabling real-time storage and visualization of industrial metrics.

Apache Flink provides a native, high-performance connector for Apache Kafka, enabling seamless integration between the stream processing engine and the distributed messaging platform.

Grafana provides native Redis connectivity through the Redis Data Source plugin, enabling visualization of Redis Streams, time-series data, and key metrics.

Eclipse Kapua can forward device telemetry to InfluxDB for time-series storage and analytics. This combination enables long-term data retention and powerful querying capabilities.

Eclipse Kapua and Node-RED can be integrated to create powerful IoT workflows. Kapua manages devices and ingests data, while Node-RED provides visual workflow orchestration and data processing.

Eclipse Kapua and Eclipse Hono are both Eclipse IoT connectivity platforms. While Kapua focuses on device management, Hono specializes in telemetry and command messaging for IoT.

Eclipse Kapua and Eclipse Kura form a complete edge-to-cloud IoT solution. Kura runs on edge gateways and devices, while Kapua provides the cloud backend for device management.

NATS and InfluxDB form a powerful combination for real-time time-series data collection and storage in IIoT deployments.

Eclipse Kapua and Eclipse Ditto complement each other in IoT deployments. Kapua handles device management and connectivity, while Ditto provides digital twin capabilities for device state management.

Eclipse Kapua uses Mosquitto as its underlying MQTT broker for device communication. While Kapua provides the device management layer, Mosquitto handles the actual MQTT message routing between devices and the cloud backend.

Node-RED provides native Redis connectivity through the node-red-contrib-redis package, enabling flow-based integration with Redis Streams for industrial IoT pipelines.

Pulsar can stream high-throughput IoT and event data into InfluxDB for time-series storage and analysis.

Eclipse Kura includes built-in MQTT broker support and can integrate with Mosquitto for message brokering at the edge.

StreamPipes can consume Kafka streams for industrial IoT analytics and processing.

Node-RED can produce and consume Kafka messages for IoT data flows.

Eclipse Kura can feed device data into Eclipse Ditto digital twins, providing the edge-to-cloud bridge for digital twin state management.

Eclipse Kura edge gateways can publish telemetry to Eclipse Hono's MQTT adapter, enabling cloud-scale device connectivity with protocol abstraction.

Kafka metrics and streaming data can be visualized in Grafana dashboards for real-time monitoring.

Kafka can stream high-throughput IoT sensor data into InfluxDB for time-series storage and analysis.

Eclipse Ditto connects to MQTT brokers like Eclipse Mosquitto to consume device telemetry and send commands. Ditto's Connectivity service supports MQTT 3.1.1 and MQTT 5 protocols.

Eclipse Ditto and Eclipse Hono are designed to work together in IoT architectures. Hono provides device connectivity and protocol abstraction, while Ditto provides the digital twin layer for state management and APIs.

Node-RED can consume telemetry and events from Eclipse Hono's northbound AMQP or Kafka APIs, enabling visual flow-based processing of device data.

Eclipse Hono normalizes telemetry from IoT devices and forwards it to downstream consumers. InfluxDB is a common destination for time-series telemetry data ingested through Hono pipelines.

Eclipse Hono includes an MQTT protocol adapter that allows devices to connect using MQTT, similar to how they would connect to Mosquitto. Hono can use an existing MQTT broker as its messaging infrastructure or expose its own MQTT adapter endpoint.

Node-RED can send processed data to ThingsBoard via MQTT or REST API. Some deployments use Node-RED for complex flow logic and protocol translation at the edge, feeding results into ThingsBoard for centralized dashboards and device management.

ThingsBoard's MQTT transport layer can connect to Mosquitto brokers, or ThingsBoard can act as its own MQTT broker (via TBMQ). Devices publishing to a Mosquitto broker can be ingested into ThingsBoard using the IoT Gateway's MQTT connector.

ThingsBoard can push telemetry data to Grafana via PostgreSQL or Cassandra as a shared data source. Some teams run Grafana alongside ThingsBoard for more advanced visualization, though ThingsBoard's built-in dashboards cover most monitoring use cases.

Mosquitto publishes MQTT messages that Telegraf (InfluxData's collection agent, part of the InfluxDB ecosystem) subscribes to and writes into InfluxDB. Telegraf acts as the bridge — it's a standalone agent from InfluxData that collects metrics from 300+ sources, including MQTT brokers, and writes them to InfluxDB. This Mosquitto → Telegraf → InfluxDB pipeline is the data ingestion path in the MING stack.

Explore integrations, comparisons, and dependencies between manufacturing tools.