Question 1

When a broker goes down, what will the Controller do?

Accepted Answer

B

Explanation: The Controller is a designated broker in a Kafka cluster responsible for managing the state of partitions and replicas. When a broker fails, the Controller detects this failure (historically via ZooKeeper, now via the KRaft consensus protocol). For every partition whose leader was on the failed broker, the Controller initiates a leader election. It selects a new leader from the set of in-sync replicas (ISRs) for that partition. This action ensures that leadership for the affected partitions is redistributed among the remaining healthy brokers, maintaining data availability.

Question 2

A developer is working for a company with internal best practices that dictate that there is no single
point of failure for all data stored.
What is the best approach to make sure the developer is complying with this best practice when
creating Kafka topics?

Accepted Answer

D

Explanation: The core principle to avoid a single point of failure for data in Kafka is replication. The topic's replication-factor determines how many copies of each partition's data are stored across different brokers in the cluster. Setting the replication factor to 3 (a common best practice) ensures that for each partition, there is one leader and two follower replicas on three separate brokers. If one broker fails, the data remains available on the other two, and a new leader can be elected from the in-sync followers, thus preventing data loss and service interruption.

Question 3

A company is setting up a log ingestion use case where they will consume logs from numerous
systems. The company wants to tune Kafka for the utmost throughput.
In this scenario, what acknowledgment setting makes the most sense?

Accepted Answer

A

Explanation: The acks (acknowledgments) configuration determines the durability guarantee for messages sent by a producer. To achieve the "utmost throughput," latency must be minimized. Setting acks=0 instructs the producer not to wait for any acknowledgment from the broker after sending a message. This "fire and forget" approach eliminates the round-trip time of waiting for a response, allowing the producer to send messages as fast as the network buffer allows. This configuration is suitable for use cases like high-volume log ingestion where losing a small fraction of messages is an acceptable trade-off for maximizing ingestion speed.

Question 4

If the Controller detects the failure of a broker that was the leader for some partitions, which actions will be taken? (Choose two.)

Accepted Answer

B, C

Explanation: When a broker that is a leader for one or more partitions fails, the Kafka Controller is responsible for managing the failover process. The Controller first selects a new leader from the list of in-sync replicas (ISR) for each affected partition. It then performs two critical actions: it persists this new leadership information and the updated ISR list to ZooKeeper to ensure the state change is durable. Concurrently, it sends a LeaderAndIsr request to all live brokers in the cluster, informing them of the new leader so they can update their metadata cache and route client requests correctly.

Question 5

Where are Apache Kafka Access Control Lists stored'?

Accepted Answer

B

Explanation: In traditional Apache Kafka deployments, which rely on ZooKeeper for cluster coordination, Access Control Lists (ACLs) are stored as metadata within ZooKeeper. ZooKeeper serves as the authoritative source of truth for the cluster's configuration, including security policies. Kafka brokers connect to ZooKeeper, read the ACLs, and cache them in memory to enforce authorization for client requests efficiently. While newer Kafka versions can run in KRaft mode without ZooKeeper, storing ACLs in ZooKeeper is the standard mechanism in the widely deployed architecture covered by the CCAAK exam.

Question 6

Which tool is used for scalably and reliably streaming data between Kafka and other data systems?

Accepted Answer

A

Explanation: Kafka Connect is a framework included in Apache Kafka specifically designed for scalably and reliably streaming data between Kafka and other data systems. It uses pre-built or custom connectors to move large data sets. Source connectors ingest entire databases or collect metrics from application servers into Kafka topics, while sink connectors deliver data from Kafka topics into secondary indexes like Elasticsearch or batch systems such as Hadoop for offline analysis. The framework manages offset commits, scaling, and fault tolerance, simplifying the development of data integration pipelines.

Question 7

You are using Confluent Schema Registry to provide a RESTful interface for storing and retrieving schemas. Which types of schemas are supported? (Choose three.)

Accepted Answer

A, C, E

Explanation: Confluent Schema Registry provides a centralized repository for managing and validating schemas for Kafka messages. It natively supports three schema formats as first-class citizens: Avro, Protobuf, and JSON Schema. These formats enable robust schema evolution, ensuring that producers and consumers can exchange data compatibly over time. The registry's RESTful interface allows for the storage, retrieval, and versioning of schemas defined in any of these three supported types, which are integrated with corresponding serializers and deserializers for client applications.

Question 8

What are important factors in sizing a ksqlDB cluster? (Choose three.)

Accepted Answer

A, B, C

Explanation: Sizing a ksqlDB cluster requires evaluating the workload's demands on compute, memory, and network resources. The three primary factors are: 1. Number of Queries: Each persistent query runs as a dedicated Kafka Streams application. More queries consume more CPU and memory. The complexity of these queries (e.g., joins, aggregations) also significantly impacts resource utilization. 2. Number of Partitions: ksqlDB achieves parallelism by assigning topic partitions to processing tasks. The number of partitions in the input topics dictates the maximum level of parallelism, directly influencing how many ksqlDB nodes can share the processing load and thus determining the required cluster size for a given throughput. 3. Data Schema: The complexity and size of the message schema affect the CPU and memory needed for serialization/deserialization and processing each message. Complex, nested schemas require more resources than simple, flat ones.

Question 9

By default, what do Kafka broker network connections have?

Accepted Answer

A

Explanation: By default, Apache Kafka is configured for a "trusted network" environment, prioritizing ease of use and initial setup over security. The default network listener uses the PLAINTEXT security protocol, which transmits data without any encryption. This default configuration does not implement any mechanism to verify the identity of clients connecting to the brokers, meaning there is no authentication. Consequently, as there is no authenticated principal (user), there is no basis for performing authorization checks against access control lists (ACLs). All security features—encryption (SSL/TLS), authentication (SASL or SSL), and authorization (ACLs)—must be explicitly configured by the administrator.

Question 10

A customer has a use case for a ksqlDB persistent query. You need to make sure that duplicate messages are not processed and messages are not skipped. Which property should you use?

Accepted Answer

A

Explanation: The requirement to prevent both duplicate message processing and skipping messages is the definition of exactly-once processing semantics. In ksqlDB, which is built on Kafka Streams, this guarantee is enabled by setting the processing.guarantee property to exactlyonce. This configuration ensures that each input record is processed once and only once, even in the event of failures, by leveraging Kafka's transactional capabilities to atomically write output records and commit consumer offsets.

Question 11

A Kafka administrator notices that their consumers of Topic X are starting to fall behind. The
administrator sees that Topic X has four partitions, and the consumer group has two consumers.
Which change can increase the performance of the Consumer Group?

Accepted Answer

D

Explanation: The fundamental unit of parallelism for consumption in Kafka is the topic partition. A consumer group can scale its processing throughput by adding more consumer instances, up to the total number of partitions in the topic. In this scenario, the topic has four partitions, but the consumer group only has two consumers. This means each consumer is responsible for processing messages from two partitions. By increasing the number of consumers in the group to three or four, the partitions will be rebalanced across more instances, allowing the workload to be processed in parallel and increasing the overall consumption rate for the group.

Question 12

Which ksqlDB statement produces data that is persisted into a Kafka topic?

Accepted Answer

C

Explanation: The INSERT INTO ... VALUES statement is a Data Manipulation Language (DML) command in ksqlDB used to produce a single row of data into an existing stream. Since every ksqlDB stream is backed by a Kafka topic, executing this statement directly results in a new message being produced and durably persisted to that underlying topic. This is the primary method for inserting individual, ad-hoc records into a stream from the ksqlDB CLI or an application.

Question 13

What is the primary purpose of Kafka quotas?

Accepted Answer

A

Explanation: Kafka quotas are a control mechanism designed to manage and limit the broker resources consumed by clients. The primary purpose is to enforce limits on network bandwidth (produce and fetch rates) and request processing time (request rate quotas). By setting these limits, administrators can throttle specific clients, preventing any single client or group of clients from monopolizing broker resources like network I/O or CPU. This ensures fair resource allocation and protects the overall stability and availability of the Kafka cluster for all other clients.

Question 14

You have a Kafka cluster with topics t1 and t2. In the output below, topic t2 shows Partition 1 with a
leader “-1”.
What is the most likely reason for this?
...
$ kafka-topics --zookeeper localhost:2181 --describe --topic t1
Topic:t1 PartitionCount 1 ReplicationFactor 1 Configs:
Topic: t1 Partition: 0 Leader: 0 Replicas: 0 Isr: 0
$ kafka-topics --zookeeper localhost:2181 --describe --topic t2
Topic:t2 PartitionCount 2 ReplicationFactor 1 Configs:
Topic: t2 Partition: 0 Leader: 0 Replicas: 0 Isr: 0
Topic: t2 Partition: 1 Leader: -1 Replicas: 1 Isr:

Accepted Answer

A

Explanation: The output Leader: -1 for a partition signifies that there is currently no active leader. This happens when the broker that was the leader becomes unavailable, and no other in-sync replica can be elected to take its place. In this specific case, the output for Topic: t2 Partition: 1 shows Replicas: 1. This indicates that Broker 1 is the only broker assigned to hold a replica for this partition. Therefore, if Broker 1 fails or becomes unreachable, the partition has no available replicas, the controller cannot elect a new leader, and the leader ID is set to -1 to indicate its unavailability.

Question 15

Kafka Connect is running on a two node cluster in distributed mode. The connector is a source
connector that pulls data from Postgres tables (users/payment/orders), writes to topics with two
partitions, and with replication factor two. The development team notices that the data is lagging
behind.
What should be done to reduce the data lag*?
The Connector definition is listed below:
{
"name": "confluent-postgresql-source",
"connector class": "PostgresSource",
"topic.prefix": "postgresql_",
& nbsp;& nbsp;& nbsp;…
"db.name": "postgres",
"table.whitelist": "users.payment.orders”,
"timestamp.column.name": "created_at",
"output.data format": "JSON",
"db.timezone": "UTC",
"tasks.max": "1"
}

Accepted Answer

B

Explanation: The connector configuration explicitly sets "tasks.max": "1", which restricts the entire data ingestion process for all three tables (users, payment, orders) to a single thread (task). This creates a significant performance bottleneck, as one task must sequentially poll all tables. By increasing the tasks.max value (e.g., to 3), you allow Kafka Connect to create more tasks. The JDBC source connector can then parallelize the work, potentially assigning each table to a separate task. These tasks can run concurrently on the available worker nodes, significantly improving throughput and reducing the data lag.

Free Confluent CCAAK Actual Exam Questions