View Full Confluent CCDAK Exam Dumps and Practice Test Dumps

 

Question 141

Which Kafka Streams abstraction represents an unbounded stream of records?

1. KTable
2. KStream
3. GlobalKTable
4. StateStore

Correct Answer: 2

Explanation:

A KStream represents an unbounded, continuously arriving stream of records in Kafka Streams. Each record is treated as an independent event, making KStream suitable for event-processing operations such as filtering, mapping, transforming, and joining. Unlike a KTable, which represents the latest state associated with keys, a KStream models the sequence of events themselves. Applications commonly use KStream when processing transaction events, user activities, sensor readings, or other continuously generated data. Understanding the distinction between KStream and table abstractions is fundamental when designing Kafka Streams topologies.

Question 142

Which Kafka Streams abstraction represents the latest value for each key?

1. KStream
2. GlobalKTable
3. KTable
4. ProcessorContext

Correct Answer: 3

Explanation:

A KTable represents a changelog stream interpreted as the latest value associated with each key. When a new record arrives for an existing key, it updates the corresponding table entry. This makes KTable useful for representing current state, such as customer profiles, account balances, or product information. KTable processing can also propagate updates and deletions downstream. Unlike a KStream, where each event is independently represented, a KTable emphasizes the current state derived from a sequence of records. This distinction is important when designing stateful Kafka Streams applications.

Question 143

Which Kafka Streams abstraction replicates a complete table to each application instance?

1. GlobalKTable
2. KStream
3. WindowStore
4. KeyValueStore

Correct Answer: 1

Explanation:

A GlobalKTable maintains a complete copy of its underlying table on every Kafka Streams application instance. This differs from an ordinary KTable, where partitions of state are distributed among application instances. GlobalKTable can be useful when applications need to perform lookups against a relatively small reference dataset without repartitioning the incoming stream. Because every instance maintains the entire table, storage and update traffic must be considered when choosing this abstraction. GlobalKTable is particularly useful for enriching event streams with reference information that changes over time.

Question 144

What Kafka Streams component stores local state used by processing operations?

1. StreamPartition
2. QueryRegistry
3. RecordCache
4. StateStore

Correct Answer: 4

Explanation:

A Kafka Streams StateStore provides local storage for stateful stream-processing operations. State stores can maintain information needed for aggregations, joins, counts, and other processing tasks. Kafka Streams can back state stores with changelog topics so state can be restored after an application instance restarts or moves to another host. Different store types support different access patterns, including key-value and windowed data. State stores therefore provide an important bridge between continuously processed records and durable application state.

Question 145

What Kafka Streams topic is created to redistribute records by key?

1. Source topic
2. Repartition topic
3. Audit topic
4. Snapshot topic

Correct Answer: 2

Explanation:

A Kafka Streams repartition topic is used when records must be redistributed according to a new key before a downstream operation. Certain operations, especially joins and aggregations, require records with matching keys to reside in the same partition. Kafka Streams can automatically create an internal repartition topic to accomplish this redistribution. Records are written to the repartition topic and then consumed according to the new partitioning. Repartitioning can introduce additional network, storage, and processing overhead, so understanding when it occurs is important for performance-oriented topology design.

Question 146

Which topic preserves updates needed to rebuild a Kafka Streams state store?

1. Changelog topic
2. Metrics topic
3. Request topic
4. Notification topic

Correct Answer: 1

Explanation:

A Kafka Streams changelog topic records updates associated with a state store so the local state can be reconstructed when necessary. If an application instance fails or its state is moved to another instance, Kafka Streams can replay the changelog to restore the state store. This mechanism provides durability for local processing state without requiring the application to reconstruct everything from its original source data. Changelog topics are therefore an important part of Kafka Streams fault tolerance, particularly for stateful processing and recovery scenarios.

Question 147

Which Kafka Streams setting controls how long processed results remain cached?

1. state.cache.expiration
2. streams.cache.timeout
3. cache.max.age
4. cache.max.bytes.buffering

Correct Answer: 4

Explanation:

The Kafka Streams cache.max.bytes.buffering setting controls the maximum amount of memory allocated for record caching across a Streams application. Caching can reduce downstream traffic by combining or suppressing intermediate updates before forwarding results. The cache is particularly useful for aggregation workloads that generate many successive updates for the same keys. The configured value affects memory consumption and processing behavior, so it should be considered alongside application workload and available resources. Caching does not replace durable state storage; it is an optimization layer used during stream processing.

Question 148

Which processing guarantee targets exactly-once behavior in Kafka Streams?

1. processing.guarantee=at_least_once
2. processing.guarantee=best_effort
3. processing.guarantee=exactly_once_v2
4. processing.guarantee=single_delivery

Correct Answer: 3

Explanation:

The Kafka Streams setting processing.guarantee=exactly_once_v2 enables exactly-once processing semantics using the modern Kafka Streams implementation. Under the appropriate configuration, Kafka Streams coordinates processing and output writes so that successfully committed results are not duplicated as a consequence of normal retries or failures. Exactly-once processing is useful for applications where duplicate downstream effects would be undesirable, such as financial calculations or stateful transformations. It does introduce additional coordination and transactional overhead, so the processing guarantee should be selected according to application requirements.

Question 149

Which window type groups records into fixed, non-overlapping intervals?

1. Tumbling window
2. Session window
3. Sliding interval
4. Dynamic window

Correct Answer: 1

Explanation:

A tumbling window divides records into fixed-duration intervals that do not overlap. For example, a five-minute tumbling window groups events into consecutive five-minute periods. Each event belongs to the interval determined by its timestamp and the configured window boundaries. Tumbling windows are useful for periodic calculations such as counting transactions every five minutes or measuring traffic per fixed interval. Unlike hopping windows, they do not overlap, and unlike session windows, they do not depend on periods of user activity or inactivity.

Question 150

Which Kafka Streams window type is based on periods of activity and inactivity?

1. Fixed window
2. Session window
3. Calendar window
4. Batch window

Correct Answer: 2

Explanation:

A session window groups records according to periods of activity separated by inactivity gaps. Instead of using fixed boundaries, Kafka Streams creates sessions based on configured inactivity periods. This makes session windows useful for modeling user sessions, application interactions, or bursts of activity where events naturally cluster together. New events arriving within the session gap can extend or merge sessions. Because session boundaries depend on observed activity, the resulting windows can have different lengths. This makes them different from fixed-duration tumbling or hopping windows.

Question 151

Which Kafka Streams window type produces overlapping fixed-size intervals?

1. Tumbling
2. Session
3. Hopping
4. Session-gap

Correct Answer: 3

Explanation:

A hopping window uses a fixed window size together with a smaller advance interval, allowing consecutive windows to overlap. For example, an application could calculate a ten-minute window every five minutes, causing each event to appear in multiple applicable windows. Hopping windows are useful when applications need rolling measurements while retaining predictable time boundaries. They differ from tumbling windows because tumbling intervals do not overlap. They also differ from session windows, which are based on activity gaps rather than predetermined time intervals.

Question 152

What Kafka Streams concept represents the timestamp used to advance event processing?

1. Stream-time
2. Wall-clock mode
3. Partition-clock
4. Commit-time

Correct Answer: 1

Explanation:

Stream-time in Kafka Streams advances based on the timestamps of records being processed. It is particularly important for windowed operations because Kafka Streams uses stream-time to determine when certain windows can progress and when records are considered sufficiently late according to the application’s configuration. Stream-time differs from wall-clock time because it is driven by event timestamps rather than the system clock. This makes stream-time useful for event-processing applications where the timing of records in the data itself is more meaningful than the machine’s current time.

Question 153

What Kafka Streams setting defines an allowed period for late records?

1. lateness.interval
2. event.delay.limit
3. grace period
4. window.wait.time

Correct Answer: 3

Explanation:

A window’s grace period defines how long Kafka Streams can continue accepting records that arrive after the nominal end of a window. This accommodates events that are delayed because of network conditions, upstream processing, or other factors. Choosing an appropriate grace period requires understanding the expected lateness of the application’s data. A value that is too short may cause valid late events to be excluded, while an excessively long value can delay finalization of results. Grace periods are therefore an important consideration in event-time window processing.

Question 154

Which Kafka Streams feature allows applications to expose interactive state queries?

1. RecordForwarder
2. Interactive Queries
3. Stream Inspector
4. Query Connector

Correct Answer: 2

Explanation:

Kafka Streams Interactive Queries allow an application to expose locally maintained state stores for querying. This can enable applications or services to retrieve information derived from stream processing without rebuilding that state from the original Kafka topics. Interactive Queries are particularly useful for applications that maintain aggregates, materialized views, or other continuously updated state. The querying architecture must account for which application instance owns the relevant partitioned state. Therefore, applications often need metadata about state-store ownership before routing a query to the correct instance.

Question 155

Which Kafka Connect setting limits concurrent task execution for a connector?

1. tasks.max
2. connector.task.limit
3. parallel.tasks
4. task.count.maximum

Correct Answer: 1

Explanation:

The tasks.max setting specifies the maximum number of tasks that Kafka Connect can assign to a connector. A connector may use fewer tasks if its implementation or workload does not support greater parallelism. Increasing this setting can improve throughput when the connector can divide work effectively, but it can also increase resource consumption on Connect workers and external systems. Task parallelism should therefore be chosen based on connector capabilities, source or destination capacity, and workload characteristics rather than simply selecting the largest possible value.

Question 156

Which Kafka Connect setting enables tolerance of record-processing errors?

1. errors.ignore.mode
2. errors.tolerance
3. failures.continue
4. record.error.policy

Correct Answer: 2

Explanation:

The Kafka Connect errors.tolerance setting controls how a connector responds to errors encountered while processing records. A common configuration allows errors to be tolerated so that processing can continue rather than immediately stopping the connector. This capability is especially useful when individual records may contain malformed or incompatible data. Error handling can be combined with logging and dead-letter queue features to preserve information about failed records for later investigation. Administrators should configure error tolerance carefully because silently skipping problematic records can result in incomplete destination data.

Question 157

Which Kafka Connect feature records failed records for later investigation?

1. Connector snapshot
2. Retry ledger
3. Dead Letter Queue
4. Error checkpoint

Correct Answer: 3

Explanation:

A Kafka Connect Dead Letter Queue, or DLQ, provides a destination for records that fail processing when the connector is configured for appropriate error handling. Instead of allowing a problematic record to halt processing or disappear without trace, the failed record can be routed to a dedicated Kafka topic. Operations teams can then inspect the record, determine the cause, and potentially correct or replay it. DLQs are particularly useful for handling malformed data, conversion problems, or destination-specific record failures while allowing the main connector workload to continue.

Question 158

Which Kafka Connect component converts records between Kafka and connector data formats?

1. Converter
2. Task scheduler
3. Worker coordinator
4. Offset manager

Correct Answer: 4

Explanation:

Kafka Connect converters translate data between Kafka’s serialized record representation and the data representation expected by connectors. Common converter choices include JSON, Avro, and Protobuf-based implementations. Source connectors use converters when producing records into Kafka, while sink connectors use converters when consuming records from Kafka. Converter configuration is therefore important for ensuring that keys, values, and schemas are interpreted correctly across the connector pipeline. A mismatch between converter configuration and actual record serialization can cause processing or deserialization failures.

Question 159

Which Kafka Connect API manages connector configurations and lifecycle operations?

1. Worker protocol
2. Connector REST API
3. Task metadata API
4. Record management API

Correct Answer: 2

Explanation:

Kafka Connect provides a REST API for managing connectors and their configurations. Administrators can use this interface to create connectors, inspect configurations, update settings, pause or resume processing, and retrieve connector or task status. In distributed mode, requests can be sent to Connect workers, which coordinate connector and task execution across the worker cluster. The REST interface is therefore an important operational mechanism for managing connector deployments without manually modifying worker processes or local configuration files.

Question 160

Which Kafka Connect mode distributes connector tasks across multiple workers?

1. Standalone mode
2. Local execution
3. Embedded mode
4. Distributed mode

Correct Answer: 4

Explanation:

Kafka Connect distributed mode allows connectors and their tasks to be distributed across multiple Connect workers. The workers coordinate connector assignments, task execution, configuration state, and offsets through Kafka-backed internal topics. This architecture provides greater scalability and fault tolerance than standalone mode, where connectors run within a single worker process. Distributed mode is commonly used for production deployments because workloads can be spread across workers and reassigned when worker membership changes. Proper internal-topic configuration is important for reliable distributed Connect operation.