The Confluent Certified Developer for Apache Kafka Certification Examination (CCDAK)

RetriableException is a subclass of KafkaException, indicating transient issues that might succeed if retried. Examples include:

LeaderNotAvailableException: Happens when metadata is not yet propagated or leader election is in progress.

NotEnoughReplicasException: Happens when the number of in-sync replicas is insufficient. This can be transient if replicas come back online.

From the Apache Kafka Java Client documentation:

"These exceptions (like LeaderNotAvailableException, NotEnoughReplicasException) are transient and the client will retry them automatically depending on retry configuration."

RecordTooLargeException and AuthorizationException are non-retriable as they indicate client-side or permission errors.

Comprehensive and Detailed Explanation From Exact Extract:

✅ C. Consumers can consume both committed and uncommitted transactions.By default, Kafka consumers only read committed messages if they are configured with isolation.level=read_committed. However, if configured as read_uncommitted, they can 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_state to maintain metadata about producer transactions. This topic is essential for tracking the transaction lifecycle, fencing, and recovery.

From Kafka Internals:

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

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.

These three metrics are critical for cluster health:

OfflinePartitionsCount: Indicates partitions without active leaders — a sign of broker failure.

ActiveControllerCount: There should be exactly one active controller. A count ≠ 1 signals controller failure.

UncleanLeaderElectionsPerSec: Tracks leader elections where out-of-sync replicas were selected — risky for data loss.

From Kafka Monitoring Documentation:

“Offline partitions and unclean leader elections should trigger alerts. Also, ensure a single active controller is running.”

A is about topics pending deletion — not critical.

E is a per-topic record metric, not broker-level.

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.format This is a connector-specific configuration, commonly used by file-based or storage-based source connectors (for example, HDFS, S3, or FilePulse connectors). It is not part of the Kafka Connect framework itself , so it is only valid for some source connectors.

value.converter This is a worker-level configuration that defines how record values are converted (JSON, Avro, Protobuf, etc.). It applies to all connectors running on the worker unless overridden at the connector level.

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

errors.retry.timeout This is part of Kafka Connect’s error handling framework , introduced to support retries and tolerance of transient errors. It is a generic Connect configuration and valid for all connectors.

tasks.max This is a mandatory, generic connector configuration that controls the maximum number of tasks a connector may create. It is valid for all source (and sink) connectors .

The ConsumerRebalanceListener lets you handle partition assignments and revocations during rebalances. This is critical for managing offsets, stateful processing, or external transactions.

From Kafka 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 partitions assigned to the consumer change.

B, C, and D are unrelated to consumer rebalancing directly.

When a message key is specified in Kafka, the producer uses a partitioner (typically the default hash-based partitioner) to deterministically map all records with the same key to the same partition. Kafka guarantees order within a partition, so this enables per-key ordering.

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

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

The Apache Kafka Streams documentation defines a co-partitioning requirement for KStream–KTable and KStream–KStream joins. Both input topics must have the same number of partitions and the same key partitioning strategy.

One valid solution is to use a GlobalKTable (Option A). A GlobalKTable is fully replicated to every Kafka Streams instance, removing the co-partitioning requirement. This approach is recommended when the reference data is relatively small and changes infrequently.

Another valid solution is to repartition one topic so that both topics have the same number of partitions (Option B). Kafka Streams provides repartition topics specifically for this purpose, allowing proper KStream–KTable joins.

Option C does not resolve the partition mismatch, as increasing instances does not change partitioning. Option D is incorrect because Kafka Streams does not automatically repartition both topics for joins; repartitioning must be explicitly configured.

Therefore, the correct and officially supported solutions are using a GlobalKTable and explicitly repartitioning one topic.

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