State stores in Kafka - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a state store in Kafka Streams?

A state store is a local database that Kafka Streams uses to keep track of data and state during stream processing. It helps remember information between events.

beginner

Name two types of state stores in Kafka Streams.

The two main types are:
1. KeyValueStore - stores key-value pairs.
2. WindowStore - stores data with time windows.

intermediate

How does Kafka Streams keep state stores fault-tolerant?

Kafka Streams backs up state stores by writing changes to a special Kafka topic called a changelog. If the app crashes, it can restore the state from this topic.

intermediate

What is the role of ProcessorContext in accessing state stores?

ProcessorContext provides access to state stores inside a processor. It lets you read and write data to the store during processing.

intermediate

Why use state stores instead of external databases in Kafka Streams?

State stores are local and fast, tightly integrated with Kafka Streams. They reduce latency and simplify managing state compared to external databases.

What does a Kafka Streams state store primarily do?

A Manages user authentication

B Sends messages to Kafka topics

C Stores and manages local state for stream processing

D Creates new Kafka topics

State stores keep local data needed to process streams, like counts or aggregates.

Which Kafka topic type is used to back up state stores for fault tolerance?

A Changelog topic

B Input topic

C Output topic

D Control topic

Changelog topics store all changes to state stores to restore state after failure.

Which interface lets you access state stores inside a Kafka Streams processor?

A StreamBuilder

B KafkaProducer

C KafkaConsumer

D ProcessorContext

ProcessorContext provides methods to access state stores during processing.

What type of state store would you use to keep data grouped by time intervals?

A WindowStore

B KeyValueStore

C SessionStore

D TimestampStore

WindowStore stores data with time windows, useful for time-based aggregations.

Why are state stores preferred over external databases in Kafka Streams?

A They require no configuration

B They are local and faster for stream processing

C They automatically scale Kafka clusters

D They replace Kafka topics

Local state stores reduce latency and simplify state management compared to external databases.

Explain what a state store is and why it is important in Kafka Streams.

Think about how Kafka Streams remembers information between events.

Describe how Kafka Streams ensures state stores are fault-tolerant and can recover after a crash.

Consider how changes to the state are saved and replayed.

Practice

1. What is the main purpose of a state store in Kafka Streams?

easy

A. To monitor Kafka cluster health

B. To send messages to Kafka topics

C. To configure Kafka brokers

D. To keep data between processing of different messages

Solution

1. Step 1: Understand state store role and compare options

   A state store holds data locally so the app can remember information across messages. Sending messages, configuring brokers, and monitoring health are unrelated to state stores.

2. Final Answer:

   To keep data between processing of different messages -> Option D

3. Quick Check:

   State store = remembers data between messages [OK]

Hint: State stores remember data across messages [OK]

Common Mistakes:

• Confusing state store with message sending
• Thinking state store configures Kafka brokers
• Assuming state store monitors cluster health

2. Which of the following is the correct way to add a persistent key-value state store named myStore to a StreamsBuilder in Kafka Streams?

easy

A. builder.addStateStore(Stores.keyValueStoreBuilder(Stores.persistentKeyValueStore("myStore"), Serdes.String(), Serdes.String()))

B. builder.addStore("myStore", persistentKeyValueStore())

C. builder.createStateStore("myStore", KeyValueStore.class)

D. builder.addKeyValueStore("myStore", Serdes.String(), Serdes.String())

Solution

1. Step 1: Recall correct syntax for adding state store and check options

   The correct method uses addStateStore with a store builder from Stores.keyValueStoreBuilder and Stores.persistentKeyValueStore. Only builder.addStateStore(Stores.keyValueStoreBuilder(Stores.persistentKeyValueStore("myStore"), Serdes.String(), Serdes.String())) matches the correct method signature and usage.

2. Final Answer:

   builder.addStateStore(Stores.keyValueStoreBuilder(Stores.persistentKeyValueStore("myStore"), Serdes.String(), Serdes.String())) -> Option A

3. Quick Check:

   Use addStateStore with keyValueStoreBuilder [OK]

Hint: Use addStateStore with keyValueStoreBuilder [OK]

Common Mistakes:

• Using incorrect method names like addStore or createStateStore
• Missing Serdes parameters for key and value
• Confusing persistent and in-memory store creation

3. Given the following Kafka Streams processor code snippet, what will be the output stored in the state store after processing the input key-value pairs ("key1", 1) and ("key1", 2)?

KeyValueStore<String, Integer> store = context.getStateStore("countStore");
Integer current = store.get("key1");
if (current == null) current = 0;
store.put("key1", current + value);

medium

A. The state store will have key "key1" with value 1

B. The state store will have key "key1" with value 2

C. The state store will have key "key1" with value 3

D. The state store will be empty

Solution

1. Step 1: Trace code execution for both inputs

   First ("key1", 1): store.get("key1") returns null, current = 0, store.put("key1", 0 + 1) = 1. Second ("key1", 2): store.get("key1") = 1, current = 1, store.put("key1", 1 + 2) = 3.

2. Final Answer:

   The state store will have key "key1" with value 3 -> Option C

3. Quick Check:

   Sum values for key1 = 3 [OK]

Hint: Add new value to existing store value for same key [OK]

Common Mistakes:

• Assuming store resets between messages
• Not handling null initial value
• Overwriting instead of adding values

4. Identify the error in this Kafka Streams processor code that tries to update a state store named myStore:

KeyValueStore<String, Long> store = context.getStateStore("myStore");
Long count = store.get(key);
count += 1L;
store.put(key, count);

medium

A. The getStateStore method is called incorrectly

B. The variable count may be null causing a NullPointerException

C. The put method should be called before incrementing count

D. The store should be cast to ReadOnlyKeyValueStore

Solution

1. Step 1: Check store.get(key) handling and increment operation

   If the key does not exist, store.get(key) returns null, so count is null. Trying to do count += 1L when count is null causes a NullPointerException.

2. Final Answer:

   The variable count may be null causing a NullPointerException -> Option B

3. Quick Check:

   Null check needed before incrementing count [OK]

Hint: Always check for null before incrementing store value [OK]

Common Mistakes:

• Ignoring null values from store.get()
• Incorrect method usage for state store access
• Wrong store type casting

5. You want to build a Kafka Streams application that counts the number of times each word appears in a stream of sentences. Which approach correctly uses a state store to maintain the counts?

hard

A. Use a persistent key-value state store to keep counts, update counts on each word, and query the store for results

B. Use an in-memory state store without updating counts, just print words as they arrive

C. Use a state store only to store the last processed sentence, ignoring counts

D. Use a state store to buffer all sentences without processing counts

Solution

1. Step 1: Understand word count requirement and evaluate options

   Counting words requires storing and updating counts per word, so a key-value store is needed. Use a persistent key-value state store to keep counts, update counts on each word, and query the store for results fits the requirement.

2. Final Answer:

   Use a persistent key-value state store to keep counts, update counts on each word, and query the store for results -> Option A

3. Quick Check:

   Persistent store + update counts = correct word count approach [OK]

Hint: Use persistent store and update counts per word [OK]

Common Mistakes:

• Using in-memory store without updating counts
• Storing sentences instead of counts
• Buffering data without processing