Pass the Confluent Confluent Certified Developer CCDAK Questions and answers with CertsForce

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.

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.

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.

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.

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

According to the official Apache Kafka client documentation, Kafka uses SLF4J (Simple Logging Facade for Java) for all client-side logging. SLF4J is only an abstraction layer and requires a concrete logging implementation to route log messages to the actual logging framework used by the application.

Since the application uses Log4j2, an SLF4J-to-Log4j2 binding must be provided. The correct and officially recommended dependency is org.apache.logging.log4j:log4j-slf4j-impl. This dependency acts as the SLF4J implementation and forwards all Kafka client log messages to Log4j2, ensuring consistent logging across the application.

Option B is incorrect because it targets the legacy Log4j 1.2 framework, which is deprecated and incompatible with Log4j2. Option C is insufficient because Log4j2 alone does not satisfy Kafka’s SLF4J dependency. Option D is incorrect because Kafka intentionally does not include a logging implementation transitively, allowing applications to choose their preferred logging framework.

Therefore, including the SLF4J implementation for Log4j2 is required to properly integrate Kafka client logs.

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

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

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.

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.

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.