Confluent CCAAK Confluent Certified Administrator for Apache Kafka Exam Practice Test

In Kafka, the Controller is responsible for managing partition leadership. When a broker that was leader for certain partitions goes down, the Controller immediately detects the failure and:

Triggers a new leader election among the in-sync replicas (ISRs) of those partitions.

Updates the partition metadata to reflect the new leaders and notifies the cluster.

Kafka documentation states:

“When a broker fails, the controller triggers a leader election for all partitions previously led by the failed broker.”

Page Reference:

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

Apache Kafka Documentation: “Kafka Controller and Leader Election”

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

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

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

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

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

Replication in Kafka ensures that partition data is copied across multiple brokers. This guarantees durability (data survives broker failure) and availability (other replicas can serve as leader if current leader fails).

From Kafka documentation:

“Replication ensures that data is not lost if a broker crashes and that messages remain available even during broker outages.”

B → Correct: Ensures persisted data even after failure.

C → Correct: Allows partition leader failover.

A → Incorrect: Replication may slightly reduce performance.

D → Incorrect: Replication is not a security mechanism.

Page Reference:

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

Apache Kafka Documentation: Replication Overview

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

By default, Kafka does not enable any security mechanism. This means:

Communication is done over PLAINTEXT (unencrypted).

No authentication is configured.

No authorization is enforced.

From Apache Kafka documentation:

“By default, Kafka has no security. All network communication is done in plaintext, and there is no client authentication or authorization.”

This means that:

Option A is correct.

Option B is incorrect because encryption is not enabled by default.

Option C is incorrect because authentication is not provided unless SASL is configured.

Option D is incorrect as neither encryption nor authentication is enabled by default.

Page Reference:

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

Apache Kafka Documentation: “Security Overview” section

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

The kafka-consumer-groups.sh script is used to monitor consumer group offsets and lag. It shows the current offset, log end offset, and lag for each partition consumed by a consumer group.

From Kafka documentation:

“You can use kafka-consumer-groups.sh with the --describe flag to get the offset lag per consumer group.”

A → Incorrect: No such built-in script.

B → Correct: Official script for viewing consumer group lag.

C → Incorrect: Does not exist as a built-in Kafka tool.

D → Incorrect: Used for partition reassignment, unrelated to lag monitoring.

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 10, p. 308

Apache Kafka Documentation: kafka-consumer-groups.sh usage

When a broker is shut down gracefully:

It flushes data from memory to disk to avoid log recovery upon restart.

It also notifies the controller to reassign leadership of the partitions it leads, ensuring high availability.

From Kafka documentation:

“A graceful shutdown will first flush logs to disk and then hand over leadership of partitions to ensure minimal disruption.”

C → Incorrect: Leader election happens only when the controller detects broker loss; it’s not guaranteed on restart.

D → Incorrect: Partition rebalancing is not automatic on broker restart unless manually initiated.

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 10, p. 306

Apache Kafka Documentation: Graceful Shutdown Behavior

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

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

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

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

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

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

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

In Apache Kafka, rack awareness can be used to ensure better fault tolerance and availability by spreading partition replicas across brokers in different racks. The broker configuration property that explicitly indicates the rack a broker belongs to is broker.rack.

As per the official Apache Kafka documentation:

“To assign a broker to a specific rack, configure the broker.rack property in server.properties. This informs Kafka of the rack location for the broker.”

This is useful for features like rack-aware partition assignment and leader election. With broker.rack set, Kafka can make intelligent decisions to ensure that replicas are distributed across racks.

Other options:

client.rack is a client-side setting to inform Kafka of the client’s rack for fetching from the closest replica, not for brokers.

zookeeper.rack and kafka.rack do not exist in Kafka’s official configuration.

Page Reference:

Apache Kafka Documentation, “Rack Awareness” section.

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

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

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

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

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

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 supports multiple SASL mechanisms for authentication, including:

SASL/PLAIN – Username/password

SASL/GSSAPI – Kerberos-based

SASL/OAUTHBEARER – OAuth 2.0 token-based

From Apache Kafka documentation:

“Kafka supports the following SASL mechanisms: GSSAPI (Kerberos), PLAIN, SCRAM, OAUTHBEARER.”

B → SAML20 is not supported.

E → OTP is not a supported SASL mechanism.

Page Reference:

Kafka: The Definitive Guide, 1st Edition, Chapter 9, p. 280–284

Apache Kafka Documentation: Kafka SASL Authentication

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

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!