Message key and value in Kafka - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to send a message with a key in Kafka producer.

Kafka

producer.send('my_topic', key=[1], value=b'My message')

Drag options to blanks, or click blank then click option'

Ab'key1'

B'key1'

C123

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Using a string without b prefix causes type errors.

Using None as key when a key is expected.

Kafka message keys must be bytes, so the key should be a bytes object like b'key1'.

2fill in blank

medium

Complete the code to deserialize the message value as a UTF-8 string.

Kafka

message_value = record.value().[1]('utf-8')

Drag options to blanks, or click blank then click option'

AtoString

Bdecode

Cencode

Dparse

Attempts:

3 left

💡 Hint

Common Mistakes

Using encode instead of decode reverses the operation.

Using parse or toString are not valid methods on bytes.

To convert bytes to string, use decode('utf-8').

3fill in blank

hard

Fix the error in the code to correctly set the message key as a string converted to bytes.

Kafka

key_str = 'user123'
producer.send('topic', key=[1], value=b'data')

Drag options to blanks, or click blank then click option'

Abytes(key_str)

Bkey_str

Ckey_str.encode()

Dstr(key_str)

Attempts:

3 left

💡 Hint

Common Mistakes

Passing string directly causes type error.

Using bytes(string) without encoding causes error.

Using str() returns string, not bytes.

To convert a string to bytes, use encode(). bytes() without encoding argument won't work on string.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension mapping keys to values from a list of tuples.

Kafka

message_dict = { [1]: [2] for [1], [2] in records }

Drag options to blanks, or click blank then click option'

Akey

Bvalue

Crecord

Ditem

Attempts:

3 left

💡 Hint

Common Mistakes

Using same variable for key and value.

Using wrong variable names that don't match unpacking.

In a dict comprehension, use key: value for key, value in records to unpack tuples.

5fill in blank

hard

Fill all three blanks to filter messages with key length greater than 3 and create a dict of key-value pairs.

Kafka

filtered = { [1]: [2] for [1], [2] in messages if len([3]) > 3 }

Drag options to blanks, or click blank then click option'

Akey

Bvalue

Dmsg

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong variable names in comprehension.

Filtering by length of value instead of key.

Use key and value for dict comprehension and check length of key for filtering.

Practice

1. What is the primary role of the message key in Kafka?

easy

A. To decide which partition the message goes to

B. To store the actual data of the message

C. To encrypt the message content

D. To delete old messages automatically

Solution

1. Step 1: Understand message key purpose

   The message key in Kafka is used to determine the partition where the message will be stored.

2. Step 2: Differentiate key and value roles

   The message value holds the actual data, while the key helps with partitioning and ordering.

3. Final Answer:

   To decide which partition the message goes to -> Option A

4. Quick Check:

   Message key = Partition decision [OK]

Hint: Key decides partition, value holds data [OK]

Common Mistakes:

• Confusing key with message value
• Thinking key encrypts data
• Assuming key deletes messages

2. Which of the following is the correct way to send a Kafka message with a key and value in Java?

easy

A. producer.send(new ProducerRecord<>("topic", value));

B. producer.send(new ProducerRecord<>(key, value));

C. producer.send("topic", value);

D. producer.send(new ProducerRecord<>("topic", key, value));

Solution

1. Step 1: Review ProducerRecord constructor

   The correct constructor for sending a message with key and value includes topic, key, and value in that order.

2. Step 2: Check each option

   producer.send(new ProducerRecord<>("topic", key, value)); uses new ProducerRecord<>("topic", key, value), which is correct syntax. Others miss topic or key.

3. Final Answer:

   producer.send(new ProducerRecord<>("topic", key, value)); -> Option D

4. Quick Check:

   ProducerRecord(topic, key, value) = correct [OK]

Hint: ProducerRecord needs topic, key, then value [OK]

Common Mistakes:

• Omitting the topic parameter
• Swapping key and value order
• Using wrong constructor overload

3. Given the following Kafka producer code snippet, what will be the key of the message sent?

ProducerRecord record = new ProducerRecord<>("orders", "12345", "order details");
producer.send(record);

medium

A. "orders"

B. null

C. "12345"

D. "order details"

Solution

1. Step 1: Identify parameters in ProducerRecord

   The constructor is ProducerRecord(topic, key, value). Here, "orders" is topic, "12345" is key, and "order details" is value.

2. Step 2: Determine the key value

   The key is the second argument, which is "12345".

3. Final Answer:

   "12345" -> Option C

4. Quick Check:

   Second argument = key = "12345" [OK]

Hint: Second argument in ProducerRecord is key [OK]

Common Mistakes:

• Confusing topic with key
• Choosing message value as key
• Assuming key is null if not obvious

4. Identify the error in this Kafka producer code snippet:

ProducerRecord record = new ProducerRecord<>("topic", null, "data");
producer.send(record);

medium

A. Message key cannot be null

B. This code is valid; no error

C. ProducerRecord constructor parameters are in wrong order

D. Message value cannot be null

Solution

1. Step 1: Check if null key is allowed

   Kafka allows message keys to be null; this means messages can be sent without a key.

2. Step 2: Verify constructor usage

   The constructor ProducerRecord<>("topic", null, "data") is valid and sends a message with no key.

3. Final Answer:

   This code is valid; no error -> Option B

4. Quick Check:

   Null key allowed in Kafka messages [OK]

Hint: Null keys are allowed in Kafka messages [OK]

Common Mistakes:

• Assuming key must never be null
• Confusing parameter order
• Thinking value cannot be null without checking

5. You want to ensure all messages with the same user ID go to the same partition for ordering. Which Kafka message feature should you use and how?

hard

A. Use the user ID as the message key to ensure partitioning by key

B. Include the user ID only in the message value and leave key null

C. Set the user ID as the topic name

D. Send messages without keys and rely on default partitioning

Solution

1. Step 1: Understand partitioning by key

   Kafka uses the message key to decide the partition. Messages with the same key go to the same partition.

2. Step 2: Apply to user ID scenario

   Using the user ID as the message key ensures all messages for that user go to the same partition, preserving order.

3. Final Answer:

   Use the user ID as the message key to ensure partitioning by key -> Option A

4. Quick Check:

   Key = user ID for partitioning [OK]

Hint: Use key for grouping messages by user ID [OK]

Common Mistakes:

• Putting user ID only in value loses partition control
• Changing topic per user is inefficient
• Relying on default partitioning breaks ordering