CCDAK Confluent Certified Developer for Apache Kafka Certification Examination Question and Answers

For real-time applications, thekey metric to monitor is consumer lag— the difference between thelatest offset on the brokerand thelast committed offset by the consumer.

FromKafka Monitoring Guide:

“Consumer lag is the most important metric for real-time applications. It tells you how far behind the consumer is from the latest data in Kafka.”

B relates to replication, not client responsiveness.

C tracks group membership stability, not data delay.

D tracks input throughput, not processing latency.

This syntax is a clear match toProtocol Buffers (Protobuf). It defines a schema with fields, types, and tags, which is a format supported by Kafka when usingProtobuf-based schema registry serialization.

FromConfluent Schema Registry Docs:

“Kafka supports Protobuf serialization, where schemas are written in .proto files and include fields with tags.”

int32, double, and string are standard Protobuf types.

Avro uses JSON-style schema.

JSON Schema uses JSON object structure, not .proto.

YAML is unrelated.

TheStickyAssignortries to minimize partition movement bypreserving existing assignmentsas much as possible while still achieving a balanced assignment. This improvesconsumer stabilityand reduces rebalances.

From theKafka Consumer Assignor Documentation:

“The StickyAssignor attempts topreserve as many existing assignments as possible, which helps minimize partition movement between rebalances.”

RoundRobinAssignor focuses on even distribution, not stability.

RangeAssignor groups partitions by topic and assigns them consecutively, but can lead to imbalances.

PartitionAssignor is an abstract base class, not an assignor used directly.

To increase consumerthroughput, one effective strategy is toincrease the amount of datafetched in each poll by raisingfetch.max.bytesormax.partition.fetch.bytes. This allows each poll to retrieve more records per request, improving processing efficiency.

FromKafka Consumer Config Docs:

“Increasing fetch size allows consumers to retrieve larger batches of messages, improving throughput and reducing request overhead.”

Removing consumers (A) may reduce parallelism.

Manual commit (C) adds complexity, not throughput.

Decreasing session timeout (D) risks unnecessary rebalances.

Comprehensive and Detailed Explanation From Exact Extract:

✅C. Consumers can consume both committed and uncommitted transactions.By default,Kafka consumers only read committed messagesif they are configured with isolation.level=read_committed. However, if configured as read_uncommitted, theycan also consume uncommitted (potentially aborted) transactional messages.

From Kafka Documentation:

"The isolation.level setting controls whether the consumer will read only committed messages or all messages, including uncommitted messages from ongoing or aborted transactions."

✅D. Information about producers and their transactions is stored in the _transaction_state topic.Kafka uses an internal topic named__transaction_stateto maintain metadata about producer transactions. This topic is essential for tracking thetransaction lifecycle, fencing, and recovery.

From Kafka Internals:

“Kafka stores the state of active and completed transactions in an internal topic called __transaction_state.”

TheKafka Streams DSLprovides 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.

FromKafka 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 donot existin Kafka’s API.

max.poll.interval.ms defines themaximum 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.

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

These three metrics are critical for cluster health:

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

ActiveControllerCount: There should beexactly one active controller. A count ≠ 1 signals controller failure.

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

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

Kafka Connect can run instandalone modeordistributed mode. For simple tasks likereading logs from a file on a single host,standalone modeis recommended.

FromKafka Connect User Guide:

“Standalone mode is useful when running connectors on a single machine (e.g., for development or simple deployments like log collection from a local file).”

Distributed mode is preferred for scalability and fault tolerance but overkill for this use case.

Kafkamessage headersare the right place to includemetadatasuch as:

Payload format (e.g., schema version)

Timestamps (custom)

Trace or correlation IDs

FromKafka Producer API Docs:

“Headers are a map of key-value pairs that can be used to include metadata alongside the message, without modifying the message body.”

Keys determine partitioning and ordering

Values are the message payload

Brokers do not store arbitrary metadata fields

C is true: When a new broker is added,no partitions are assigned to itunless you create new topics orreassign existing onesusing kafka-reassign-partitions.sh.

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

FromKafka 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 bemanually setunless using dynamic broker registration in KRaft mode.

B is false unless the cluster usesKRaft modeand the broker isspecifically assigneda controller role.

Table→ Product, Customers

Stream→ Orders_Placed, Shipment_Of_Orders

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

Streamsrepresentreal-time event data— e.g., orders placed, shipments processed.

FromKafka Streams Documentation:

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

To change the replication factor of an existing topic, you must perform apartition reassignment, because the replication factor is not directly modifiable via kafka-topics.sh. Thekafka-reassign-partitions.shtool is the official command-line utility to handle partition reassignments, including changing the replication factor.

This tool allows you to generate a reassignment JSON specifying new replica assignments per partition and then apply it.

From official documentation:

“To change the replication factor, use the kafka-reassign-partitions tool to assign the partitions to more or fewer brokers.”

Neither kafka-topics.sh nor kafka-reassign-topics.sh exists for this purpose, and kafka-recreate-topic.sh isnotan official Kafka tool.

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.

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

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

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