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

The onCompletion() method of Kafka’sCallback interfaceis executedonce the broker acknowledgesthe message. This includes success or failure, and it isinvoked asynchronouslyby the producer.

FromKafka Java Client API Documentation:

“The onCompletion method will be called when the record sent to the server has been acknowledged, or when an error occurs.”

This ensures thatthe record was sent and acknowledged, not just added to a batch or local buffer.

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.

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.

Kafka Streams usestransactional producersto guaranteeexactly-once semantics (EOS). This ensures that both theoutput recordsandstate store updatesare committed atomically, avoiding duplication or partial writes.

FromKafka Streams Documentation > Processing Guarantees:

“Kafka Streams leveragesKafka’s transactional APIsto commit the output records and internal state updatesas a single atomic unit, thereby providing exactly-once semantics.”

Option A is incorrect because log compaction is not disabled for EOS.

Option C incorrectly describes a checkpointing system Kafka Streams does not use.

Option D refers to deduplication, which is not how EOS is achieved in Streams.

ForSASL/PLAIN authentication over SSL, the correct combination is:

security.protocol=SASL_SSL

sasl.jaas.config=...PlainLoginModule required username=... password=...

FromKafka Security Documentation:

“For SASL/PLAIN over SSL, configure security.protocol=SASL_SSL and provide login module configuration using sasl.jaas.config.”

Options B and D are incorrect because they do not pair the correct protocol with the authentication method.

Session windowsare ideal for trackingperiods of activity separated by inactivity, such as user sessions.

FromKafka Streams Documentation > Windowing:

“A session window captures streams of events that areintermittentand separated by agap of inactivity.”

Tumbling/Hopping/Sliding windows are fixed in size

Session windows are dynamic and close after inactivity timeout

This makes them perfect for identifyinggaps in user interaction.

With acks=all and min.insync.replicas=2, Kafka requiresat least two in-sync replicasto acknowledge a write. If onlyone broker is alive, the condition fails, andNotEnoughReplicasExceptionis thrown by the producer.

FromKafka Producer Exception Docs:

“NotEnoughReplicasException is thrown when the number of in-sync replicas is insufficient to satisfy acks=all with min.insync.replicas.”

NetworkException is generic and not raised here.

NotCoordinatorException is related to consumer group coordination.

NotLeaderForPartitionException is unrelated unless accessing an unassigned leader.

If a key isnot specified, thedefault Kafka partitioner uses round-robinlogic to assign partitions. This leads toeven distributionof messages across all partitions.

FromKafka Producer Design:

“If the key is null, the producer will assign the partition in a round-robin fashion to achieve load balancing.”

There isno error, and partition 0 isnot alwayschosen in this case.

The bootstrap.servers setting is used by clients (producers and consumers) toinitially connectto the Kafka cluster. It does not need to list all brokers—just a few that are up and reachable. The client will then use the cluster metadata to discover the full broker list.

FromKafka Java Client Configuration Docs:

“This is a list of host/port pairs to use for establishing the initial connection to the Kafka cluster. The client will make use of all servers irrespective of which servers are specified here for bootstrapping.”

Hence,listing multiple brokers provides redundancyand fault tolerance in the event one is down during client startup.

For proper delivery handling with acks=all:

Usecallbackto log or act on success/failure.

Usetry/catchto handle synchronous exceptions like serialization errors or network failures.

FromKafka Producer Documentation:

“Errors can be caught either via the returned Future or via the callback interface. For fatal errors, use a try/catch block around the send call.”

Option B is incorrect because send() returns a Future, not RecordMetadata directly.

Option D is invalid — ProducerRecord has no method called status().

fetch-rate: Measures how frequently consumers fetch data — critical for monitoring throughput.

incoming-byte-rate: Shows how much data is being written to the broker per second — a keyproducer-side metric.

FromKafka JMX Metrics Guide:

“fetch-rate, incoming-byte-rate, request-latency are key performance metrics for producers and consumers.”

B, C, E, and F areapplication-layer business metrics, not Kafka performance metrics.

Kafka producers can group messages destined fordifferent partitionsintoseparate batches, and sendmultiple batches in one requestto optimize network usage.

FromKafka Producer Internals:

“The producer maintains buffers (batches) for each partition and can send multiple of these batches together in a single request to the broker.”

Message size is not a constraint for batching (A is false).

Broker failures don’t disable batching (B is false).

There isno separate thread per batch(C is false).

Thebatch.sizeconfig sets themaximum number of bytes to batch per partitionbefore sending. This allows Kafka producers toamortize I/Oand improve throughput.

FromKafka Producer Configuration Docs:

“batch.size is the maximum amount of data per partition the producer will batch before sending.”

buffer.memory sets total memory for the producer, not per-batch.

send.buffer.bytes is aTCP socket buffer, not a Kafka config.

max.block.ms controls blocking time, not size.

BothLeaderNotAvailableExceptionandNotEnoughReplicasExceptionare subclasses of RetriableException, which representstransient issuesthat may succeed upon retry.

FromApache Kafka Java Client Documentation:

“RetriableException indicates that the request can be retried. This includes network errors and certain broker-side failures like leader not available or not enough replicas.”

RecordTooLargeException and AuthorizationException arenon-retriablebecause they represent client misconfigurations or access issues.

To isolate logs for a specific connector, you can configurea separate logger and appenderin theConnect worker’s log4j.propertiesfile, using the connector’s name as the logging context.

FromKafka Connect Logging Docs:

“Kafka Connect loggers use hierarchical logger names. You can configure per-connector log levels and output files by extending log4j.properties.”

A and C change verbosity but don’t separate logs.

D is false; targeted logging is possible.