Now Reading
MQTT vs Kafka: An IoT Advocate’s Perspective (Half 1 – The Fundamentals)

MQTT vs Kafka: An IoT Advocate’s Perspective (Half 1 – The Fundamentals)

2023-03-14 13:36:24

With the Kafka Summit quick approaching, I assumed it was time to get my fingers soiled and see what it’s all about. As an advocate for IoT, I heard about Kafka however was too embedded in protocols like MQTT to research additional. For the uninitiated (like me) each protocols appear extraordinarily comparable if not nearly competing. Nevertheless, I’ve realized that is removed from the case and truly, in lots of circumstances, they complement each other.

On this weblog sequence, I hope to summarize what Kafka and MQTT are and the way they’ll each match into an IoT structure. To assist clarify a number of the ideas, I assumed it could be sensible to make use of a previous situation:

monitoring-emergency fuel generators

Within the previous blog, we mentioned a situation the place we wished to watch emergency gas mills. We created a simulator with the InfluxDB Python Consumer library to ship generator knowledge to InfluxDB Cloud. For this weblog, I made a decision to reuse that simulator however substitute the consumer library with an MQTT writer and Kafka producer to grasp the core mechanics behind every.

You could find the code for this demo here.

Understanding the fundamentals

So what’s Kafka? Kafka is described as an occasion streaming platform. It conforms to a publisher-subscriber structure with the additional benefit of information persistence (to grasp extra of the basics, take a look at this blog). Kafka additionally promotes some fairly nice advantages throughout the IoT sector:

  • Excessive throughput
  • Excessive availability
  • Connectors to well-known third-party platforms

So why would I not simply construct my complete IoT platform utilizing Kafka? Nicely, it boils down to some key points:

  1. Kafka is constructed for steady networks which deploy a great infrastructure
  2. It doesn’t deploy key knowledge supply options corresponding to Maintain-Alive and Final Will

Having mentioned this, let’s go forward and examine implementations of writing a fundamental Kafka producer and examine it to an MQTT writer throughout the context of the Emergency generator demo:


Assumptions: For the needs of this demo, I shall be making use of the Mosquitto MQTT Dealer and the Confluent platform (Kafka). We won’t cowl the preliminary creation/setup right here, however you possibly can seek the advice of these directions accordingly:

  1. Mosquito Broker 
  2. Confluent (I extremely suggest utilizing the free trial of Confluent Cloud to sense examine if Kafka is best for you earlier than bogging your self down in an on-prem setup)


Let’s begin with the initialization of our MQTT writer and Kafka producer:


The minimal necessities for an MQTT Writer (omitting safety) are as follows:

  1. Host: The handle / IP of the platform internet hosting the Mosquitto server
  2. Port: Which port will the MQTT producer discuss to. Normally 1883 for fundamental connectivity, 8883 TLS.
  3. Maintain Alive Interval: The period of time in seconds allowed between communications.

self.consumer.join(host=self.mqttBroker,port=self.port, keepalive=MQTT_KEEPALIVE_INTERVAL)


There was a bit extra background work when it got here to Kafka. We needed to set up connectivity to 2 totally different Kafka entities:

  1. Kafka cluster: This can be a given we shall be sending our payload right here.
  2. Schema registry: The registry lies outdoors the scope of the Kafka Cluster. It handles the storing and supply of subject schemers. In different phrases, this forces producers to ship knowledge in a format that’s anticipated by the Kafka shopper. Extra on this later.

So let’s arrange connectivity to each entities:

Schema registry

schema_registry_conf = {'url': '', 
                                '': <USERNAME>:<PASSWORD>'}
     schema_registry_client = SchemaRegistryClient(schema_registry_conf)

The breakdown:

  • url: The handle of your schema registry. Confluent helps the creation of registries for internet hosting.
  • authentication: Like every repository, it incorporates fundamental safety to maintain your schema designs safe.

Kafka cluster

self.json_serializer = JSONSerializer(self.schema_str, schema_registry_client, engine_to_dict)
    self.p = SerializingProducer({
        'bootstrap.servers': '',
        'sasl.mechanism': 'PLAIN',
        'safety.protocol': 'SASL_SSL',
        'sasl.username': '######',
        'sasl.password': '######',
        'error_cb': error_cb,
        'key.serializer': StringSerializer('utf_8'),
        'worth.serializer': self.json_serializer

The breakdown:

  1. bootstrap.servers: In brief, the handle factors to Confluent Cloud internet hosting our Kafka Cluster; extra particularly, a Kafka dealer. (Kafka additionally has the notation of brokers however on a per-topic foundation). Bootstrap is a reference to the producer establishing its presence globally within the cluster.
  2. sasl.*: Easy safety authentication protocol; these are a minimal requirement for connecting to Confluent Kafka. I will not cowl this right here, as it’s of no curiosity to our general comparability.
  3. error_cb: Handles Kafka error dealing with.
  4. key_serializer: This describes how the message key shall be saved inside Kafka. Keys are an especially vital a part of how Kafka handles payloads. Extra on this throughout the subsequent weblog.
  5. Worth.serializer: We are going to cowl this subsequent, in brief, we should describe what kind of information our producer shall be sending. For this reason defining our schema registry is essential.

Subjects and supply

Now that we have now initiated our MQTT writer and Kafka producer, it’s time to ship our Emergency generator knowledge. To do that, each protocols require the institution of a subject and knowledge preparation earlier than supply:


Inside MQTT’s world, a subject is a UTF-8 string that establishes logical filtering between payloads.

Matter Title Payload
temperature 36
gas 400

In Part 2 of this sequence, we break down the capabilities and variations of MQTT and Kafka matters in additional element. For now, we’re going to set up one subject to ship all of our Emergency Generator knowledge (this isn’t greatest follow however is logical within the complexity build-up of this venture).

message = json.dumps(knowledge)
self.consumer.publish(subject="emergency_generator", message)

MQTT has the advantage of with the ability to generate matters on demand in the course of the supply of a payload. If the subject already exists, the payload is just despatched to the established subject. If not, the subject is created. This makes our code comparatively easy. We outline our subject title and the JSON string we plan to ship. MQTT payloads by default are extraordinarily versatile, which has professionals and cons. On the optimistic facet, you don’t want to outline strict schema typing on your knowledge. However, you depend on your subscribers being sturdy sufficient to deal with the incoming messages which fall out of the norm.

See Also


So I have to admit, I got here in with silly optimism that sending a JSON payload through Kafka can be so simple as publish(). How mistaken I used to be! Let’s stroll by means of it:

self.schema_str = """{
            "$schema": "",
            "title": "Generator",
            "description": "A gas engines well being knowledge",
            "kind": "object",
            "properties": {
                "generatorID": {
                "description": "UniqueID of generator",
                "kind": "string"
                "lat": {
                "description": "latitude",
                "kind": "quantity"
                "lon": {
                "description": "longitude",
                "kind": "quantity"
                "temperature": {
                "description": "temperature",
                "kind": "quantity"
                "stress": {
                "description": "stress",
                "kind": "quantity"
                "gas": {
                "description": "gas",
                "kind": "quantity"
            "required": [ "generatorID", "lat", "lon", "temperature", "pressure", "fuel" ]

        schema_registry_conf = {'url': '', 
                                '': environ.get('SCHEMEA_REGISTRY_LOGIN')}
        schema_registry_client = SchemaRegistryClient(schema_registry_conf)

        self.json_serializer = JSONSerializer(self.schema_str, schema_registry_client, engine_to_dict)

        self.p = SerializingProducer({
        'bootstrap.servers': '',
        'sasl.mechanism': 'PLAIN',
        'safety.protocol': 'SASL_SSL',
        'sasl.username': environ.get('SASL_USERNAME'),
        'sasl.password': environ.get('SASL_PASSWORD'),
        'error_cb': error_cb,
        'key.serializer': StringSerializer('utf_8'),
        'worth.serializer': self.json_serializer

The primary activity on our listing is to determine a JSON schema. The JSON schema describes the anticipated construction of our knowledge. In our instance, we outline our generator meter readings (temperature, stress, gas) and likewise our metadata (generdatorID, lat, lon).  Be aware, throughout the definition, we outline their knowledge varieties and which knowledge factors are required to be despatched with every payload.

We now have already mentioned connecting to our schema registry earlier. Subsequent, we need to register our JSON schema with the registry and create a JSON serializer. To do that we want three parameters:

  1. schema_str: the schema design we mentioned
  2. schema _registry_client: Our object connecting to the registry
  3. engine_to_dict: The JSON serializer which lets you write a customized operate for constructing out a Python dictionary struct which shall be transformed to JSON format.

The json_serializer object is then included throughout the initialization of the Serializing Producer.

Lastly to ship knowledge we name our producer object:

self.p.produce(subject=subject, key=str(uuid4()), worth=knowledge, on_delivery=delivery_report)

To ship knowledge to our Kafka cluster we:

  1. Outline our subject title (Kafka by default requires the guide technology of matters. You’ll be able to, through settings throughout the dealer/cluster, permit auto-generation).
  2. Create a novel key for our knowledge, the info we want to publish (this shall be processed by means of our customized operate and supply report (a operate outlined to supply suggestions on profitable or unsuccessful supply of the payload).

My first impression of strongly typed / schemer-based design was: “Wow, this should depart system designers with lots of code to keep up and a steep studying curve”. As I carried out the instance, I spotted you’ll most likely avert lots of future technical debt this manner. Schemers pressure new producers/shoppers to evolve to the present meant knowledge construction or generate a brand new schema model. This enables the present system to proceed unimpeded by a rogue producer connecting to your Kafka cluster. I’m going to cowl this in additional element inside Part 2 of this weblog sequence.

Potential and conclusion

So, what have we performed? Nicely, in its most brutally simplistic type we have now created a Kafka producer and MQTT writer to transmit our generator knowledge. At face worth, it could appear Kafka appears vastly extra complicated in its setup than MQTT for a similar consequence.

At this degree, you’ll be right. Nevertheless, we have now barely scraped the floor of what Kafka can do and the way it ought to be deployed in a real IoT structure. I plan to launch two extra blogs on this sequence:

  • Part 2: I cowl extra of the options distinctive to Kafka, corresponding to a deeper look into matters, scalability and third-party integrations (together with InfluxDB).
  • Part 3: We take what we have now realized and apply greatest practices to an actual IoT venture. We are going to use Kafka’s MQTT proxy and delve deeper into third-party integrations to get probably the most out of your Kafka infrastructure.

Till then take a look at the code, run it, play with it, and enhance it. Next blog (Part 2 of this series) we cowl matters in additional element.

Source Link

What's Your Reaction?
In Love
Not Sure
View Comments (0)

Leave a Reply

Your email address will not be published.

2022 Blinking Robots.
WordPress by Doejo

Scroll To Top