Confluent CCDAK Confluent Certified Developer for Apache Kafka Certification Examination Exam Practice Test

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.

Kafka clients useSLF4Jas a logging facade. To redirect Kafka logs tolog4j2, you must include theSLF4J binding for log4j2in your classpath:

“org.apache.logging.log4j:log4j-slf4j-impl bridges SLF4J to Log4j2 so that Kafka's logs integrate into your application's Log4j2 configuration.”

Option A is forLog4j 1.x, which is outdated.

Option C is incorrect; Kafka clients don't include logging bindings.

Option D is insufficient without the SLF4J bridge.

A:Kafka batches storecompression metadata in their headers, indicating how the batch was compressed.

B:Compression is controlled via theproducer config compression.type, which defaults to none. Producers explicitly set Gzip or other formats.

FromKafka Producer Docs:

“Compression is done by the producer, and the type is stored in the message batch metadata. The broker does not recompress.”

C is false: messages are serializedbeforecompression.

D is false: messages without keys are distributed acrossmultiple 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.

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

fetch-rate: Measures how frequently consumers fetch data — critical for monitoring throughput.

incoming-byte-rate: Shows how much data is being written to the broker per second — a keyproducer-side metric.

FromKafka JMX Metrics Guide:

“fetch-rate, incoming-byte-rate, request-latency are key performance metrics for producers and consumers.”

B, C, E, and F areapplication-layer business metrics, not Kafka performance 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.

AGlobalKTableis a replicated, read-only table available in full on all instances. It's best forreference or lookup datasetssuch as:

Product catalog

Customer profiles

Warehouse inventory

FromKafka Streams Developer Guide:

“Use GlobalKTable when you need to perform joins using non-partition-aligned reference data that's small enough to replicate.”

Purchases and transactions are high-throughput, time-sensitive streams, not static reference data.

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.

Comprehensive and Detailed Explanation From Exact Extract:

✅C. Consumers can consume both committed and uncommitted transactions.By default,Kafka consumers only read committed messagesif they are configured with isolation.level=read_committed. However, if configured as read_uncommitted, theycan also consume uncommitted (potentially aborted) transactional messages.

From Kafka Documentation:

"The isolation.level setting controls whether the consumer will read only committed messages or all messages, including uncommitted messages from ongoing or aborted transactions."

✅D. Information about producers and their transactions is stored in the _transaction_state topic.Kafka uses an internal topic named__transaction_stateto maintain metadata about producer transactions. This topic is essential for tracking thetransaction lifecycle, fencing, and recovery.

From Kafka Internals:

“Kafka stores the state of active and completed transactions in an internal topic called __transaction_state.”

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.

This syntax is a clear match toProtocol Buffers (Protobuf). It defines a schema with fields, types, and tags, which is a format supported by Kafka when usingProtobuf-based schema registry serialization.

FromConfluent Schema Registry Docs:

“Kafka supports Protobuf serialization, where schemas are written in .proto files and include fields with tags.”

int32, double, and string are standard Protobuf types.

Avro uses JSON-style schema.

JSON Schema uses JSON object structure, not .proto.

YAML is unrelated.

Kafka Connectsource connectorsuse theoffset.storage.topicconfiguration parameter to define where to storeoffsets that track the connector's positionin the source system (e.g., database, file, etc.).

FromKafka Connect Worker Configuration:

“offset.storage.topic specifies the topic in Kafka where the connector stores offsets for each source partition.”

This allows Kafka Connect toresumefrom the correct position on restart.

The other options (B–D) are not valid Kafka configs.

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.

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.

A409 Conflictresponse 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 toa rebalance in progress.

From theConfluent Developer documentationand 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 return400 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.

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.

max.poll.interval.ms defines themaximum 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.

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