Reviews (1-25 of 70)
- Atomic operations
- Quick Lookups
- Widely supported (there are many tools/libraries built over Redis)
- We had some difficulty scaling Redis without it becoming prohibitively expensive.
- Redis has very simple search capabilities, which means its not suitable for all use cases.
- Redis doesn't have good native support for storing data in object form and many libraries built over it return data as a string, meaning you need build your own serialization layer over it.
Conversely, due to price/data I wouldn't recommend Redis for persisted or infrequently accessed data.
- Easy for developers to understand. Unlike Riak, which I've used in the past, it's fast without having to worry about eventual consistency.
- Reliable. With a proper multi-node configuration, it can handle failover instantly.
- Configurable. We primarily still use Memcache for caching but one of the teams uses Redis for both long-term storage and temporary expiry keys without taking on another external dependency.
- Fast. We process tens of thousands of RPS and it doesn't skip a beat.
- Autoscale. We've used Redis at RedisLabs and currently on AWS with ElastiCache plus previously I've self-hosted it and there are no real options for "serverless" or an operating model whereby I'm using only the resources needed to handle my current volume, instead, everything is provisioned and sized to your highest throughput needs. For us, that's only a few hours a day where we're at our peak, the other 16 hours could run smaller hardware but the system doesn't autoscale up/down seamlessly on any of the platform providers.
- Management console. Some systems such as Riak have a built-in GUI for ops or Mongo runs their own Compass product but Redis seems to entirely rely on other OSS solutions, which is great, but having a built-in tool that's lock-step with the released versions would ease any quick troubleshooting that CLI-challenged ops teams could utilize.
- Redis replication is asynchronous. Therefore, when a primary cluster fails over to a replica, a small amount of data might be lost due to replication lag.
- Ease of use and set-up.
- Clustering and sharding.
- Automated backups to remote storage (S3).
- The documentation grows quite fast (200+ commands), perhaps they should have a most-used ranking.
- Redis modules (Bloom, JSON, Search) are great, but only one can be active at a time.
- The system is very reliable. The only times we had issues was when we hit database capacity limits.
- There is continuing development on the technology (like Redis streams) that make it an even more attractive technology.
- For systems that require many concurrent users, like several million watching the Super Bowl on their connected devices, it works and it works well.
- None that I can think of
The main problem it solves for us is to need to have a high-performance cache that also provides data persistence so we can restart instances and deploy new ones without losing data in the middle. This is very important for us because of the problem we're tackling. In the case of auth tokens, we don't want to make all users log in again after we restart an instance because the memory got cleared. The same applies for the sync flags that our processes depend on to complete.
- High performance. Redis is FAST, really fast.
- Data persistence. Having this feature was the main reason we chose Redis over Memcached.
- Clustering. Distributing data between multiple instances is easy to do with Redis.
- Data types. It isn't normal to have native data types supported on cache servers, but Redis covers many areas for this use case.
- The data type collections aren't extensive and can fall short for some needs.
- Single-threaded. Redis doesn't support multi-threading, so it won't benefit from multi-core CPUs. Instead, you need to deploy several single-core instances to scale horizontally. While this is a design decision, it may be a downside on some infrastructures.
- Lack of UI. A visual UI can be a downer for some users.
It's usually compared to Memcached, and in terms of performance I think they're very similar, and for some critical applications, Memcached may be a better option. But the feature-rich characteristics of Redis will position it in a more competitive place against many applications.
- Cache management: Redis is the best solution out there for cache management. It out marked Memcache in latency. Redis gives better flexibility when comes to data storage techniques.
- For example: Instead of storing objects as serialized strings, we can use a Redis Hash to store an object's fields and values and manage them using a single key.
- Replication: Redis has the best build in replication feature.
- For example, It allows slave Redis instances to be exact copies of master instances. The slave will automatically reconnect to the master every time the link breaks and will attempt to be an exact copy of it regardless of what happens to the master.
- Pub/Sub- It's Publish & Subscribe system of Redis. Where Publish broadcast content to all its subscribers simultaneously. There are various use cases of Pub/Sub. Developers are using it for triggering scripts based on Pub/Sub events. There are various chat ecosystems built on the Pub/Sub module.
- Redis is super fast but it comes with a cost. Whole dataset resides in RAM. So it can be costly as primary memory is more costly, then secondary ones.
- Persistence issues: To achieve it, Redis uses a memory dump to create a persistence snapshot, that's cool. But it requires some Linux Kernel tweaking to avoid performance degradation while the Redis server process is forking. This further causes latency.
- Master-slave structure side effect: Master-slave architecture comes with its own side effects. Please note that there will be only one master with multiple slaves for replication. All writing goes to the master, which creates more load on the master node. So, when the master goes down, the whole architecture does.
The great thing about this is also that each cluster can be running a different version of our application allowing us to maintain a high level of robustness for our larger enterprise customers, while also allowing us to deploy frequently to other clusters that want the bleeding edge. With Redis, being able to determine the right cluster for the right request happens blazing fast.
- FAST LOOKUPS. First and foremost, this is the bread and butter of Redis. It is our go-to for any highly performant lookups.
- SCALE OUT. Helps build distributed applications that need to share data across geographies.
- Better GUI clients. At the time of adoption, the choices for UI based clients were poor. Such tools are necessary for tier 1 support personnel who may not be entirely technically savvy.
- Filtering out duplicates
- Implement rate limits
- Store access tokens or revoked credentials
- Storing complex data (go for a traditional database instead)
When it comes to performing analytics, Redis is very efficient at that as well as handling large amounts of data common in the data analytics industry. Redis also acts as a very excellent NoSQL database.
- High-speed access for a database where the size is generally well-known.
- If you display real-time stock prices, you can use Redis to rapidly get the latest stock price by its key and get it displayed to the user.
- Support for data structures such as scalars, sets, hashes, and lists.
- Persistence can impact performance since Redis will use memory dump to create snapshots used for persistence.
- Redis supports only basic security options. Redis doesn't provide any access control.
- There is no internal full-text search support and it is difficult to model relationships using Redis.
- Speeds up database searches.
- Cloud-based without the need for on-prem.
- High availability.
- Support needs to be better, with chat support as an option.
- Training material for new hire dev-ops.
- Wiki-type documentation.
- We used cache data to speed up the processing power.
- To do intersections of various sets and achieve a high performing solution.
- To use it as a second-level cache for large data.
- Luva script is a pain to work on
- Great reliability and great fail over capabilities
- Easy to set up, implement and deploy
- Can scale as you grow
- Backups to AWS S3 are supported and are very easy to set up
- Better UI interface for less technical support personnel
- Wish Reids had a Chat support option
- Better documentation in a wiki format
- Great fail over capabilities for optimal up time
- Very easy to set up and get running
- Create backups to AWS S3
- Clustering for greater performance is very easy
- Able to scale is easy to set up and can build with your needs
- Complete data sets tend to have some difficulty. But that's mostly on the type of code you're running
- Only one module can be active at one time. Wish you could run multiple
- Redis provides the ability to score data quickly.
- Redis provides the ability to distribute this info in a fast manner.
- Redis provides an alternative method for data retrieval which lessens the load on the database access.
- Greater emphasis on Pub/Sub capabilities more in line with Kafka.
- Storing geolocations - Redis has built-in geolocation storage capabilities, thus saving us the time of developing the logic ourselves.
- Serving fast info for real-time apps - To anyone who works with real-time applications, fast information is the basis of good user experiences.
- I think the documentation could improve. It's not always clear, especially for engineers that are new on Redis.
- Redislabs admin interface could use a tune-up, maybe being more informative and with a better UI.
- I think the main cons I see in Redis could be that it may be a bit too obscure to new users.
Redis Scorecard Summary
Feature Scorecard Summary
According to the vendor, Redis is an in-memory multi-model database that supports multiple data structures such as strings, hashes, lists, sets, sorted sets with range queries, bitmaps, hyperloglogs and geospatial indexes with radius queries. Redis has built-in replication, Lua scripting, LRU eviction, transactions and different levels of on-disk persistence, and provides high availability and automatic partitioning with Redis Cluster.
Redis combines in-memory, schema-less design with optimized data structures and versatile modules that adapt to your data needs. The result is an adept, high performance, multi-purpose database that scales easily like a simple key/value data store but delivers sophisticated functionality with great simplicity, according to the vendor.
Redis also enables data persistence and high availability through replication and backups. Redis Enterprise is built from the ground up to serve as a system of record for any application.
Redis Support Options
|Free Version||Paid Version|
|Video Tutorials / Webinar|
Redis Technical Details
|Deployment Types:||On-premise, SaaS|
|Operating Systems:||Windows, Linux, Mac|
|Mobile Application:||Apple iOS, Android, Windows Phone, Blackberry, Mobile Web|