Redis persistence overview (RDB, AOF) - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Difference between RDB and AOF persistence

Which statement correctly describes the main difference between RDB and AOF persistence in Redis?

A RDB logs every write operation to a file, while AOF saves snapshots of the dataset at intervals.

B RDB saves snapshots of the dataset at intervals, while AOF logs every write operation to a file.

C Both RDB and AOF save snapshots of the dataset at the same frequency.

D RDB and AOF are two names for the same persistence method in Redis.

💡 Hint

Think about how often data is saved and what is recorded.

RDB creates point-in-time snapshots of the dataset at specified intervals. AOF records every write operation received by the server, allowing more fine-grained recovery.

❓ query_result

intermediate

Result of Redis restart with only RDB enabled

If Redis is configured to use only RDB persistence and it crashes before the next snapshot, what data will be available after restart?

A No data will be available; Redis starts empty.

B All data including the most recent writes before the crash.

C Only the data saved in the last snapshot before the crash.

D Data will be partially corrupted and unusable.

💡 Hint

Consider when RDB saves data and what happens if Redis crashes unexpectedly.

RDB saves data only at snapshot times. If Redis crashes before the next snapshot, recent writes after the last snapshot are lost.

📝 Syntax

advanced

Correct Redis configuration for AOF persistence

Which Redis configuration snippet correctly enables AOF persistence with appendfsync set to 'everysec'?

Redis

appendonly yes
appendfsync everysec

A

appendonly yes
appendfsync everysec

B

appendonly no
appendfsync always

C

appendonly maybe
appendfsync everysec

D

appendonly yes
appendfsync no

💡 Hint

Check the valid values for appendonly and appendfsync.

To enable AOF, appendonly must be set to 'yes'. The appendfsync option controls how often Redis fsyncs the AOF file; 'everysec' is a common safe setting.

❓ optimization

advanced

Choosing persistence for minimal data loss and performance

You want Redis to minimize data loss but also maintain good performance. Which persistence setup is best?

A Disable both RDB and AOF for best performance.

B Enable only RDB snapshots every hour.

C Enable AOF with appendfsync always and disable RDB.

D Enable AOF with appendfsync everysec and RDB snapshots as backup.

💡 Hint

Think about balancing data safety and speed.

Using AOF with 'everysec' fsync reduces data loss risk while keeping performance reasonable. RDB snapshots provide a backup in case AOF is corrupted.

🔧 Debug

expert

Diagnosing Redis data loss after crash with AOF enabled

Redis is configured with AOF enabled and appendfsync set to 'everysec'. After a crash, some recent writes are missing. What is the most likely cause?

A The crash happened less than one second after the last fsync, so recent writes were not yet flushed to disk.

B RDB snapshots overwrite AOF data causing loss.

C AOF was disabled, so no writes were logged.

D appendfsync was set to 'always', causing data loss.

💡 Hint

Consider how appendfsync everysec works and timing of crashes.

With appendfsync everysec, Redis fsyncs the AOF file once per second. If a crash occurs just before fsync, recent writes in memory are lost.

Practice

1. What is the main purpose of Redis persistence?

easy

A. To speed up data retrieval during queries

B. To save data so it is not lost after a restart

C. To compress data for less storage use

D. To encrypt data for security

Solution

1. Step 1: Understand Redis persistence goal

   Redis persistence is designed to keep data safe even if Redis restarts or crashes.

2. Step 2: Match purpose with options

   Only To save data so it is not lost after a restart talks about saving data across restarts, which matches the goal.

3. Final Answer:

   To save data so it is not lost after a restart -> Option B

4. Quick Check:

   Persistence means saving data = A [OK]

Hint: Persistence means data stays after restart [OK]

Common Mistakes:

• Confusing persistence with speed optimization
• Thinking persistence compresses data
• Assuming persistence encrypts data

2. Which Redis persistence method saves snapshots of the dataset at intervals?

easy

A. None of the above

B. AOF (Append Only File)

C. Both AOF and RDB

D. RDB (Redis Database)

Solution

1. Step 1: Recall persistence methods

   RDB saves snapshots of the dataset at set intervals, while AOF logs every write operation.

2. Step 2: Identify correct method for snapshots

   Only RDB matches the description of saving snapshots periodically.

3. Final Answer:

   RDB (Redis Database) -> Option D

4. Quick Check:

   Snapshots = RDB [OK]

Hint: Snapshots = RDB saves whole data periodically [OK]

Common Mistakes:

• Mixing AOF with snapshot saving
• Choosing both methods as snapshot savers
• Thinking AOF saves snapshots

3. Given Redis configured with both RDB and AOF enabled, which statement is true about data recovery after a crash?

medium

A. Redis will use the AOF log if available, otherwise the RDB snapshot

B. Redis will use only the RDB snapshot for recovery

C. Redis will use only the AOF log for recovery

D. Redis cannot recover data if both are enabled

Solution

1. Step 1: Understand recovery priority

   When both RDB and AOF are enabled, Redis prefers AOF for recovery because it has more recent data.

2. Step 2: Analyze options

   Redis will use the AOF log if available, otherwise the RDB snapshot correctly states Redis uses AOF if available, else falls back to RDB.

3. Final Answer:

   Redis will use the AOF log if available, otherwise the RDB snapshot -> Option A

4. Quick Check:

   AOF if available else RDB = B [OK]

Hint: AOF has latest data, used first for recovery [OK]

Common Mistakes:

• Assuming Redis uses only RDB always
• Thinking Redis cannot recover with both enabled
• Believing AOF is ignored if RDB exists

4. You configured Redis with AOF persistence but notice the AOF file is not growing after writes. What is the most likely cause?

medium

A. AOF rewrite is stuck and blocking writes

B. Redis is only using RDB snapshots

C. AOF persistence is disabled in the config

D. Redis does not support AOF persistence

Solution

1. Step 1: Check AOF file behavior

   If AOF file size does not increase after writes, it suggests AOF is not active or enabled.

2. Step 2: Identify cause from options

   AOF persistence is disabled in the config states AOF persistence is disabled, which explains no file growth.

3. Final Answer:

   AOF persistence is disabled in the config -> Option C

4. Quick Check:

   No AOF growth means AOF disabled = C [OK]

Hint: No AOF file growth? Check if AOF is enabled [OK]

Common Mistakes:

• Assuming Redis does not support AOF
• Thinking AOF rewrite blocks all writes
• Confusing RDB usage with AOF file size

5. You want to minimize data loss in Redis but keep fast restart times. Which persistence setup is best?

hard

A. Enable both RDB snapshots and AOF with fsync every second

B. Enable only AOF with every write logged

C. Disable persistence and rely on backups

D. Enable only RDB snapshots every hour

Solution

1. Step 1: Understand trade-offs

   RDB snapshots are fast but risk losing data between snapshots. AOF logs every write but can slow restarts.

2. Step 2: Analyze combined setup

   Enabling both with AOF fsync every second balances minimal data loss and reasonable restart speed.

3. Step 3: Evaluate other options

   Only RDB risks data loss; only AOF can slow restarts; disabling persistence risks total data loss.

4. Final Answer:

   Enable both RDB snapshots and AOF with fsync every second -> Option A

5. Quick Check:

   Best mix for safety and speed = D [OK]

Hint: Combine RDB + AOF for safety and speed [OK]

Common Mistakes:

• Choosing only RDB and ignoring data loss risk
• Choosing only AOF and ignoring restart speed
• Disabling persistence entirely