CCAAK Confluent Certified Administrator for Apache Kafka Questions and Answers

A → Correct: Kafka uses ZooKeeper's ephemeral node (/controller) to elect a single controller. If the node disappears (e.g., due to GC pause or failure), a new controller is elected.“Kafka uses an ephemeral znode in ZooKeeper to hold the identity of the controller.” — Apache Kafka docs

B → Correct: The controller assigns partition leaders after startup or during rebalancing.

C → Correct: The controller epoch is a monotonically increasing number used to detect outdated controller messages.“Kafka uses a controller epoch to avoid split-brain situations. A new controller will increase the epoch.”

Incorrect options:

D → Wrong: Broker ID is not used as epoch.

E → Wrong: Only one active controller at a time, not one per broker.

F → Wrong: Partition assignment to consumers is handled by the consumer coordinator, not the controller.

Page Reference:

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

Apache Kafka Documentation: “Kafka Controller Design”

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

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

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

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

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”

Kafka’s default authorizer implementation is the SimpleAclAuthorizer, which stores ACLs in ZooKeeper and reads them on each access.

From Kafka documentation:

“Apache Kafka includes an out-of-the-box authorizer implementation that stores ACLs in ZooKeeper.”

A → RBAC is Confluent-specific and not stored in ZooKeeper.

B → Correct: Built-in ACL mechanism uses ZooKeeper.

C → Ranger is an external plugin, not bundled with Apache Kafka.

D → LDAP is used for authentication, not authorization.

Page Reference:

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

Apache Kafka Documentation: ACLs and Authorizers

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

Kafka topics are logical streams of data, and each topic is split into one or more partitions. Each partition belongs to exactly one topic.

From Kafka documentation:

“A topic is a category of messages, split into partitions. Each partition is an ordered, immutable sequence of messages, and each belongs to only one topic.”

A → Incorrect: A topic can have more than one partition.

B → Correct: Kafka uses partitions to scale topics.

C → Correct: Partitions belong to exactly one topic.

D/E → Incorrect: Invalid Kafka data model.

Page Reference:

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

Apache Kafka Documentation: Kafka Data Model Overview

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

When sizing a ksqlDB cluster, the following factors are crucial:

A. Data Schema: Complex schemas may require more CPU/memory for serialization/deserialization.

B. Number of Queries: Each persistent query consumes system resources (CPU, memory).

C. Number of Partitions: Determines parallelism and state store scalability.

From Confluent documentation:

“Cluster capacity planning depends on schema complexity, query concurrency, and partition count.”

D → Incorrect: Encryption impacts producer/broker, not ksqlDB sizing directly.

E → Incorrect: Retention is managed by Kafka, not ksqlDB.

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 7, p. 225–229

Confluent ksqlDB Documentation: Capacity Planning Guidelines

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

In Kafka Connect, sink connectors consume data from Kafka topics and send it to external systems (e.g., databases, object storage, search indexes).

From Kafka documentation:

“Sink connectors receive data from Kafka topics and write it to external systems.”

A → Correct: Moves data out of Kafka.

B → Moves data into Kafka.

C → Not a connector type.

D → Not a standard connector classification.

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 8, p. 241

Apache Kafka Documentation: Kafka Connect – Sink Connectors

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

Kafka Connect uses internal topics to manage its state. When running in distributed mode, it relies on the following internal topics:

connect-configs — stores connector and task configurations

connect-offsets — stores source connector offsets

connect-status — stores status information (running, failed, etc.) for connectors and tasks

Option A appears misspelled as “connect-confiqs” — it should be “connect-configs”. Assuming it is a typo, the correct answer includes it.

Incorrect options:

connect-distributed and connect-standalone are not internal topics but execution modes for Kafka Connect.

Page Reference:

Confluent Kafka: The Definitive Guide, 1st Edition, Chapter 8, p. 249

Apache Kafka Documentation: “Kafka Connect - Distributed Mode Configuration”

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

Kafka ensures message immutability once data is written to disk. It guarantees that the message cannot be altered post-write, ensuring strong integrity.

From Kafka documentation:

“Kafka provides strong durability and immutability guarantees. Once a message is written and acknowledged, it cannot be modified.”

A → Incorrect: Offsets are immutable. Producers cannot overwrite messages.

C → Partially true for performance but not about message integrity.

D → Metadata changes do not affect message content or integrity.

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 4, p. 122–123

Apache Kafka Documentation: Message Durability & Immutability

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

For maximum throughput and lowest latency, the setting acks=0 allows the producer to send messages without waiting for any acknowledgment from the broker. This increases speed but at the cost of durability.

From Kafka documentation:

“acks=0: The producer does not wait for any acknowledgment from the broker. The message can be lost but offers the highest throughput.”

A → Correct: Maximizes throughput with no delivery guarantee.

B → Balanced option but not max throughput.

C → Offers strongest durability but lowest throughput.

D → Invalid configuration.

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 5, p. 158–159

Apache Kafka Documentation: Producer Configs – acks

Let’s break it down step by step using official Kafka architecture principles:

Total partitions: 10

Each partition stores: 25 GB per day

Total data for the topic per day (no replication): 10 partitions × 25 GB = 250 GB

Replication factor: 3 → three copies of each partition across the brokers

Each partition is replicated across three brokers. Since the replication factor is three, each broker will have one full replica of one-third of the partitions. In a balanced cluster with three brokers:

Each broker stores a replica of every partition (since replication factor = number of brokers).

So, each broker will store the full 250 GB of data for that topic.

Hence:

Each broker will consume: 250 GB

This is confirmed in the official Apache Kafka documentation:

“A replica is a fully-qualified copy of a partition. When the replication factor equals the number of brokers, each broker contains a full copy of the topic data.”

“Each broker stores the total size of data for the topic, regardless of which partitions it leads.”

Page Reference:

Confluent Kafka: The Definitive Guide, 1st Edition, Chapter 6 (Kafka Cluster), p. 209–210.

Apache Kafka Documentation, “Replication” and “Storage” sections.

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

Kafka supports quotas to limit the broker resources each client can use. This is used to prevent one client from monopolizing cluster bandwidth.

From Kafka documentation:

“Quotas can be applied to both producers and consumers. These quotas are enforced based on the number of bytes per second, and they are applied to ensure fair usage of broker resources.”

A. Quotas → Correct: Admins can define quotas on throughput per client ID or user.

B. Consumer Groups → Incorrect: This controls parallelism in consumption but not resource fairness.

C. Rebalancing → Incorrect: This helps with load balancing but not with resource limitation.

D. ACLs → Incorrect: ACLs define access permissions but not resource usage.

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 10 (“Administering Kafka”), p. 306–308

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