Limited Time Offer!

For Less Than the Cost of a Starbucks Coffee, Access All DevOpsSchool Videos on YouTube Unlimitedly.
Master DevOps, SRE, DevSecOps Skills!

Enroll Now
Uncategorised

How to deal with data persistence using Redis while implementing Cache?

December 13, 2024 Leave a Comment

Redis is primarily an in-memory data store, meaning it stores data in the system’s memory (RAM) for fast read and write operations. However, Redis also provides options for data persistence to ensure that data can be recovered after a server restart or crash. Here’s how Redis handles data storage and persistence:

1. In-Memory Storage

  • By default, Redis keeps all data in RAM, which allows it to deliver extremely fast performance.
  • This is ideal for caching purposes because:
    • Data retrieval is nearly instantaneous.
    • It supports high-throughput operations.

2. Data Persistence Options

Redis offers two primary mechanisms for persisting data to disk for long-term storage:

a. RDB (Redis Database Backup) Snapshots

  • How It Works:
    • Redis periodically creates a snapshot of the dataset and saves it to disk in a binary file (e.g., dump.rdb).
    • This happens at predefined intervals (e.g., every X minutes or after Y changes).
  • Advantages:
    • Faster recovery times since the file is compact.
    • Minimal impact on runtime performance.
  • Disadvantages:
    • Data loss may occur if the server crashes between snapshots.

b. AOF (Append-Only File)

  • How It Works:
    • Redis logs every write operation to a file (appendonly.aof) in real-time or at a specified interval.
    • On recovery, Redis replays the log to restore the dataset.
  • Advantages:
    • Ensures minimal data loss.
    • More reliable for applications requiring high durability.
  • Disadvantages:
    • Slower than RDB for large datasets.
    • Files are larger compared to RDB snapshots.

3. Hybrid Persistence

  • Redis 6.0 introduced hybrid persistence, which combines RDB and AOF methods.
  • On recovery, Redis uses the RDB snapshot for fast loading and replays the AOF logs to ensure the dataset is current.
  • This approach balances speed and durability.

4. Memory Management

  • Redis can evict old keys when memory is full based on its eviction policies:
    • Least Recently Used (LRU): Removes the least recently used keys.
    • Least Frequently Used (LFU): Removes keys accessed less frequently.
    • Allkeys Random: Randomly removes keys, regardless of access.

5. Use Cases for Persistence

  • Caching: No persistence needed (default behavior). Data can be regenerated if lost.
  • Session Management: Use persistence to avoid losing user session data.
  • Primary Data Store: Use AOF or hybrid persistence for applications requiring high durability.

Configuration for Persistence

Persistence options can be configured in the redis.conf file:

Enable RDB:

save 900 1      # Save snapshot every 900 seconds if at least 1 key is changed
save 300 10     # Save snapshot every 300 seconds if at least 10 keys are changed
save 60 10000   # Save snapshot every 60 seconds if at least 10,000 keys are changed

Enable AOF:

appendonly yes
appendfsync everysec   # Sync AOF file to disk every second

Hybrid Persistence:

aof-use-rdb-preamble yes

Does Redis Store Data Somewhere Other Than RAM?

  • By Default: Data resides only in memory, making Redis extremely fast.
  • With Persistence Enabled: Data is also stored on disk (RDB/AOF) for recovery.

If your application requires both fast caching and long-term reliability, enabling AOF or hybrid persistence is recommended.

Let me know if you’d like guidance on configuring Redis for your specific use case!

Rajesh Kumar
Follow me
Latest posts by Rajesh Kumar (see all)
Subscribe
Notify of
guest
0 Comments
Newest
Oldest Most Voted
Inline Feedbacks
View all comments
0
Would love your thoughts, please comment.x
()
x