Practice Free CCDAK Confluent Certified Developer for Apache Kafka Certification Examination Exam Questions Answers With Explanation

The official CLI utility for consuming messages from Kafka topics is kafka-console-consumer.sh. It connects to the broker, consumes messages, and prints them to standard output.

From Kafka CLI Tools Documentation:

"kafka-console-consumer.sh is used to read data from a Kafka topic and write it to standard output."

The other options are not valid Kafka CLI tools.

1st: Place the connector's JAR file in the directory specified by plugin.path

2nd: Restart the Kafka Connect cluster

3rd: Verify using REST API (/connector-plugins)

4th: Configure the connector

5th: (Repeat of 4th, duplicate step)

1st ? Place the connector’s JAR file in the directory specified by the plugin.path configuration.

2nd ? Restart the Kafka Connect cluster.

3rd ? Verify that the connector is installed by listing all available connectors using the Kafka Connect REST API (/connector-plugins).

4th ? Configure the connector using a JSON or properties file with the necessary settings.

5th ? Configure the connector using a JSON or properties file with the necessary settings.

Kafka Connect requires that custom connectors be placed in the directory defined by plugin.path. After restarting the cluster, you can use the REST API to confirm availability and then deploy the connector configuration.

From Kafka Connect Documentation:

“After placing the JAR in the plugin.path, you must restart the Connect cluster to pick it up. Use the /connector-plugins REST endpoint to verify.”

The duplication of configuration is an error in the question options and should occur only once.

According to the official Apache Kafka Connect REST API documentation, restarting a connector can be done at different granularities: connector-level, task-level, or both. By default, calling POST /connectors/{name}/restart only restarts the connector instance, not its tasks.

To restart the connector and all of its tasks, the request must explicitly include the query parameter includeTasks=true. This instructs Kafka Connect to restart the connector and all associated tasks, regardless of whether they are currently running or failed.

Option B (onlyFailed=true) limits the restart to only failed tasks, which does not meet the requirement to restart all tasks. Option C restarts only the connector instance, leaving tasks untouched. Option D restarts a single specific task and does not restart the connector itself.

Therefore, the correct and officially documented REST request to restart the connector instance and all tasks is:

POST /connectors/s3-connector/restart?includeTasks=true

This ensures a full restart of the connector and its execution context across the Kafka Connect cluster.

max.poll.interval.ms defines the maximum delay between invocations of poll() before the consumer is considered failed. It essentially gives consumers more time to process records before needing to poll again.

From Kafka Consumer Configuration Reference:

“max.poll.interval.ms: The maximum delay between invocations of poll() when using consumer group management. If poll() is not called before expiration, the consumer is considered failed.”

session.timeout.ms and heartbeat.interval.ms relate to group coordination and heartbeats.

fetch.max.wait.ms affects how long the broker waits to accumulate data before sending a fetch response.

The Apache Kafka Streams documentation clearly distinguishes between the Kafka Streams DSL and the Processor API. While the DSL is designed for common stream processing operations such as filtering, mapping, joining, and aggregations, it does not support fully custom processing logic.

For use cases that require custom transformations, fine-grained control over record processing, access to headers, timestamps, state stores, and punctuation, Kafka Streams provides the Processor API. This API allows developers to implement custom Processor, Transformer, or ValueTransformer classes and explicitly define the processing topology.

Option A (TopologyTestDriver) is a testing utility, not a development API. Option C (DSL) is higher-level and not suitable for advanced custom logic. Option D does not exist in Kafka.

Therefore, the correct and officially supported approach for defining custom processors in Kafka Streams is to use the Processor API.

=========================

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.

Kafka clients use SLF4J as a logging facade. To redirect Kafka logs to log4j2, you must include the SLF4J binding for log4j2 in your classpath:

“org.apache.logging.log4j:log4j-slf4j-impl bridges SLF4J to Log4j2 so that Kafka's logs integrate into your application's Log4j2 configuration.”

Option A is for Log4j 1.x, which is outdated.

Option C is incorrect; Kafka clients don't include logging bindings.

Option D is insufficient without the SLF4J bridge.

Increasing tasks.max allows the connector to create multiple tasks, each responsible for processing different tables or table partitions. If only one task is used, adding more workers has no effect.

From Kafka Connect JDBC Connector Docs:

“Use tasks.max to configure how many tasks are created for the connector. Each task can process a subset of the data.”

A and C help only if the bottleneck is in Kafka, not Connect.

D is a large architectural change, not the first step.

This scenario describes vertical scaling, as defined in the Apache Kafka Streams documentation and general distributed systems terminology. Vertical scaling refers to adding more resources (CPU, memory, or disk) to a single machine to increase processing capacity.

In this example, the Kafka Streams application is moved from a server with four CPU threads to one with ten CPU threads, increasing the available compute resources without increasing the number of application instances. Kafka Streams can take advantage of additional CPU threads through its num.stream.threads configuration, allowing more partitions to be processed in parallel within the same application instance.

Horizontal scaling (also known as scaling out) would involve adding more application instances across multiple servers, not upgrading a single server. Option D is therefore incorrect, and Option C is not a recognized scaling term.

Thus, this example clearly illustrates vertical scaling, where performance is improved by increasing the capacity of a single node.

The Apache Kafka consumer configuration max.poll.records explicitly controls the maximum number of records returned in a single call to Consumer.poll(). This is clearly documented in the official Kafka consumer configuration reference. It allows developers to limit the size of the batch returned to the application, helping to control processing latency, memory usage, and CPU load.

This setting does not affect how much data the broker sends to the consumer; instead, it limits how many records the consumer returns to the application layer from the fetched data. This makes it especially useful for applications where processing each record is expensive and needs predictable batch sizes.

Option B (max.records.consumer) does not exist in Kafka. Option C (fetch.max.records) is also invalid; Kafka uses fetch.max.bytes and related byte-based configurations, not record-count limits, at the fetch level. Option D (max.poll.records.interval) is not a valid Kafka configuration; the correct related setting is max.poll.interval.ms, which controls liveness, not batch size.

Thus, max.poll.records is the correct and officially documented configuration.

C is true: When a new broker is added, no partitions are assigned to it unless you create new topics or reassign existing ones using kafka-reassign-partitions.sh.

D is true: Kafka brokers are hot-pluggable; no need to stop the cluster when scaling.

From Kafka Operations Guide:

“A newly added broker won’t be assigned partitions until reassignments or new topic creation.”

“Kafka allows dynamic scaling by adding brokers without downtime.”

A is false: Broker IDs must be manually set unless using dynamic broker registration in KRaft mode.

B is false unless the cluster uses KRaft mode and the broker is specifically assigned a controller role.

Session windows are ideal for tracking periods of activity separated by inactivity, such as user sessions.

From Kafka Streams Documentation > Windowing:

“A session window captures streams of events that are intermittent and separated by a gap of inactivity.”

Tumbling/Hopping/Sliding windows are fixed in size

Session windows are dynamic and close after inactivity timeout

This makes them perfect for identifying gaps in user interaction.

These three metrics are critical for cluster health:

OfflinePartitionsCount: Indicates partitions without active leaders — a sign of broker failure.

ActiveControllerCount: There should be exactly one active controller. A count ? 1 signals controller failure.

UncleanLeaderElectionsPerSec: Tracks leader elections where out-of-sync replicas were selected — risky for data loss.

From Kafka Monitoring Documentation:

“Offline partitions and unclean leader elections should trigger alerts. Also, ensure a single active controller is running.”

A is about topics pending deletion — not critical.

E is a per-topic record metric, not broker-level.

When using Kafka Connect with sink connectors (like S3 Sink), each task is assigned one or more topic partitions. The total number of partitions (6) is evenly distributed across the available tasks (2). Thus, each task will handle 3 partitions.

From Kafka Connect Documentation:

“Kafka Connect divides the topic partitions among available tasks. For example, a topic with six partitions and two tasks results in each task handling three partitions.”

For Kafka Streams to perform joins, topics must be co-partitioned, meaning:

They have the same number of partitions (A), and

They use the same partitioning strategy (typically by key) (B)

From Kafka Streams Documentation > Joins:

“Co-partitioning is required for Kafka Streams joins. Topics must have the same number of partitions and use the same key-based partitioner.”

Value schema (C) and retention time (D) have no bearing on join compatibility.

To ensure exactly-once delivery and avoid duplicates even during retries:

enable.idempotence=true ensures deduplication on the broker

retries=2147483647 allows unlimited retries on retriable errors

max.in.flight.requests.per.connection=5 is the maximum value that preserves message order with idempotence

From Kafka Producer Config Docs:

“To achieve exactly-once semantics, set enable.idempotence=true, and max.in.flight.requests.per.connection ? 5.”

A is unrelated (consumer-side)

C disables retries

D disables idempotence, leading to duplicates

Correct Matches

path.format?Only valid for some Source Connectors

value.converter?Valid for all Source Connectors

input.path?Only valid for some Source Connectors

errors.retry.timeout?Valid for all Source Connectors

tasks.max?Valid for all Source Connectors

path.formatThis is a connector-specific configuration, commonly used by file-based or storage-based source connectors (for example, HDFS, S3, or FilePulse connectors). It isnot part of the Kafka Connect framework itself, so it is only valid for some source connectors.

value.converterThis is aworker-level configurationthat defines how record values are converted (JSON, Avro, Protobuf, etc.). It applies toall connectorsrunning on the worker unless overridden at the connector level.

input.pathThis configuration is specific to file-based source connectors (e.g., FileStreamSourceConnector). It isnot universally supported, so it is only valid for some source connectors.

errors.retry.timeoutThis is part of Kafka Connect’serror handling framework, introduced to support retries and tolerance of transient errors. It is ageneric Connect configurationand valid for all connectors.

tasks.maxThis is amandatory, generic connector configurationthat controls the maximum number of tasks a connector may create. It is valid forall source (and sink) connectors.

According to the Apache Kafka Consumer API documentation, the assign() method allows a consumer to manually assign specific partitions to itself, bypassing Kafka’s consumer group coordination and rebalancing mechanism. When a consumer uses assign() with all partitions of a topic, that consumer will read from every partition, regardless of how many other consumers exist.

This behavior is required when every consumer instance must independently read the full dataset, such as in auditing, monitoring, or replication use cases. In contrast, subscribe() is designed for consumer group usage, where partitions are distributed among consumers, ensuring that each partition is consumed by only one consumer in the group.

Option B is invalid because assign() requires a collection of TopicPartition objects, not just a topic name. Option C still uses group coordination and does not guarantee all partitions per consumer. Option D is invalid because an empty group ID is not supported by Kafka.

Thus, explicitly calling assign() with all topic partitions is the only correct and documented way to ensure each consumer reads from all partitions.

The Kafka Streams DSL provides three primary abstractions:

KStream: Represents an unbounded stream of records (append-only).

KTable: Represents a changelog stream where each key has the latest value (like a materialized view).

GlobalKTable: A fully replicated version of KTable across all stream instances, enabling global joins.

From Kafka Streams Developer Guide:

“Kafka Streams provides three core abstractions: KStream, KTable, and GlobalKTable, each serving different purposes in stream processing and joins.”

GlobalKStream and StreamTable do not exist in Kafka’s API.

Table ? Product, Customers

Stream ? Orders_Placed, Shipment_Of_Orders

Tables represent slowly changing, reference data — e.g., customer profiles, product info.

Streams represent real-time event data — e.g., orders placed, shipments processed.

From Kafka Streams Documentation:

“Use KTable for reference datasets, and KStream for event-based processing such as orders or logs.”

If the application is CPU-bound and lagging, adding more consumers to the group will allow better parallel processing, especially since the topic has 4 partitions, allowing up to 4 active consumers.

From Kafka Consumer Group Docs:

“Kafka achieves parallelism by distributing partitions across consumers in a group. Adding consumers helps reduce lag if partitions are underutilized.”

B may help but requires repartitioning and coordination.

C or D affects how much data is polled, not how fast it’s processed.

The default maximum message size that a Kafka broker accepts is 1MB (1,048,576 bytes), controlled by the config property message.max.bytes.

From Kafka Broker Configuration Docs:

“The default maximum message size is 1MB. To accept larger messages, configure message.max.bytes and the producer’s max.request.size.”

Producers also have a matching limit via max.request.size, and consumers via fetch.message.max.bytes.