Confluent Confluent Certified Developer for Apache Kafka Certification Examination CCDAK Exam Dumps: Updated Questions & Answers (July 2025)

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 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.

Table→ Product, Customers

Stream→ Orders_Placed, Shipment_Of_Orders

Tablesrepresent slowly changing,reference data— e.g., customer profiles, product info.

Streamsrepresentreal-time event data— e.g., orders placed, shipments processed.

FromKafka Streams Documentation:

“Use KTable for reference datasets, and KStream for event-based processing such as orders or logs.”

If the consumer fails to send heartbeats in time (due to being slow under load), it is considereddead, causing a rebalance. Increasing session.timeout.ms gives the consumermore time to process messages and send heartbeats, preventing premature removal.

FromKafka Docs > Heartbeats and Failures:

“If the consumer does not send a heartbeat in session.timeout.ms, it is considered dead and the group coordinator will trigger a rebalance.”

Reducing max.poll.records mightslow consumption further. More consumers won’t help since each partition already has a dedicated consumer.

C is true: When a new broker is added,no partitions are assigned to itunless you create new topics orreassign existing onesusing kafka-reassign-partitions.sh.

D is true: Kafka brokers arehot-pluggable; no need to stop the cluster when scaling.

FromKafka Operations Guide:

“A newly added broker won’t be assigned partitions until reassignments or new topic creation.”

“Kafka allows dynamic scaling by adding brokers without downtime.”

A is false: Broker IDs must bemanually setunless using dynamic broker registration in KRaft mode.

B is false unless the cluster usesKRaft modeand the broker isspecifically assigneda controller role.

For real-time applications, thekey metric to monitor is consumer lag— the difference between thelatest offset on the brokerand thelast committed offset by the consumer.

FromKafka Monitoring Guide:

“Consumer lag is the most important metric for real-time applications. It tells you how far behind the consumer is from the latest data in Kafka.”

B relates to replication, not client responsiveness.

C tracks group membership stability, not data delay.

D tracks input throughput, not processing latency.

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.

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.

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.

The default maximum message size that a Kafka broker accepts is1MB (1,048,576 bytes), controlled by the config propertymessage.max.bytes.

FromKafka Broker Configuration Docs:

“The default maximum message size is 1MB. To accept larger messages, configure message.max.bytes and the producer’s max.request.size.”

Producers also have a matching limit via max.request.size, and consumers via fetch.message.max.bytes.