Free and Premium Confluent CCDAK Dumps Questions Answers

TheStickyAssignortries to minimize partition movement bypreserving existing assignmentsas much as possible while still achieving a balanced assignment. This improvesconsumer stabilityand reduces rebalances.

From theKafka Consumer Assignor Documentation:

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

Kafka Streams usestransactional producersto guaranteeexactly-once semantics (EOS). This ensures that both theoutput recordsandstate store updatesare committed atomically, avoiding duplication or partial writes.

FromKafka Streams Documentation > Processing Guarantees:

“Kafka Streams leveragesKafka’s transactional APIsto commit the output records and internal state updatesas a single atomic unit, thereby providing exactly-once semantics.”

Option A is incorrect because log compaction is not disabled for EOS.

Option C incorrectly describes a checkpointing system Kafka Streams does not use.

Option D refers to deduplication, which is not how EOS is achieved in Streams.

The bootstrap.servers setting is used by clients (producers and consumers) toinitially connectto the Kafka cluster. It does not need to list all brokers—just a few that are up and reachable. The client will then use the cluster metadata to discover the full broker list.

FromKafka Java Client Configuration Docs:

“This is a list of host/port pairs to use for establishing the initial connection to the Kafka cluster. The client will make use of all servers irrespective of which servers are specified here for bootstrapping.”

Hence,listing multiple brokers provides redundancyand fault tolerance in the event one is down during client startup.

SMTs (Single Message Transforms) arelightweight transformationsapplied to individual messages as they pass through Kafka Connect.

Chaining SMTs: You can applymultiple SMTsin sequence by defining them in order in the connector config.

Masking or modifying fieldsis acommon use case(e.g., redacting sensitive data).

FromKafka Connect Documentation:

“Single Message Transforms (SMTs) are applied to individual messages. You can chain multiple SMTs together.”

SMTsdo not perform joins(B is incorrect).

Converters and SMTs areseparate concerns(D is incorrect).

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.

These three metrics are critical for cluster health:

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

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

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

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

If a key isnot specified, thedefault Kafka partitioner uses round-robinlogic to assign partitions. This leads toeven distributionof messages across all partitions.

FromKafka Producer Design:

“If the key is null, the producer will assign the partition in a round-robin fashion to achieve load balancing.”

There isno error, and partition 0 isnot alwayschosen in this case.

unclean.leader.election.enable=false→ Prevents data loss by only considering in-sync replicas when rebalancing.

replication.factor→ Specifies how many redundant copies of partitions are distributed across brokers.

min.insync.replicas=2→ Sets the standard for the number of partition instances that must keep up with the latest committed message.

unclean.leader.election.enable=false ensures that onlyin-sync replicascan be elected as leaders. If disabled, an out-of-sync replica may become leader, potentially leading to data loss.

replication.factor defineshow many brokerswill maintain copies of each partition, directly impacting durability and availability.

min.insync.replicas determineshow many replicas must acknowledgea write when acks=all is used, enforcing write durability.

BothLeaderNotAvailableExceptionandNotEnoughReplicasExceptionare subclasses of RetriableException, which representstransient issuesthat may succeed upon retry.

FromApache Kafka Java Client Documentation:

“RetriableException indicates that the request can be retried. This includes network errors and certain broker-side failures like leader not available or not enough replicas.”

RecordTooLargeException and AuthorizationException arenon-retriablebecause they represent client misconfigurations or access issues.

Using assign() givesmanual controlover partition assignment. In this mode:

B is true: The applicationchooses partitionsdirectly without involving the group coordinator.

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

FromKafka 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() aremutually exclusive.

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

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.

Kafka Connectsource connectorsuse theoffset.storage.topicconfiguration parameter to define where to storeoffsets that track the connector's positionin the source system (e.g., database, file, etc.).

FromKafka Connect Worker Configuration:

“offset.storage.topic specifies the topic in Kafka where the connector stores offsets for each source partition.”

This allows Kafka Connect toresumefrom the correct position on restart.

The other options (B–D) are not valid Kafka configs.

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.

Kafka Connectsink connectorsuse thestandard Kafka consumer mechanismto track offsets, which means offsets are stored in the__consumer_offsets internal topic.

FromKafka Connect Documentation:

“Sink connectors are regular Kafka consumers and store their offsets in the __consumer_offsets topic like any other consumer.”

The other options refer tosource connectorsor worker configuration.

offsets.storage.topic is relevant forsource connectors.

RetriableException is a subclass of KafkaException, indicating transient issues thatmight 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 theApache Kafka Java Client documentation:

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

RecordTooLargeExceptionandAuthorizationExceptionarenon-retriableas they indicate client-side or permission errors.

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

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

For proper delivery handling with acks=all:

Usecallbackto log or act on success/failure.

Usetry/catchto handle synchronous exceptions like serialization errors or network failures.

FromKafka Producer Documentation:

“Errors can be caught either via the returned Future or via the callback interface. For fatal errors, use a try/catch block around the send call.”

Option B is incorrect because send() returns a Future, not RecordMetadata directly.

Option D is invalid — ProducerRecord has no method called status().

Increasing partitions increasesparallelism, but also means:

Consumers in a group may have to handlemore partitions, especially if the number of consumers is lower than the number of partitions.

This can result inincreased lag, especially under high load.

FromKafka 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 partitionbased on hash.

D is not directly impacted by the partition count.