CCDAK Practice Exam Questions with Answers Confluent Certified Developer for Apache Kafka Certification Examination Certification

ForSASL/PLAIN authentication over SSL, the correct combination is:

security.protocol=SASL_SSL

sasl.jaas.config=...PlainLoginModule required username=... password=...

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

To maintainmessage ordering per bank account, themessage key must be the account number. Kafka guaranteesordering per partition, and the partition is selected based on thehash of the key.

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

When amessage keyis specified in Kafka, the producer uses apartitioner(typically the default hash-based partitioner) todeterministically map all records with the same key to the same partition. Kafka guaranteesorder within a partition, so this enables per-key ordering.

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

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

FromKafka 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, only3 acknowledgments are needed, as defined by min.insync.replicas.

To change the replication factor of an existing topic, you must perform apartition reassignment, because the replication factor is not directly modifiable via kafka-topics.sh. Thekafka-reassign-partitions.shtool 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 isnotan official Kafka tool.

Session windowsare ideal for trackingperiods of activity separated by inactivity, such as user sessions.

FromKafka Streams Documentation > Windowing:

“A session window captures streams of events that areintermittentand separated by agap of inactivity.”

Tumbling/Hopping/Sliding windows are fixed in size

Session windows are dynamic and close after inactivity timeout

This makes them perfect for identifyinggaps in user interaction.

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, andall 15 can be activedepending on processing topology.

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

The ConsumerRebalanceListener lets youhandle partition assignments and revocationsduring rebalances. This is critical for managingoffsets,stateful processing, orexternal transactions.

FromKafka 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 partitionsassigned to the consumer change.

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

If the consumer fails to send heartbeats in time (due to being slow under load), it is considereddead, causing a rebalance. Increasing session.timeout.ms gives the consumermore time to process messages and send heartbeats, preventing premature removal.

FromKafka Docs > Heartbeats and Failures:

“If the consumer does not send a heartbeat in session.timeout.ms, it is considered dead and the group coordinator will trigger a rebalance.”

Reducing max.poll.records mightslow consumption further. More consumers won’t help since each partition already has a dedicated consumer.

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

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

To ensureexactly-once deliveryand avoid duplicates even during retries:

enable.idempotence=trueensures deduplication on the broker

retries=2147483647allows unlimited retries on retriable errors

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

FromKafka 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

For Kafka Streams to performjoins, topics must beco-partitioned, meaning:

They have thesame number of partitions(A), and

They use thesame partitioning strategy(typically by key) (B)

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

TheKafka Streams DSLprovides three primary abstractions:

KStream: Represents an unbounded stream of records (append-only).

KTable: Represents a changelog stream where each key has the latest value (like a materialized view).

GlobalKTable: A fully replicated version of KTable across all stream instances, enabling global joins.

FromKafka Streams Developer Guide:

“Kafka Streams provides three core abstractions: KStream, KTable, and GlobalKTable, each serving different purposes in stream processing and joins.”

GlobalKStream and StreamTable donot existin Kafka’s API.