Confluent CCDAK - Confluent Certified Developer for Apache Kafka Certification Examination

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.

The official Apache Kafka producer documentation states that setting enable.idempotence=true guarantees that messages are written to a partition exactly once, even in the presence of retries caused by network failures or broker timeouts. This feature prevents duplicate records by assigning producer sequence numbers and validating them on the broker side.

For idempotent producers to work correctly, retries must be enabled, which is why Kafka recommends a very large value such as retries=2147483647. Additionally, limiting max.in.flight.requests.per.connection to 1 ensures strict ordering during retries, preventing message reordering in older Kafka versions and providing the safest configuration.

Option A is irrelevant to producers. Option B explicitly disables idempotence, which causes duplicates. Option D disables retries, which increases the risk of message loss.

Therefore, the correct and fully documented solution to eliminate duplicate messages is enabling idempotence with retries and a safe in-flight request limit, as shown in Option C.

According to the Apache Kafka Consumer API documentation, the assign() method allows a consumer to manually assign specific partitions to itself, bypassing Kafka’s consumer group coordination and rebalancing mechanism. When a consumer uses assign() with all partitions of a topic, that consumer will read from every partition, regardless of how many other consumers exist.

This behavior is required when every consumer instance must independently read the full dataset, such as in auditing, monitoring, or replication use cases. In contrast, subscribe() is designed for consumer group usage, where partitions are distributed among consumers, ensuring that each partition is consumed by only one consumer in the group.

Option B is invalid because assign() requires a collection of TopicPartition objects, not just a topic name. Option C still uses group coordination and does not guarantee all partitions per consumer. Option D is invalid because an empty group ID is not supported by Kafka.

Thus, explicitly calling assign() with all topic partitions is the only correct and documented way to ensure each consumer reads from all partitions.

Correct Matches

path.format→Only valid for some Source Connectors

value.converter→Valid for all Source Connectors

input.path→Only valid for some Source Connectors

errors.retry.timeout→Valid for all Source Connectors

tasks.max→Valid for all Source Connectors

path.formatThis is a connector-specific configuration, commonly used by file-based or storage-based source connectors (for example, HDFS, S3, or FilePulse connectors). It isnot part of the Kafka Connect framework itself, so it is only valid for some source connectors.

value.converterThis is aworker-level configurationthat defines how record values are converted (JSON, Avro, Protobuf, etc.). It applies toall connectorsrunning on the worker unless overridden at the connector level.

input.pathThis configuration is specific to file-based source connectors (e.g., FileStreamSourceConnector). It isnot universally supported, so it is only valid for some source connectors.

errors.retry.timeoutThis is part of Kafka Connect’serror handling framework, introduced to support retries and tolerance of transient errors. It is ageneric Connect configurationand valid for all connectors.

tasks.maxThis is amandatory, generic connector configurationthat controls the maximum number of tasks a connector may create. It is valid forall source (and sink) connectors.

The default maximum message size that a Kafka broker accepts is 1MB (1,048,576 bytes), controlled by the config property message.max.bytes.

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

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.

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.

For real-time applications, the key metric to monitor is consumer lag — the difference between the latest offset on the broker and the last committed offset by the consumer.

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

As documented in the official Apache Kafka Connect framework documentation, Kafka Connect workers form a logical cluster by using a Kafka consumer group. The configuration property that identifies this cluster is group.id.

All Kafka Connect workers configured with the same group.id automatically join the same Connect cluster. Kafka’s group coordination protocol is then used to distribute connector and task configurations among the workers, providing fault tolerance, scalability, and automatic rebalancing.

Option A (cluster.id) is a Kafka internal identifier used by brokers and is not configurable for Kafka Connect workers. Option B (worker.id) does not exist as a valid Kafka Connect configuration. Option D (connector.id) identifies individual connectors within a Connect cluster, not the worker cluster itself.

Therefore, the group.id property is the correct and officially documented configuration that determines which Kafka Connect cluster a worker belongs to.

With acks=all and min.insync.replicas=2, Kafka requires at least two in-sync replicas to acknowledge a write. If only one broker is alive, the condition fails, and NotEnoughReplicasException is thrown by the producer.

From Kafka Producer Exception Docs:

“NotEnoughReplicasException is thrown when the number of in-sync replicas is insufficient to satisfy acks=all with min.insync.replicas.”

NetworkException is generic and not raised here.

NotCoordinatorException is related to consumer group coordination.

NotLeaderForPartitionException is unrelated unless accessing an unassigned leader.