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

Log compaction ensures that Kafka retains at least the latest value per key in a topic. Compaction happens in the background and removes older records with the same key in inactive log segments, not immediately.

From the Kafka Documentation > Log Compaction:

“Kafka guarantees that the last message for each key will 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.

The Apache Kafka consumer configuration max.poll.records explicitly controls the maximum number of records returned in a single call to Consumer.poll(). This is clearly documented in the official Kafka consumer configuration reference. It allows developers to limit the size of the batch returned to the application, helping to control processing latency, memory usage, and CPU load.

This setting does not affect how much data the broker sends to the consumer; instead, it limits how many records the consumer returns to the application layer from the fetched data. This makes it especially useful for applications where processing each record is expensive and needs predictable batch sizes.

Option B (max.records.consumer) does not exist in Kafka. Option C (fetch.max.records) is also invalid; Kafka uses fetch.max.bytes and related byte-based configurations, not record-count limits, at the fetch level. Option D (max.poll.records.interval) is not a valid Kafka configuration; the correct related setting is max.poll.interval.ms, which controls liveness, not batch size.

Thus, max.poll.records is the correct and officially documented configuration.

Kafka Connect sink connectors use the standard Kafka consumer mechanism to track offsets, which means offsets are stored in the __consumer_offsets internal topic.

From Kafka 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 to source connectors or worker configuration.

offsets.storage.topic is relevant for source connectors.

The Apache Kafka producer API is asynchronous by default, and proper error handling requires explicit mechanisms. The official documentation recommends using a callback function with producer.send() to determine whether a record was successfully acknowledged or failed due to an exception. The callback provides access to both RecordMetadata and any exception encountered during sending.

Additionally, certain errors—such as serialization errors or configuration issues—are thrown synchronously when calling producer.send(). These must be handled using a try/catch block that catches KafkaException or its subclasses.

Option A is invalid because ProducerRecord has no status() method. Option C is incorrect because producer.send() returns a Future < RecordMetadata > , not a RecordMetadata object directly.

Thus, combining a callback for asynchronous errors and a try/catch block for synchronous errors is the correct and officially documented approach to ensure reliable producer error handling when using acks=all.

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

To maintain message ordering per bank account, the message key must be the account number. Kafka guarantees ordering per partition, and the partition is selected based on the hash of the key.

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

Kafka producers can group messages destined for different partitions into separate batches, and send multiple batches in one request to optimize network usage.

From Kafka Producer Internals:

“The producer maintains buffers (batches) for each partition and can send multiple of these batches together in a single request to the broker.”

Message size is not a constraint for batching (A is false).

Broker failures don’t disable batching (B is false).

There is no separate thread per batch (C is false).

The Apache Kafka consumer documentation explains that when a RecordDeserializationException occurs, the consumer cannot continue polling until the problematic offset is skipped. Simply logging the error is insufficient, because the consumer will repeatedly fail on the same record.

The recommended pattern is to log the malformed record, extract its topic, partition, and offset from the exception, and then call consumer.seek() to move the consumer position to the next offset (offset + 1). This allows the application to skip the poison pill and resume processing subsequent records.

Option B is invalid because Kafka does not provide a consumer.skip() API. Option C is unnecessary if the application is designed to tolerate malformed records. Option D results in an infinite failure loop.

Therefore, seeking past the bad record after logging it is the correct and officially documented way to handle poison pill records while maintaining consumer liveness and resilience.

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.

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.

This scenario describes vertical scaling, as defined in the Apache Kafka Streams documentation and general distributed systems terminology. Vertical scaling refers to adding more resources (CPU, memory, or disk) to a single machine to increase processing capacity.

In this example, the Kafka Streams application is moved from a server with four CPU threads to one with ten CPU threads, increasing the available compute resources without increasing the number of application instances. Kafka Streams can take advantage of additional CPU threads through its num.stream.threads configuration, allowing more partitions to be processed in parallel within the same application instance.

Horizontal scaling (also known as scaling out) would involve adding more application instances across multiple servers, not upgrading a single server. Option D is therefore incorrect, and Option C is not a recognized scaling term.

Thus, this example clearly illustrates vertical scaling, where performance is improved by increasing the capacity of a single node.

For Kafka Streams to perform joins, topics must be co-partitioned, meaning:

They have the same number of partitions (A), and

They use the same partitioning strategy (typically by key) (B)

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

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

From Kafka 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, only 3 acknowledgments are needed, as defined by min.insync.replicas.

Session windows are ideal for tracking periods of activity separated by inactivity, such as user sessions.

From Kafka Streams Documentation > Windowing:

“A session window captures streams of events that are intermittent and separated by a gap of inactivity.”

Tumbling/Hopping/Sliding windows are fixed in size

Session windows are dynamic and close after inactivity timeout

This makes them perfect for identifying gaps in user interaction.

The onCompletion() method of Kafka’s Callback interface is executed once the broker acknowledges the message. This includes success or failure, and it is invoked asynchronously by the producer.

From Kafka Java Client API Documentation:

“The onCompletion method will be called when the record sent to the server has been acknowledged, or when an error occurs.”

This ensures that the record was sent and acknowledged, not just added to a batch or local buffer.

Kafka Connect source connectors use the offset.storage.topic configuration parameter to define where to store offsets that track the connector's position in the source system (e.g., database, file, etc.).

From Kafka Connect Worker Configuration:

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

This allows Kafka Connect to resume from the correct position on restart.

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

To increase consumer throughput, one effective strategy is to increase the amount of data fetched in each poll by raising fetch.max.bytes or max.partition.fetch.bytes. This allows each poll to retrieve more records per request, improving processing efficiency.

From Kafka Consumer Config Docs:

“Increasing fetch size allows consumers to retrieve larger batches of messages, improving throughput and reducing request overhead.”

Removing consumers (A) may reduce parallelism.

Manual commit (C) adds complexity, not throughput.

Decreasing session timeout (D) risks unnecessary rebalances.

Increasing partitions increases parallelism, but also means:

Consumers in a group may have to handle more partitions, especially if the number of consumers is lower than the number of partitions.

This can result in increased lag, especially under high load.

From Kafka Topic Management Docs:

“Increasing the number of partitions increases consumer work, and if consumers can’t keep up, lag can accumulate.”

A is false: existing data is not redistributed.

B is false: records with the same key always map to the same partition based on hash.

D is not directly impacted by the partition count.

If a key is not specified, the default Kafka partitioner uses round-robin logic to assign partitions. This leads to even distribution of messages across all partitions.

From Kafka Producer Design:

“If the key is null, the producer will assign the partition in a round-robin fashion to achieve load balancing.”

There is no error, and partition 0 is not always chosen in this case.

If a message key is not provided, Kafka’s default partitioner uses round-robin distribution across available partitions.

From Kafka 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 is not preserved across partitions without a key.

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

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

From Kafka 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 serialized before compression.

D is false: messages without keys are distributed across multiple partitions.

Apache Kafka Connect stores source connector offsets in a Kafka topic defined by the offset.storage.topic configuration. Since this property is explicitly set to connect-offsets, Kafka Connect will commit offsets to that topic, making Option C correct.

The offset.storage.replication.factor controls how many replicas the offsets topic will have. When this value is set to -1, Kafka Connect uses the broker’s default replication factor, as documented in the Kafka Connect worker configuration reference. Therefore, Option A is also correct.

Option B is incorrect because Kafka Connect does not use Kafka’s internal consumer offsets topic (__consumer_offsets). It always uses the configured offsets topic. Option D is incorrect because offset.flush.timeout.ms defines how long Connect will wait for offset commits to complete, not how long it waits before attempting a commit. The commit interval itself is controlled by offset.flush.interval.ms (60 seconds in this case).

Thus, the correct statements that match the expected behavior are A and C.

To reset offsets for an existing consumer group, you must use the kafka-consumer-groups.sh tool with the --reset-offsets and --to-earliest flags.

From Kafka Consumer Group Tool Documentation:

“You can use the kafka-consumer-groups tool to reset offsets for a consumer group. This is required if the consumer has already committed offsets.”

Setting auto.offset.reset=earliest only works if no committed offset exists.

Starting a new consumer with the same group won’t reset offsets.

Retention settings don’t affect committed offsets.

Table → Product, Customers

Stream → Orders_Placed, Shipment_Of_Orders

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

Streams represent real-time event data — e.g., orders placed, shipments processed.

From Kafka Streams Documentation:

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

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.