CCDAK Confluent Certified Developer for Apache Kafka Certification Examination Questions and Answers

When using Kafka Connect with sink connectors (like S3 Sink),each task is assigned one or more topic partitions. Thetotal number of partitions (6)isevenly distributedacross the available tasks (2). Thus, each task will handle3 partitions.

FromKafka Connect Documentation:

“Kafka Connect divides the topic partitions among available tasks. For example, a topic with six partitions and two tasks results in each task handling three partitions.”

If a key isnot specified, thedefault Kafka partitioner uses round-robinlogic to assign partitions. This leads toeven distributionof messages across all partitions.

FromKafka Producer Design:

“If the key is null, the producer will assign the partition in a round-robin fashion to achieve load balancing.”

There isno error, and partition 0 isnot alwayschosen in this case.

The onCompletion() method of Kafka’sCallback interfaceis executedonce the broker acknowledgesthe message. This includes success or failure, and it isinvoked asynchronouslyby the producer.

FromKafka Java Client API Documentation:

“The onCompletion method will be called when the record sent to the server has been acknowledged, or when an error occurs.”

This ensures thatthe record was sent and acknowledged, not just added to a batch or local buffer.

BothLeaderNotAvailableExceptionandNotEnoughReplicasExceptionare subclasses of RetriableException, which representstransient issuesthat may succeed upon retry.

FromApache Kafka Java Client Documentation:

“RetriableException indicates that the request can be retried. This includes network errors and certain broker-side failures like leader not available or not enough replicas.”

RecordTooLargeException and AuthorizationException arenon-retriablebecause they represent client misconfigurations or access issues.

Increasing partitions increasesparallelism, but also means:

Consumers in a group may have to handlemore partitions, especially if the number of consumers is lower than the number of partitions.

This can result inincreased lag, especially under high load.

FromKafka Topic Management Docs:

“Increasing the number of partitions increases consumer work, and if consumers can’t keep up, lag can accumulate.”

A is false:existing data is not redistributed.

B is false:records with the same key always map to the same partitionbased on hash.

D is not directly impacted by the partition count.

The ConsumerRebalanceListener lets youhandle partition assignments and revocationsduring rebalances. This is critical for managingoffsets,stateful processing, orexternal transactions.

FromKafka Consumer Rebalance Docs:

“Implementing ConsumerRebalanceListener allows your application to take action before and after partitions are reassigned.”

A is true: It lets your app react when partitionsassigned to the consumer change.

B, C, and D are unrelated to consumer rebalancing directly.

Using assign() givesmanual controlover partition assignment. In this mode:

B is true: The applicationchooses partitionsdirectly without involving the group coordinator.

C is true: Since no group coordination occurs,no rebalancinghappens if a consumer dies.

FromKafka Consumer API Docs:

“assign() manually assigns a list of partitions to this consumer. No coordination takes place and no rebalancing is triggered.”

A is false: subscribe() and assign() aremutually exclusive.

D is incorrect: Partitions don't need to be equal across topics.

To send failed records to adead letter queue (DLQ), you must configure:

errors.tolerance=all: Tells the connector tonot failon errors but handle them (e.g., send to DLQ).

errors.deadletterqueue.topic.name=DLQ-Topic: Specifies the DLQ topic.

errors.deadletterqueue.context.headers.enable=true: Includes error context in message headers.

FromKafka Connect Error Handling Docs:

“Kafka Connect supports directing problematic records to a separate topic (DLQ) using errors.* configs. Headers can include failure metadata.”

Options D, E, F are related tologging, not DLQ behavior.

Each of these settings plays a key role inKafka Connect offset management:

offset.flush.interval.ms=60000 → Offset commits happen every 60 seconds.

offset.flush.timeout.ms=500 → The flush operation times out if it takes more than 500 ms.

offset.storage.topic=connect-offsets → This is the internal topic for storing source offsets.

offset.storage.replication.factor=-1 → This uses thebroker's default replication factor(commonly set via default.replication.factor).

FromKafka Connect Docs:

“If offset.storage.replication.factor=-1, the value will be determined by the broker's default replication factor.”

Low I/O thread activity with blocked throughput often indicates thatproducer callbacks are consuming too much time, causing the sender thread to block while waiting for onCompletion() to finish.

FromKafka Producer Performance Guide:

“Expensive logic in callbacks (e.g., I/O or complex computation) can block the sender thread, reducing throughput.”

Compression (A) may slightly impact CPU but not I/O thread usage.

Large batches (B) improve throughput if managed correctly.

A Layer 2 network issue (C) would lead to packet loss, not specifically low callback metrics.

ForSASL/PLAIN authentication over SSL, the correct combination is:

security.protocol=SASL_SSL

sasl.jaas.config=...PlainLoginModule required username=... password=...

FromKafka Security Documentation:

“For SASL/PLAIN over SSL, configure security.protocol=SASL_SSL and provide login module configuration using sasl.jaas.config.”

Options B and D are incorrect because they do not pair the correct protocol with the authentication method.

Unit Testing→ MockProducer

Integration Testing→ Testcontainers

Performance Testing→ Trogdor

Mock Data Generation→ Connect Datagen

MockProducer: Simulates a Kafka producer in unit tests (no real broker interaction).

Testcontainers: Spawns Kafka in Docker forreal environment testing.

Trogdor: Kafka’s built-inperformance load testingframework.

Connect Datagen: Createssample source recordsfor test and demo purposes.

FromKafka Developer Tools Guide:

“Kafka developers commonly use MockProducer for unit tests, Testcontainers for integration, and Trogdor for performance tests.”

Log compactionensures that Kafka retains at least thelatest value per keyin a topic. Compaction happensin the backgroundand removes older records with the same keyin inactive log segments, not immediately.

From theKafka Documentation > Log Compaction:

“Kafka guarantees that thelast message for each keywill be retained in the log after compaction, even if earlier messages with the same key are deleted.”

So, D is correct. A is incorrect because compaction does not overwrite; it's a background process. B is incorrect—deletion is not immediate. C incorrectly suggests client-side hashmap behavior.

For Kafka Streams to performjoins, topics must beco-partitioned, meaning:

They have thesame number of partitions(A), and

They use thesame partitioning strategy(typically by key) (B)

FromKafka Streams Documentation > Joins:

“Co-partitioning is required for Kafka Streams joins. Topics must have the same number of partitions and use the same key-based partitioner.”

Value schema (C) and retention time (D) have no bearing on join compatibility.

Thebatch.sizeconfig sets themaximum number of bytes to batch per partitionbefore sending. This allows Kafka producers toamortize I/Oand improve throughput.

FromKafka Producer Configuration Docs:

“batch.size is the maximum amount of data per partition the producer will batch before sending.”

buffer.memory sets total memory for the producer, not per-batch.

send.buffer.bytes is aTCP socket buffer, not a Kafka config.

max.block.ms controls blocking time, not size.