Redis persistence overview (RDB, AOF) - Step-by-Step Execution

Concept Flow - Redis persistence overview (RDB, AOF)

Start Redis Server

↓

Data in Memory

↓

RDB Snapshot

↓

Save to Disk

↓

Data Persistence

↓

Recovery on Restart

Redis keeps data in memory and saves it to disk using two methods: RDB snapshots and AOF logs, which help recover data after restart.

Execution Sample

Redis

SET key1 value1
SET key2 value2
SAVE
APPEND command: SET key3 value3
RESTART
LOAD data from RDB and AOF

This sequence shows setting keys, saving snapshot (RDB), appending commands (AOF), restarting Redis, and loading data from persistence files.

Execution Table

Step	Action	RDB State	AOF State	Result
1	SET key1 value1	Memory updated	AOF empty	key1 in memory
2	SET key2 value2	Memory updated	AOF empty	key2 in memory
3	SAVE (RDB snapshot)	RDB file saved with key1, key2	AOF empty	Disk has snapshot
4	APPEND command: SET key3 value3	RDB unchanged	AOF file has SET key3	AOF logs new command
5	RESTART Redis	Load RDB file	Replay AOF commands	Memory restored with key1, key2, key3
6	END	Data loaded	Data loaded	Redis ready with all keys

💡 Redis stops loading after replaying all AOF commands and loading RDB snapshot

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	Final
Memory Data	{}	{"key1":"value1"}	{"key1":"value1","key2":"value2"}	{"key1":"value1","key2":"value2"}	{"key1":"value1","key2":"value2","key3":"value3"}	{"key1":"value1","key2":"value2","key3":"value3"}	{"key1":"value1","key2":"value2","key3":"value3"}
RDB File	None	None	Snapshot with key1,key2	Snapshot with key1,key2	Snapshot with key1,key2	Loaded snapshot	Loaded snapshot
AOF File	Empty	Empty	Empty	Contains SET key3	Contains SET key3	Replayed commands	Replayed commands

Key Moments - 2 Insights

Why does Redis load both RDB and AOF files on restart?

Redis first loads the RDB snapshot to restore a baseline, then replays AOF commands to apply recent changes not in the snapshot, as shown in execution_table steps 5 and 6.

What happens if SAVE is not called before appending AOF commands?

Without SAVE, the RDB file is outdated or missing, so Redis relies on AOF to restore data. The execution_table shows RDB unchanged at step 4, meaning AOF holds newer data.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what does the RDB file contain?

A Snapshot with key1 and key2

B No data, it's empty

C Snapshot with key3 only

D All keys including key3

💡 Hint

Check the 'RDB State' column at step 3 in execution_table

At which step does the AOF file start containing data?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'AOF State' column in execution_table to see when it changes from empty

If Redis restarts without an AOF file, what will happen according to the flow?

A Data will be lost completely

B Data will be restored from RDB snapshot only

C Redis will fail to start

D Redis will create a new empty database

💡 Hint

Refer to concept_flow where RDB snapshot is loaded first on restart

Concept Snapshot

Redis persistence saves data from memory to disk.
RDB creates snapshots at intervals.
AOF logs every write command.
On restart, Redis loads RDB then replays AOF.
RDB is fast but less frequent.
AOF is slower but more complete.

Full Transcript

Redis stores data in memory for fast access. To keep data safe after a restart, it uses two methods: RDB snapshots and AOF logs. RDB snapshots save the whole dataset at once, like taking a photo. AOF logs every change command, like a diary. When Redis restarts, it loads the snapshot first, then replays the commands from the log to recover the latest data. This way, Redis balances speed and data safety.

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