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

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.

Kafka Connect can run instandalone modeordistributed mode. For simple tasks likereading logs from a file on a single host,standalone modeis recommended.

FromKafka Connect User Guide:

“Standalone mode is useful when running connectors on a single machine (e.g., for development or simple deployments like log collection from a local file).”

Distributed mode is preferred for scalability and fault tolerance but overkill for this use case.

If the application isCPU-boundandlagging, addingmore consumersto the group will allow betterparallel processing, especially since the topic has4 partitions, allowing up to 4 active consumers.

FromKafka Consumer Group Docs:

“Kafka achieves parallelism by distributing partitions across consumers in a group. Adding consumers helps reduce lag if partitions are underutilized.”

B may help but requires repartitioning and coordination.

C or D affects how much data is polled, not how fast it’s processed.

To skip a corrupted record and avoid failing the application, you mustseek past the failed offsetmanually using consumer.seek(). This allows the application to resume consumption from the next offset.

FromKafka Consumer Error Handling Docs:

“On deserialization failure, you can catch RecordDeserializationException, log the error, and call seek() to the next offset to skip the bad record.”

A does not prevent re-processing the bad record.

C is invalid; there'sno skip() methodin the Kafka consumer API.

D results in service interruption — not ideal for resiliency.

The official CLI utility for consuming messages from Kafka topics is kafka-console-consumer.sh. It connects to the broker, consumes messages, and prints them to standard output.

FromKafka CLI Tools Documentation:

"kafka-console-consumer.sh is used to read data from a Kafka topic and write it to standard output."

The other options are not valid Kafka CLI tools.

In Kafka Streams,the number of stream tasks = number of input partitions × num.stream.threads × number of instances,but only as many as the number of partitions can actively consume at once.

However, in this case,Kafka Streams assigns one task per partition, and because there are 5 partitions and 15 threads (3 instances × 5 threads),15 tasks are created, andall 15 can be activedepending on processing topology.

FromKafka Streams Developer Guide:

"Kafka Streams creates one task per input partition. If you increase the number of stream threads, it runs multiple tasks in parallel within a single instance."

So,15 stream tasks will be created and 15 will be actively consuming.

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.

Frequentrebalancesin a consumer group occur when:

Consumers are too slowand miss heartbeats (A), or

Instances crash or restart, triggering group membership changes (D)

FromKafka Consumer Group Coordination Docs:

“If a consumer fails to send a heartbeat in time (due to slowness or crash), it is removed from the group, causing a rebalance.”

Option B (partition mismatch) affectsload balancing, not rebalance frequency.

Option C (broker storage) doesn't trigger consumer rebalances.

If amessage key is not provided, Kafka’s default partitioner usesround-robin distributionacross available partitions.

FromKafka Producer Design:

“If no key is provided, the default partitioner distributes messages round-robin to available partitions.”

A is incorrect — not all go to partition 0.

C is invalid — Kafka doesn’t group messages into one segment without a key.

D is false — ordering isnot preservedacross partitions without a key.

Session windowsare ideal for trackingperiods of activity separated by inactivity, such as user sessions.

FromKafka Streams Documentation > Windowing:

“A session window captures streams of events that areintermittentand separated by agap of inactivity.”

Tumbling/Hopping/Sliding windows are fixed in size

Session windows are dynamic and close after inactivity timeout

This makes them perfect for identifyinggaps in user interaction.

The bootstrap.servers setting is used by clients (producers and consumers) toinitially connectto the Kafka cluster. It does not need to list all brokers—just a few that are up and reachable. The client will then use the cluster metadata to discover the full broker list.

FromKafka Java Client Configuration Docs:

“This is a list of host/port pairs to use for establishing the initial connection to the Kafka cluster. The client will make use of all servers irrespective of which servers are specified here for bootstrapping.”

Hence,listing multiple brokers provides redundancyand fault tolerance in the event one is down during client startup.

With acks=all, the leader waits formin.insync.replicasto acknowledge the message. Since min.insync.replicas=3, Kafka will only commit the messageonce 3 brokers (leader + 2 followers)confirm they have the message.

FromKafka Documentation > Acks and Durability:

“If acks=all is specified, the producer will wait until the full set of in-sync replicas has acknowledged the record. The minimum number of in-sync replicas is controlled by min.insync.replicas.”

Even though the replication factor is 4, only3 acknowledgments are needed, as defined by min.insync.replicas.

unclean.leader.election.enable=false→ Prevents data loss by only considering in-sync replicas when rebalancing.

replication.factor→ Specifies how many redundant copies of partitions are distributed across brokers.

min.insync.replicas=2→ Sets the standard for the number of partition instances that must keep up with the latest committed message.

unclean.leader.election.enable=false ensures that onlyin-sync replicascan be elected as leaders. If disabled, an out-of-sync replica may become leader, potentially leading to data loss.

replication.factor defineshow many brokerswill maintain copies of each partition, directly impacting durability and availability.

min.insync.replicas determineshow many replicas must acknowledgea write when acks=all is used, enforcing write durability.

To maintainmessage ordering per bank account, themessage key must be the account number. Kafka guaranteesordering per partition, and the partition is selected based on thehash of the key.

FromKafka Producer Docs:

“All records with the same key will be sent to the same partition, and Kafka preserves the order of records in a partition.”

Using account number ensures:

All messages for the same account go to the same partition

Order is maintained

Workload is evenly distributed if account keys are varied

Other options break ordering or introduce unnecessary randomness.

1st:Place the connector's JAR file in the directory specified by plugin.path

2nd:Restart the Kafka Connect cluster

3rd:Verify using REST API (/connector-plugins)

4th:Configure the connector

5th:(Repeat of 4th, duplicate step)

1st → Place the connector’s JAR file in the directory specified by the plugin.path configuration.

2nd → Restart the Kafka Connect cluster.

3rd → Verify that the connector is installed by listing all available connectors using the Kafka Connect REST API (/connector-plugins).

4th → Configure the connector using a JSON or properties file with the necessary settings.

5th → Configure the connector using a JSON or properties file with the necessary settings.

Kafka Connect requires that custom connectors be placed in the directory defined by plugin.path. After restarting the cluster, you can use the REST API to confirm availability and then deploy the connector configuration.

FromKafka Connect Documentation:

“After placing the JAR in the plugin.path, you must restart the Connect cluster to pick it up. Use the /connector-plugins REST endpoint to verify.”

The duplication of configuration is an error in the question options and should occur only once.