Confluent CCAAK Dumps

Event stream processing is ideal for real-time and near-real-time scenarios. Kafka Streams and ksqlDB are commonly used in use cases requiring immediate reaction to data.

A → Correct: Fraud detection systems benefit from low-latency anomaly detection.

B → Correct: Real-time product recommendations based on user activity require continuous processing.

C → Incorrect: End-of-day processing is batch-oriented, not real-time.

D → Correct: Real-time alerting and log anomaly detection are classic streaming use cases.

E → Incorrect: Historical dashboards rely on batch aggregation and are not continuous processing.

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 7, p. 210–215

Confluent Documentation: Use Cases for Kafka Streams and ksqlDB

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾

Kafka does not enforce a single compression format per topic or partition. Each producer can independently choose whether to compress its messages and what compression type to use (e.g., gzip, snappy, lz4). These compressed messages coexist with uncompressed ones in the same topic.

From Kafka documentation:

“Producers can individually configure compression settings. Kafka stores messages in the format they are received, so compressed and uncompressed messages can exist in the same partition.”

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 5, p. 164–165

Apache Kafka Documentation: Producer Config – compression.type

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾

In Kafka, a Leader ID of -1 indicates that no broker is currently the leader for that partition. This typically happens when the only replica for the partition (broker 1 in this case) is offline or unavailable.

From Kafka documentation:

“If the leader for a partition is not available, the leader ID will be reported as -1.”

A → Correct: The broker hosting the sole replica is down.

B/C/D → Incorrect and unrelated to leader election behavior.

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 6, p. 191

Apache Kafka Documentation: Topic Description Output and Leader Election

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾

To ensure that duplicate messages are not processed and no messages are skipped, ksqlDB’s persistent queries must be configured to provide exactly-once processing guarantees. This is achieved by setting the processing.guarantee property to exactly_once. This configuration ensures that messages are neither lost nor processed more than once in the event of failures or restarts.

As per the official Confluent documentation:

“ksqlDB persistent queries can be configured for either at-least-once or exactly-once processing semantics by setting the processing.guarantee configuration property.”

“When processing.guarantee is set to exactly_once, ksqlDB ensures that messages are processed only once, even in failure scenarios. This eliminates duplicates and guarantees strong message delivery semantics.”

Other options:

Option B and C (ksql.streams.auto.offset.reset) only control the starting offset for new consumers, and do not enforce exactly-once semantics.

Option D (ksql.fail.on.production.error) controls whether errors during message production should fail the query, and does not affect exactly-once processing.

Page Reference:

Confluent Kafka: The Definitive Guide, 1st Edition, Chapter 11 (Stream Processing with ksqlDB), p. 365.

Confluent Documentation, “ksqlDB Configuration Properties” (processing.guarantee).

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾

Kafka supports topic deletion via the kafka-topics.sh tool if the broker property delete.topic.enable=true. This is the recommended and cleanest method to delete a topic and its data from the cluster.

From Kafka documentation:

“To delete a topic, use kafka-topics.sh with --delete flag, provided delete.topic.enable is set to true on the broker.”

A → Correct: Official method.

B → Misunderstood use of null keys (used for compaction).

C → Not recommended; causes inconsistent state.

D → Deletes consumer state, not the topic itself.

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 6, p. 198

Apache Kafka Documentation: Topic Deletion

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾

Kafka uses ZooKeeper as its distributed coordination system. ZooKeeper helps manage cluster metadata and leader election.

A → Correct: Brokers retrieve leader/partition assignments from ZooKeeper.

D → Correct: ZooKeeper is used to elect the controller broker responsible for cluster-wide administrative tasks.

From Kafka documentation:

“ZooKeeper maintains metadata for Kafka, including broker registration and controller election.”

B → Incorrect: Broker scaling is not handled via ZooKeeper.

C → Incorrect: Replication across clusters is not related to ZooKeeper.

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 6, p. 189–191

Apache Kafka Documentation: ZooKeeper Integration

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾

Partitions are Kafka’s core mechanism for scaling and distributing load. Each partition of a topic is distributed across brokers. Producers and consumers interact with specific partitions, and Kafka automatically balances those partitions across available brokers.

From Kafka documentation:

“Partitions allow Kafka to parallelize data and distribute load across brokers and clients.”

A → Correct: Distributes data and load

B → Incorrect: Replicas are for fault tolerance, not load balancing

C → Incorrect: Offsets track read progress, not distribute load

D → Incorrect: Connectors are part of Kafka Connect, not used for client balancing

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 4, p. 132–134

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾

To ensure there is no single point of failure in Kafka, the most critical setting is the replication factor. By setting the replication factor to 3, each partition’s data is replicated across three brokers. This provides fault tolerance and ensures data remains available even if one or two brokers fail.

From Kafka documentation:

“A higher replication factor provides better fault tolerance. A replication factor of 3 is a common choice for production systems that prioritize availability and durability.”

A → Incorrect: min.insync.replicas=1 allows data to be acknowledged even if only one replica is in-sync — not resilient to broker failure.

B → Incorrect: More partitions increase parallelism, not redundancy.

C → Incorrect: linger.ms is a producer-side performance setting, unrelated to durability.

D → Correct: Ensures data is redundantly stored across brokers.

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 6, p. 191–193

Apache Kafka Documentation: Topic-Level Configuration – replication.factor

Let me know if you’d like to continue with Question No: 55!

Kafka follows a specific sequence for evaluating permissions:

If a user is listed as a Super User → Access granted.

Otherwise, Kafka checks if there's an explicit Allow ACL → Grants access.

If not allowed, it checks for an explicit Deny ACL → Denies access.

If no ACL matches → Denied by default.

From Apache Kafka documentation:

“The evaluation order is: Superuser → Allow ACL → Deny ACL → Default deny.”

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 9, p. 286

Apache Kafka Documentation: “Kafka Authorization – Evaluation Order”

Apache Kafka's built-in ACL mechanism (SimpleAclAuthorizer) stores ACL data in ZooKeeper. ACLs are propagated to brokers from ZooKeeper and cached in memory for fast lookup.

From Kafka documentation:

“ACLs are stored in ZooKeeper under /kafka-acl and are loaded into each broker at startup and on updates.”

B → Correct: ZooKeeper stores ACLs centrally.

A → Brokers load ACLs but don’t persist them.

C & D → Do not store or manage ACLs.

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 9, p. 285

Apache Kafka Documentation: Authorizer Configuration

Kafka's Controller is a broker that also performs controller duties. It is not a dedicated node. Therefore, it continues to host topics, partitions, and leaders just like any other broker.

From Kafka documentation:

“The controller is one of the brokers in the cluster and continues to perform all normal broker functions.”

A → Correct: The controller is also a normal broker with partitions.

B/C/D → Incorrect: Replication and consumer fetches are not tied to the controller.

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 6, p. 190

Apache Kafka Documentation: Kafka Controller Behavior

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾

To increase throughput, Kafka recommends allowing larger batches and giving more time for the producer to accumulate records into batches:

batch.size: Increasing this allows more records to be sent in a single request.

linger.ms: Increasing this adds a delay so that the producer can accumulate more messages into a batch.

From Kafka documentation:

“Increasing both batch.size and linger.ms allows the producer to send larger, more efficient batches, improving throughput at the cost of slightly increased latency.”

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 5, p. 162–163

Apache Kafka Documentation: Producer Configuration Parameters

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾

Confluent Schema Registry supports the following schema types for use with Kafka:

Avro

Protobuf

JSON Schema

These schemas are officially supported for subject versioning, compatibility checks, and REST interface integration.

From Confluent documentation:

“The Confluent Schema Registry supports Avro, JSON Schema, and Protobuf formats.”

Incorrect Options:

gRPC is not supported as a schema format.

Thrift is not supported in Schema Registry.

Page Reference:

Confluent Kafka: The Definitive Guide, 1st Edition, Chapter 7, p. 208–210

Confluent Schema Registry Documentation: Overview Section (Schema Types)

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾

Kafka uses a pull model for consumers. The consumer polls the broker for available data. This contrasts with push models (used in traditional messaging systems), where the server pushes messages to consumers.

From Kafka documentation:

“Kafka’s consumers use a pull model, where the consumer requests messages from the broker at its own pace.”

A → Incorrect: Kafka does not push messages.

B → Incorrect: Kafka is a publish-subscribe system, but not the model used for message delivery to consumers.

C → Correct: Consumers explicitly pull messages.

D → Invalid in Kafka terminology.

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 4, p. 126

Apache Kafka Documentation: Consumer Design Overview

Kafka architecture maintains exactly one active Controller at any given time, regardless of the number of brokers. The Controller is responsible for administrative tasks like partition leader election and topic creation. The remaining brokers are replicas, ready to take over if the Controller fails.

From Kafka documentation:

“At any given time, there is only one active controller in the Kafka cluster.”

Even in a cluster with 4 brokers, only 1 broker acts as the Controller.

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 6, p. 189

Apache Kafka Documentation: Controller Role Description

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾

Unclean leader election allows Kafka to elect a non-in-sync replica as a new leader when all in-sync replicas are unavailable. This increases availability at the cost of possible message loss (sacrificing reliability).

From Kafka documentation:

“If unclean.leader.election.enable is set to true, a broker that is not in the ISR can be elected as leader, which increases availability but may lead to data loss.”

A → Correct: Improves availability when ISR is empty.

B → Best practice for quorum-based systems like ZooKeeper but not the setting that trades off reliability.

C → Controls batching latency, unrelated to availability.

D → Retention -1 means “retain forever,” which impacts storage, not HA.

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 6, p. 195

Apache Kafka Documentation: Topic Config – unclean.leader.election.enable

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾