When Redis reaches its memory limit, it does not immediately crash.
Instead, Redis handles the situation based on certain memory management strategies.

The exact behavior depends on your Redis configuration and the version you are using.

Handling Methods

When Redis runs out of memory, the following scenarios may occur.

Write Operations Fail:

If Redis is not configured with persistence (such as RDB or AOF) and has reached the maximum memory limit,
the default behavior is to reject write operations and return an error.

This is to protect data consistency and prevent data loss.

Memory Eviction Policies:

Redis provides various memory eviction policies to manage situations where memory is full.
When this happens, Redis may automatically remove certain data based on the configured eviction policy to free up space.

Persistence Strategy:

If Redis is configured with persistence (such as RDB or AOF),
it can persist data to disk when memory is full, freeing up memory space.
This ensures data durability and allows Redis to continue accepting write operations.

Consequences and Impact

Performance Impact:

As Redis approaches its memory limit, it may need to frequently evict data.
This increases CPU load, affecting the response time and throughput of the Redis server.

Data Loss:

Depending on the eviction policy, some data may be deleted to free up memory.
This means that applications may no longer be able to access certain data.

Write Failures:

Under the noeviction policy, when memory is full, all write commands are rejected.
This may cause applications to fail to function properly.

Memory Eviction Policies

noeviction:

No keys are evicted. Once the memory limit is reached, Redis returns an error.

allkeys-random:

Randomly removes keys from all stored keys.

volatile-random:

Randomly removes keys only from those that have an expiration time set.

allkeys-lru:

Evicts the least recently used (LRU) keys among all keys, keeping frequently accessed keys.

volatile-lru:

Evicts the least recently used (LRU) keys only from those with an expiration time set.

allkeys-lfu:

Evicts the least frequently used (LFU) keys from all stored keys.

volatile-lfu:

Evicts the least frequently used (LFU) keys only from those with an expiration time set.

volatile-ttl:

Evicts the keys that are closest to expiration among those with an expiration time set.

Mitigation Strategies

Optimize Data Structures:

Optimize data structures, such as using compressed lists or integer sets, to reduce memory usage.

Memory Analysis:

Regularly use Redis memory analysis tools, such as the MEMORY USAGE command,
to identify memory usage hotspots.

Vertical or Horizontal Scaling:

Distribute data across multiple Redis instances or upgrade the memory capacity of existing instances.

Monitoring and Alerts:

Implement a monitoring system to track memory usage and trigger alerts when approaching limits,
allowing timely action.

Conclusion

When Redis runs out of memory, it can lead to write failures, increased read latency, memory fragmentation, and even application crashes.
To avoid these issues, it is essential to implement appropriate measures to limit memory usage and optimize memory management.

---

We are Leapcell, your top choice for hosting backend projects, with a built-in serverless Redis.

Leapcell is the Next-Gen Serverless Platform for Web Hosting, Async Tasks, and Redis:

Multi-Language Support

• Develop with Node.js, Python, Go, or Rust.

Deploy unlimited projects for free

• pay only for usage — no requests, no charges.

Unbeatable Cost Efficiency

• Pay-as-you-go with no idle charges.
• Example: $25 supports 6.94M requests at a 60ms average response time.

Streamlined Developer Experience

• Intuitive UI for effortless setup.
• Fully automated CI/CD pipelines and GitOps integration.
• Real-time metrics and logging for actionable insights.

Effortless Scalability and High Performance

• Auto-scaling to handle high concurrency with ease.
• Zero operational overhead — just focus on building.

Explore more in the Documentation!

Follow us on X: @LeapcellHQ