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

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.

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.

According to the official Apache Kafka Streams documentation, session windows are specifically designed to model periods of activity separated by gaps of inactivity. A session window groups events that occur close together in time and closes when no new events arrive within a defined inactivity gap.

In this use case, tracking user shopping cart behavior requires detecting when a user becomes inactive (for example, stops adding or removing items). Session windows naturally represent this pattern by creating a new window when activity resumes after a period of silence. This makes them ideal for modeling user sessions, cart abandonment detection, and inactivity analysis.

Hopping and tumbling windows (Options B and C) are fixed-time windows and are not well-suited for detecting inactivity, as they segment data based on clock time rather than behavior. Sliding windows are primarily used for continuous joins and do not explicitly model inactivity gaps.

Therefore, session windows are the correct and officially recommended choice for identifying periods of user inactivity in Kafka Streams applications.

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

To change the replication factor of an existing topic, you must perform a partition reassignment, because the replication factor is not directly modifiable via kafka-topics.sh. The kafka-reassign-partitions.sh tool is the official command-line utility to handle partition reassignments, including changing the replication factor.

This tool allows you to generate a reassignment JSON specifying new replica assignments per partition and then apply it.

From official documentation:

“To change the replication factor, use the kafka-reassign-partitions tool to assign the partitions to more or fewer brokers.”

Neither kafka-topics.sh nor kafka-reassign-topics.sh exists for this purpose, and kafka-recreate-topic.sh is not an official Kafka tool.

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.

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

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

To skip a corrupted record and avoid failing the application, you must seek past the failed offset manually using consumer.seek(). This allows the application to resume consumption from the next offset.

From Kafka 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's no skip() method in the Kafka consumer API.

D results in service interruption — not ideal for resiliency.

According to the official Apache Kafka documentation for Kafka Streams, exactly-once semantics (EOS) are controlled using the processing.guarantee configuration. To ensure that each input record is processed once and only once, and that the results are written atomically to the output topic, Kafka Streams provides built-in EOS support.

The correct and recommended configuration is processing.guarantee=exactly_once_v2, which is the default EOS implementation starting from Kafka 3.0. This mode uses Kafka’s transactional APIs to atomically commit consumer offsets and produce output records within a single transaction. As documented, this prevents duplicates even in the presence of failures, retries, or application restarts.

Option A is incorrect because log compaction does not guarantee exactly-once processing; it only retains the latest record per key. Option B is insufficient because enable.idempotence alone does not handle consumer offset commits or state store consistency in Kafka Streams. Option C is invalid because no such configuration exists in Kafka Streams.

Therefore, setting processing.guarantee=exactly_once_v2 is the only fully correct and officially supported solution for achieving EOS in Kafka Streams applications.

In Kafka Streams, the number of stream tasks = number of input partitions × num.stream.threads × number of instances, but only as many as the number of partitions can actively consume at once.

However, in this case, Kafka Streams assigns one task per partition, and because there are 5 partitions and 15 threads (3 instances × 5 threads), 15 tasks are created, and all 15 can be active depending on processing topology.

From Kafka Streams Developer Guide:

"Kafka Streams creates one task per input partition. If you increase the number of stream threads, it runs multiple tasks in parallel within a single instance."

So, 15 stream tasks will be created and 15 will be actively consuming.

According to the official Apache Kafka producer metrics documentation, the I/O thread ratio and I/O thread wait ratio indicate how busy the producer’s network I/O thread is and how much time it spends waiting. When both metrics are low, it means the I/O thread is underutilized and not blocked on network operations.

This strongly suggests that the bottleneck is not network-related. If there were network latency or a bad data link (Option B), the I/O thread wait ratio would be high. Similarly, large batches (Option A) or compression (Option D) generally increase throughput and would result in higher I/O utilization.

An expensive or blocking callback function (for example, heavy logic in onCompletion()) executes in the producer’s sender thread context. Kafka documentation explicitly warns that slow callbacks can throttle producer throughput because they delay the processing of acknowledgements and subsequent sends.

Therefore, the most likely and documented cause of low producer throughput with low I/O utilization is expensive callback logic in the producer code.

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

Using assign() gives manual control over partition assignment. In this mode:

B is true: The application chooses partitions directly without involving the group coordinator.

C is true: Since no group coordination occurs, no rebalancing happens if a consumer dies.

From Kafka Consumer API Docs:

“assign() manually assigns a list of partitions to this consumer. No coordination takes place and no rebalancing is triggered.”

A is false: subscribe() and assign() are mutually exclusive.

D is incorrect: Partitions don't need to be equal across topics.

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.

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.

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.

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.

The StickyAssignor tries to minimize partition movement by preserving existing assignments as much as possible while still achieving a balanced assignment. This improves consumer stability and reduces rebalances.

From the Kafka Consumer Assignor Documentation:

“The StickyAssignor attempts to preserve 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.

In the Kafka Streams API, operations are classified as stateless or stateful based on whether they require maintaining local state stores. According to the official Kafka Streams documentation, stateless operations process each record independently, without storing or accessing prior records.

Filter is a stateless operation because it evaluates each record individually and decides whether to pass it downstream. It does not require any state or historical context.

GroupBy is also considered stateless because it merely repartitions the stream by assigning a new key and forwarding records to downstream processors. While it triggers the creation of an internal repartition topic, the GroupBy operation itself does not maintain a state store.

In contrast, Reduce is a stateful operation because it aggregates records over time and requires maintaining intermediate results in a state store. Similarly, Join operations are stateful because Kafka Streams must buffer and store records from one or both input streams or tables to perform the join within a defined time window.

Thus, the correct stateless operations are Filter and GroupBy, as documented in the Kafka Streams developer guide.

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.

To send failed records to a dead letter queue (DLQ), you must configure:

errors.tolerance=all: Tells the connector to not fail on 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.

From Kafka 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 to logging, not DLQ behavior.

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.

The Apache Kafka Streams documentation clearly distinguishes between the Kafka Streams DSL and the Processor API. While the DSL is designed for common stream processing operations such as filtering, mapping, joining, and aggregations, it does not support fully custom processing logic.

For use cases that require custom transformations, fine-grained control over record processing, access to headers, timestamps, state stores, and punctuation, Kafka Streams provides the Processor API. This API allows developers to implement custom Processor, Transformer, or ValueTransformer classes and explicitly define the processing topology.

Option A (TopologyTestDriver) is a testing utility, not a development API. Option C (DSL) is higher-level and not suitable for advanced custom logic. Option D does not exist in Kafka.

Therefore, the correct and officially supported approach for defining custom processors in Kafka Streams is to use the Processor API.

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

If the application is CPU-bound and lagging, adding more consumers to the group will allow better parallel processing, especially since the topic has 4 partitions, allowing up to 4 active consumers.

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

To ensure exactly-once delivery and avoid duplicates even during retries:

enable.idempotence=true ensures deduplication on the broker

retries=2147483647 allows unlimited retries on retriable errors

max.in.flight.requests.per.connection=5 is the maximum value that preserves message order with idempotence

From Kafka Producer Config Docs:

“To achieve exactly-once semantics, set enable.idempotence=true, and max.in.flight.requests.per.connection ≤ 5.”

A is unrelated (consumer-side)

C disables retries

D disables idempotence, leading to duplicates

According to the official Apache Kafka consumer semantics documentation, at-most-once delivery means that records may be lost but must never be processed more than once. To achieve this guarantee, a consumer must commit offsets before processing records. If the application crashes after committing but before processing, messages are skipped rather than reprocessed, which satisfies at-most-once semantics.

Option B correctly implements this pattern. It disables automatic offset commits (enable.auto.commit=false) and explicitly calls commitAsync() immediately after polling and before processing records. This ensures that offsets are advanced regardless of whether processing succeeds, eliminating the possibility of duplicate processing.

Option C represents at-least-once semantics, because offsets are committed after processing, which can lead to duplicates on failure. Options A and D rely on automatic commits or incorrect ordering and do not provide strict at-most-once guarantees.

The Kafka documentation explicitly states that manual offset management with commits before processing is required for at-most-once delivery.

Therefore, Option B is the best and officially documented configuration and code skeleton to avoid duplicate message processing.