At-most-once delivery in Kafka - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding At-most-once Delivery in Kafka

Which statement best describes at-most-once delivery semantics in Kafka?

A Messages are delivered only if the consumer commits offsets manually.

B Messages are guaranteed to be delivered at least once, possibly multiple times.

C Messages are delivered exactly once, with no duplicates.

D Messages are delivered zero or one time, with no retries on failure.

💡 Hint

Think about what happens if a message fails to be processed or acknowledged.

At-most-once delivery means messages can be lost but never duplicated. Kafka sends messages without retrying on failure, so a message might be delivered zero or one time.

❓ Predict Output

intermediate

Output of Kafka Producer with At-most-once Settings

Given the following Kafka producer configuration snippet, what is the expected delivery guarantee?

props.put("enable.idempotence", "false");
props.put("acks", "0");
props.put("retries", 0);

What is the expected behavior?

A Messages are retried until acknowledged; at-least-once delivery.

B Messages may be lost but will not be duplicated; at-most-once delivery.

C Messages are delivered exactly once with no duplicates.

D Messages are only sent after manual commit.

💡 Hint

Consider what disabling idempotence and setting acks to 0 means.

With acks=0, the producer does not wait for any acknowledgment, and with retries=0 and idempotence disabled, messages may be lost but will not be duplicated, matching at-most-once semantics.

❓ Predict Output

advanced

Kafka Consumer Offset Behavior with At-most-once Delivery

Consider this Kafka consumer code snippet:

consumer.subscribe(List.of("topic"));
while (true) {
  var records = consumer.poll(Duration.ofMillis(100));
  for (var record : records) {
    System.out.println(record.value());
  }
  consumer.commitSync();
}

If the commitSync() call is moved before processing the records, what delivery guarantee does this provide?

A Exactly-once delivery, because commitSync ensures atomicity.

B At-least-once delivery, because offsets are committed after processing.

C At-most-once delivery, because offsets are committed before processing.

D No delivery guarantee, because commitSync is not used.

💡 Hint

Think about what happens if the consumer crashes after committing but before processing.

Committing offsets before processing means if the consumer crashes after commit but before processing, messages are lost, so at-most-once delivery is achieved.

🔧 Debug

advanced

Identify the Error in At-most-once Kafka Producer Code

What error will this Kafka producer code cause?

Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");
props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("acks", "0");
props.put("enable.idempotence", "true");
props.put("retries", 0);
KafkaProducer<String, String> producer = new KafkaProducer<>(props);
producer.send(new ProducerRecord<>("topic", "key", "value"));
producer.close();

A IllegalArgumentException because idempotence requires retries > 0.

B No error; code runs with at-most-once delivery.

C TimeoutException because acks=0 disables idempotence.

D NullPointerException due to missing serializers.

💡 Hint

Check Kafka producer configuration rules for idempotence.

Enabling idempotence requires retries to be greater than zero. Setting retries to 0 with idempotence enabled causes an IllegalArgumentException.

🚀 Application

expert

Designing At-most-once Delivery with Kafka Consumer

You want to implement a Kafka consumer that guarantees at-most-once delivery. Which of the following code snippets correctly implements this behavior?

A

consumer.subscribe(List.of("topic"));
while (true) {
  var records = consumer.poll(Duration.ofMillis(100));
  consumer.commitSync();
  for (var record : records) {
    process(record.value());
  }
}

B

consumer.subscribe(List.of("topic"));
while (true) {
  var records = consumer.poll(Duration.ofMillis(100));
  for (var record : records) {
    process(record.value());
  }
  consumer.commitSync();
}

C

consumer.subscribe(List.of("topic"));
while (true) {
  var records = consumer.poll(Duration.ofMillis(100));
  for (var record : records) {
    process(record.value());
    consumer.commitSync();
  }
}

D

consumer.subscribe(List.of("topic"));
while (true) {
  var records = consumer.poll(Duration.ofMillis(100));
  for (var record : records) {
    process(record.value());
  }
  consumer.commitAsync();
}

💡 Hint

Remember that committing offsets before processing leads to at-most-once delivery.

Option A commits offsets before processing, so if the consumer crashes after commit but before processing, messages are lost, ensuring at-most-once delivery.