Best CCDAK Exam Dumps for the Preparation of Latest Exam Questions
CCDAK Actual Questions 100% Same Braindumps with Actual Exam!
NEW QUESTION # 40
(Which configuration is valid for deploying a JDBC Source Connector to read all rows from the orders table and write them to the dbl-orders topic?)
- A. {"name": "dbl-orders","connector.class": "io.confluent.connect.jdbc.DdbcSourceConnector","tasks.
max": "1","connection.url": "jdbc:mysql://mysql:3306/dbl?user=user&password=pas","topic.prefix":
"dbl-","table.blacklist": "ord*"} - B. {"name": "jdbc-source","connector.class": "io.confluent.connect.jdbc.DdbcSourceConnector","tasks.
max": "1","connection.url": "jdbc:mysql://mysql:3306/dbl?user=user&useAutoAuth=true","topic.
prefix": "dbl-","table.whitelist": "orders"} - C. {"name": "jdbc-source","connector.class": "io.confluent.connect.jdbc.JdbcSourceConnector","tasks.
max": "1","connection.url": "jdbc:mysql://mysql:3306/dbl?user=user&password=pas","topic.prefix":
"dbl-","table.whitelist": "orders"} - D. {"name": "orders-connect","connector.class": "io.confluent.connect.jdbc.DdbcSourceConnector","tasks.
max": "1","connection.url": "jdbc:mysql://mysql:3306/dbl","topic.whitelist": "orders","auto.create":
"true"}
Answer: C
Explanation:
According to the official Apache Kafka Connect and Confluent JDBC Source Connector documentation, the correct connector class for a JDBC source connector is io.confluent.connect.jdbc.JdbcSourceConnector. This connector is used to read data from relational databases and publish each table as a Kafka topic.
To read all rows from a specific table, the configuration must include table.whitelist (or table.include.list in newer versions) with the table name, and a topic.prefix to determine the Kafka topic name. In this case, using topic.prefix=dbl- with table.whitelist=orders results in records being written to the dbl-orders topic, which matches the requirement.
Options A, B, and C are invalid because they reference a non-existent connector class (DdbcSourceConnector), contain unsupported properties such as topic.whitelist for a source connector, or include malformed/incorrect JDBC parameters. Additionally, blacklisting tables does not ensure that only the orders table is read.
Therefore, option D is the only configuration that is syntactically correct, uses the proper connector class, and aligns with the official Kafka Connect JDBC Source Connector documentation.
NEW QUESTION # 41
(Your application consumes from a topic configured with a deserializer.
You want the application to be resilient to badly formatted records (poison pills).
You surround the poll() call with a try/catch block for RecordDeserializationException.
You need to log the bad record, skip it, and continue processing other records.
Which action should you take in the catch block?)
- A. Log the bad record and call consumer.skip() method.
- B. Throw a runtime exception to trigger a restart of the application.
- C. Log the bad record and seek the consumer to the offset of the next record.
- D. Log the bad record; no other action is needed.
Answer: C
Explanation:
The Apache Kafka consumer documentation explains that when a RecordDeserializationException occurs, the consumer cannot continue polling until the problematic offset is skipped. Simply logging the error is insufficient, because the consumer will repeatedly fail on the same record.
The recommended pattern is to log the malformed record, extract its topic, partition, and offset from the exception, and then call consumer.seek() to move the consumer position to the next offset (offset + 1). This allows the application to skip the poison pill and resume processing subsequent records.
Option B is invalid because Kafka does not provide a consumer.skip() API. Option C is unnecessary if the application is designed to tolerate malformed records. Option D results in an infinite failure loop.
Therefore, seeking past the bad record after logging it is the correct and officially documented way to handle poison pill records while maintaining consumer liveness and resilience.
NEW QUESTION # 42
Which is true about topic compaction?
- A. Compaction will keep exactly one message per key after compaction of inactive log segments.
- B. When a client produces a new event with an existing key, the old value is overwritten with the new value in the compacted log segment.
- C. Topic compaction does not remove old events; instead, when clients consume events from a compacted topic, they store events in a hashmap that maintains the latest value.
- D. When a client produces a new event with an existing key, the broker immediately deletes the offset of the existing event.
Answer: A
Explanation:
Log compactionensures that Kafka retains at least thelatest value per keyin a topic. Compaction happensin the backgroundand removes older records with the same keyin inactive log segments, not immediately.
From theKafka Documentation > Log Compaction:
"Kafka guarantees that thelast message for each keywill be retained in the log after compaction, even if earlier messages with the same key are deleted." So, D is correct. A is incorrect because compaction does not overwrite; it's a background process. B is incorrect-deletion is not immediate. C incorrectly suggests client-side hashmap behavior.
Reference:Apache Kafka Log Compaction Docs
NEW QUESTION # 43
You have a topic t1 in a Kafka cluster. A producer running on host A can successfully write messages to t1.
Then, you move that producer code to run on host B, but it fails writing messages to t1.
What is a likely reason for that failure?
- A. The producer is connecting to a different broker in the same cluster.
- B. Kafka ACLs are not configured to allow host B's IP address.
- C. Another producer started writing to t1.
- D. Topic T1 no longer exists in the same environment as host B.
Answer: B
NEW QUESTION # 44
(You create a topic with five partitions.
What can you assume about messages read from that topic by a single consumer group?)
- A. All messages will be read from exactly one broker by the consumer group.
- B. Messages can be consumed by a maximum of five consumers in the same consumer group.
- C. The consumer group can only read the same number of messages from all the partitions.
- D. Messages from one partition can be consumed by any of the consumers in a group for faster processing.
Answer: B
Explanation:
The Apache Kafka documentation explains that Kafka's parallelism model is based on topic partitions and consumer groups. Within a single consumer group, each partition can be assigned to at most one consumer at a time. As a result, the maximum level of parallelism for a consumer group is equal to the number of partitions in the topic.
In this scenario, the topic has five partitions, which means that up to five consumers in the same consumer group can actively consume data in parallel. If more than five consumers are added, the extra consumers will remain idle because there are no additional partitions to assign.
Option B is incorrect because Kafka does not enforce equal message consumption across partitions; message distribution depends on producers and partitioning strategy. Option C is false because partitions may be hosted on different brokers, and consumers fetch data from multiple brokers. Option D is incorrect because a single partition cannot be consumed by multiple consumers within the same group simultaneously.
Therefore, the only valid assumption is that a maximum of five consumers can actively consume messages in the same consumer group.
NEW QUESTION # 45
(You are configuring a source connector that writes records to an Orders topic.
You need to send some of the records to a different topic.
Which Single Message Transform (SMT) is best suited for this requirement?)
- A. InsertField
- B. RegexRouter
- C. HeaderFrom
- D. TombstoneHandler
Answer: B
Explanation:
According to the official Apache Kafka Connect documentation, RegexRouter is the SMT specifically designed to dynamically change the destination topic name of records produced by a connector. It works by applying a regular expression to the original topic name and rewriting it to a new topic name.
This makes RegexRouter the correct choice when some records must be routed to a different topic, typically in combination with connector-level logic, predicates, or multiple connectors. It is commonly used for topic renaming, topic versioning, or routing records to alternate topics.
InsertField (Option B) only adds metadata fields (such as topic, partition, or timestamp) to the record payload and does not affect routing. TombstoneHandler (Option C) is used to manage null-value records, especially with compacted topics. HeaderFrom (Option D) copies fields into headers but does not change the target topic.
Therefore, RegexRouter is the only SMT that directly supports changing the output topic, as documented in the Kafka Connect SMT reference.
NEW QUESTION # 46
What is a consequence of increasing the number of partitions in an existing Kafka topic?
- A. Records with the same key could be located in different partitions.
- B. Consumers will need to process data from more partitions which will significantly increase consumer lag.
- C. Existing data will be redistributed across the new number of partitions temporarily increasing cluster load.
- D. The acknowledgment process will increase latency for producers using acks=all.
Answer: B
Explanation:
Increasing partitions increases parallelism, but also means:
Consumers in a group may have to handle more partitions, especially if the number of consumers is lower than the number of partitions.
This can result in increased lag, especially under high load.
From Kafka 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 partition based on hash.
D is not directly impacted by the partition count.
Reference: Kafka Topic Management > Adding Partitions
NEW QUESTION # 47
What is not a valid authentication mechanism in Kafka?
- A. SASL/GSSAPI
- B. SAML
- C. SSL
- D. SASL/SCRAM
Answer: B
Explanation:
Learn more about security herehttps://kafka.apache.org/documentation/#security
NEW QUESTION # 48
To import data from external databases, I should use
- A. Kafka Streams
- B. Kafka Connect Source
- C. Confluent REST Proxy
- D. Kafka Connect Sink
Answer: B
Explanation:
Kafka Connect Sink is used to export data from Kafka to external databases and Kafka Connect Source is used to import from external databases into Kafka.
NEW QUESTION # 49
If you enable an SSL endpoint in Kafka, what feature of Kafka will be lost?
- A. Exactly-once delivery
- B. Cross-cluster mirroring
- C. Support for Avro format
- D. Zero copy
Answer: D
Explanation:
With SSL, messages will need to be encrypted and decrypted, by being first loaded into the JVM, so you lose the zero copy optimization. See more information herehttps://twitter.com/ijuma/status/1161303431501324293?s=09
NEW QUESTION # 50
Select all that applies (select THREE)
- A. min.insync.replicas is a producer setting
- B. acks is a producer setting
- C. min.insync.replicas matters regardless of the values of acks
- D. acks is a topic setting
- E. min.insync.replicas is a topic setting
- F. min.insync.replicas only matters if acks=all
Answer: B,E,F
Explanation:
acks is a producer setting min.insync.replicas is a topic or broker setting and is only effective when acks=all
NEW QUESTION # 51
Compaction is enabled for a topic in Kafka by setting log.cleanup.policy=compact. What is true about log compaction?
- A. Each message stored in the topic is compressed
- B. After cleanup, only one message per key is retained with the latest value
- C. After cleanup, only one message per key is retained with the first value
- D. Kafka automatically de-duplicates incoming messages based on key hashes
Answer: B
Explanation:
Compaction changes the offset of messages
Explanation:
Log compaction retains at least the last known value for each record key for a single topic partition. All compacted log offsets remain valid, even if record at offset has been compacted away as a consumer will get the next highest offset.
NEW QUESTION # 52
What is the function of Kafka Connect Converters?
- A. Isolate the producer and consumer work from the source and sink connectors.
- B. Convert data from the structure used by the source system to the standard Connect structure.
- C. Serialize data written to and deserialize data read from Kafka topics.
- D. Make simple updates to data as it is written to and read from Kafka topics.
Answer: C
NEW QUESTION # 53
An application is writing AVRO messages using Schema Registry to topic t1. During this process, the Schema Registry becomes unavailable for a few seconds.
What is the expected impact to the application?
- A. Since the broker will eventually replicate the message Schema, there will not be an error.
- B. All messages within that time will receive an error.
- C. Since messages are cached by the producer, the application will only get an error if the producer is sending the batch at that time.
- D. The application may not have any impact, unless it is writing messages with a new Schema Definition.
Answer: D
NEW QUESTION # 54
There are 3 producers writing to a topic with 5 partitions. There are 5 consumers consuming from the topic.
How many Controllers will be present in the cluster?
- A. 0
- B. 1
- C. 2
- D. 3
Answer: A
Explanation:
There is only one controller in a cluster at all times.
NEW QUESTION # 55
(A stream processing application tracks user activity in online shopping carts, including items added, removed, and ordered throughout the day for each user.
You need to capture data to identify possible periods of user inactivity.
Which type of Kafka Streams window should you use?)
- A. Sliding
- B. Tumbling
- C. Session
- D. Hopping
Answer: C
Explanation:
According to the official Apache Kafka Streams documentation, session windows are specifically designed to model periods of activity separated by gaps of inactivity. A session window groups events that occur close together in time and closes when no new events arrive within a defined inactivity gap.
In this use case, tracking user shopping cart behavior requires detecting when a user becomes inactive (for example, stops adding or removing items). Session windows naturally represent this pattern by creating a new window when activity resumes after a period of silence. This makes them ideal for modeling user sessions, cart abandonment detection, and inactivity analysis.
Hopping and tumbling windows (Options B and C) are fixed-time windows and are not well-suited for detecting inactivity, as they segment data based on clock time rather than behavior. Sliding windows are primarily used for continuous joins and do not explicitly model inactivity gaps.
Therefore, session windows are the correct and officially recommended choice for identifying periods of user inactivity in Kafka Streams applications.
NEW QUESTION # 56
(What are two stateless operations in the Kafka Streams API?
Select two.)
- A. Filter
- B. Join
- C. Reduce
- D. GroupBy
Answer: A,D
Explanation:
In the Kafka Streams API, operations are classified as stateless or stateful based on whether they require maintaining local state stores. According to the official Kafka Streams documentation, stateless operations process each record independently, without storing or accessing prior records.
Filter is a stateless operation because it evaluates each record individually and decides whether to pass it downstream. It does not require any state or historical context.
GroupBy is also considered stateless because it merely repartitions the stream by assigning a new key and forwarding records to downstream processors. While it triggers the creation of an internal repartition topic, the GroupBy operation itself does not maintain a state store.
In contrast, Reduce is a stateful operation because it aggregates records over time and requires maintaining intermediate results in a state store. Similarly, Join operations are stateful because Kafka Streams must buffer and store records from one or both input streams or tables to perform the join within a defined time window.
Thus, the correct stateless operations are Filter and GroupBy, as documented in the Kafka Streams developer guide.
NEW QUESTION # 57
Which two producer exceptions are examples of the class RetriableException? (Select two.)
- A. RecordTooLargeException
- B. AuthorizationException
- C. LeaderNotAvailableException
- D. NotEnoughReplicasException
Answer: C,D
Explanation:
RetriableException is a subclass of KafkaException, indicating transient issues that might 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 the Apache Kafka Java Client documentation:
"These exceptions (like LeaderNotAvailableException, NotEnoughReplicasException) are transient and the client will retry them automatically depending on retry configuration." RecordTooLargeException and AuthorizationException are non-retriable as they indicate client-side or permission errors.
Reference: Apache Kafka Java Client API > org.apache.kafka.common.errors
NEW QUESTION # 58
......
CCDAK Study Material, Preparation Guide and PDF Download: https://www.getvalidtest.com/CCDAK-exam.html
Free CCDAK Certification Sample Questions with Online Practice Test: https://drive.google.com/open?id=1dpmeZ5Ex1vx4RCkya3bWOeonOe5VVgUT