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

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

From Kafka 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 might slow consumption further. More consumers won’t help since each partition already has a dedicated consumer.

A 409 Conflict response in Kafka Connect REST API usually means:

The connector name provided already exists (i.e., a connector with that name is already deployed).

The Kafka Connect cluster is temporarily unavailable to accept new tasks due to a rebalance in progress.

From the Confluent Developer documentation and Kafka Connect REST API spec:

“409 – Conflict. The connector name is already in use or the worker group is in the process of rebalancing and cannot complete the request at this time.”

Option A is incorrect because invalid configurations return 400 Bad Request, not 409.

Option B is invalid because Kafka Connect does not have a strict concept of "capacity" that prevents connector creation with a 409.

According to the official Apache Kafka documentation, log compaction is the mechanism used to retain only the latest record for each key in a topic. By setting cleanup.policy=compact, Kafka ensures that older records with the same key are eventually removed, leaving only the most recent value for each key.

This behavior is exactly suited for use cases such as tracking the current state of an entity, including GPS tracker locations, user profiles, or configuration data. In this scenario, the key (trackerId) uniquely identifies a tracker, and the value represents its most recent latitude and longitude.

Option B (retention.ms=infinite) retains all historical data, which contradicts the requirement. Option C (min.cleanable.dirty.ratio) controls when compaction runs, not what data is retained. Option D (retention.ms=0) would immediately delete all data and is unsafe.

Therefore, setting cleanup.policy=compact is the correct and officially documented solution to always retain the latest location per tracker.

=========================

According to the official Apache Kafka Connect REST API documentation, restarting a connector can be done at different granularities: connector-level, task-level, or both. By default, calling POST /connectors/{name}/restart only restarts the connector instance, not its tasks.

To restart the connector and all of its tasks, the request must explicitly include the query parameter includeTasks=true. This instructs Kafka Connect to restart the connector and all associated tasks, regardless of whether they are currently running or failed.

Option B (onlyFailed=true) limits the restart to only failed tasks, which does not meet the requirement to restart all tasks. Option C restarts only the connector instance, leaving tasks untouched. Option D restarts a single specific task and does not restart the connector itself.

Therefore, the correct and officially documented REST request to restart the connector instance and all tasks is:

POST /connectors/s3-connector/restart?includeTasks=true

This ensures a full restart of the connector and its execution context across the Kafka Connect cluster.

C is true: When a new broker is added, no partitions are assigned to it unless you create new topics or reassign existing ones using kafka-reassign-partitions.sh.

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

From Kafka 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 be manually set unless using dynamic broker registration in KRaft mode.

B is false unless the cluster uses KRaft mode and the broker is specifically assigned a controller role.

For SASL/PLAIN authentication over SSL, the correct combination is:

security.protocol=SASL_SSL

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

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

To isolate logs for a specific connector, you can configure a separate logger and appender in the Connect worker’s log4j.properties file, using the connector’s name as the logging context.

From Kafka Connect Logging Docs:

“Kafka Connect loggers use hierarchical logger names. You can configure per-connector log levels and output files by extending log4j.properties.”

A and C change verbosity but don’t separate logs.

D is false; targeted logging is possible.

The official Apache Kafka Connect documentation explains that connectors run within the same worker JVM, and all logs are written through the worker’s logging framework (Log4j or Log4j2). To isolate logs for a specific connector, Kafka Connect supports connector-specific logging contexts, which can be routed to separate log files using logging configuration.

By modifying the log4j.properties (or log4j2.xml) file to define a dedicated logger and appender for the connector’s package or class name, you can direct logs from that connector to a separate file. This is the recommended and documented approach for debugging individual connectors in a shared Connect cluster.

Option A is incorrect because there is no generic “enable connector context” switch. Option B may increase verbosity but does not isolate logs per connector. Option D is false; Kafka Connect explicitly supports connector-level log separation through logging configuration.

Therefore, the correct approach is to configure a dedicated log appender for the specific connector.

max.poll.interval.ms defines the maximum delay between invocations of poll() before the consumer is considered failed. It essentially gives consumers more time to process records before needing to poll again.

From Kafka Consumer Configuration Reference:

“max.poll.interval.ms: The maximum delay between invocations of poll() when using consumer group management. If poll() is not called before expiration, the consumer is considered failed.”

session.timeout.ms and heartbeat.interval.ms relate to group coordination and heartbeats.

fetch.max.wait.ms affects how long the broker waits to accumulate data before sending a fetch response.

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.

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