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

SMTs (Single Message Transforms) arelightweight transformationsapplied to individual messages as they pass through Kafka Connect.

Chaining SMTs: You can applymultiple SMTsin sequence by defining them in order in the connector config.

Masking or modifying fieldsis acommon use case(e.g., redacting sensitive data).

FromKafka Connect Documentation:

“Single Message Transforms (SMTs) are applied to individual messages. You can chain multiple SMTs together.”

SMTsdo not perform joins(B is incorrect).

Converters and SMTs areseparate concerns(D is incorrect).

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

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.

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.

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.

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

When amessage keyis specified in Kafka, the producer uses apartitioner(typically the default hash-based partitioner) todeterministically map all records with the same key to the same partition. Kafka guaranteesorder within a partition, so this enables per-key ordering.

FromKafka Producer Concepts:

“If a key is present, the producer will always route records with the same key to the same partition. Kafka preserves the order of records within a partition.”

This is essential for ordered processing and join semantics.

TheStickyAssignortries to minimize partition movement bypreserving existing assignmentsas much as possible while still achieving a balanced assignment. This improvesconsumer stabilityand reduces rebalances.

From theKafka Consumer Assignor Documentation:

“The StickyAssignor attempts topreserve as many existing assignments as possible, which helps minimize partition movement between rebalances.”

RoundRobinAssignor focuses on even distribution, not stability.

RangeAssignor groups partitions by topic and assigns them consecutively, but can lead to imbalances.

PartitionAssignor is an abstract base class, not an assignor used directly.

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.

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

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.

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.

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

Kafka Connectsink connectorsuse thestandard Kafka consumer mechanismto track offsets, which means offsets are stored in the__consumer_offsets internal topic.

FromKafka Connect Documentation:

“Sink connectors are regular Kafka consumers and store their offsets in the __consumer_offsets topic like any other consumer.”

The other options refer tosource connectorsor worker configuration.

offsets.storage.topic is relevant forsource connectors.

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.

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.

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.

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.