Reviews (1-25 of 40)
- 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.
- Key/Value datastore. Redis is incredibly fast when it comes to simple "phone book-style" lookups.
- Queue orchestration and management when there are many nodes in a system that need to all be on the same page.
- Dead-simple installation process. It takes about 3 minutes to install Redis and get the service started.
- I am unable to come up with any legitimate cons, but one thing to note is that Redis, by default, will be installed with no password, leaving it open to the world if the host is not locked-down with a firewall.
- Redis is easy to install and maintain.
- Redis is very fast, especially with set operations.
- Redis is cost effective.
- Clustering, especially with multiple write nodes, can be difficult to configure.
- Configuring extremely high availability can be difficult.
- 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.
2) Unique and flexible key value db structure
3) They use Ssd Flash for their instances
They also provide session management capabilities to be implemented in any huge projects without much headache. Their db instance also provides a high number of read write per second, which makes it a leader.
- Being a non-SQL database, it does not require any structure. Perfect for unstructured data like key-value pairs.
- Redis is extremely fault tolerant. As soon as we write a record, it gets saved to the disk, without any performance issues.
- Redis is very lightweight. In docker it takes less than 30MB, so it is so easy to run multiple containers in cluster without taking too much power.
- Redis has a very good query API, and they are in their website each operation is clearly mentioned with its time complexity. This gives you a clear picture of performance. We didn't in fact do any performance testing because we trusted their site with all the information.
- Redis has a very strong community around it. We have never found an issue for which a solution didn't exist beforehand.
- A cluster in Redis was a little hard to understand and deploy, but this is a one time thing to learn, no worries.
I can also vouch for Redis's pub/sub notification. You can basically set expiration or event hooks around your keys, and Redis will trigger a notification for those events.
But Redis is ill-suited for treating it as a proper database. For instance, this is not a replacement for elasticsearch or mongo.
To assess if you need Redis, in my opinion, just think if you need to query values. If yes, don't use redis. If you are only concerned with key operations, then go with Redis.
Review: "Blazing performance, excellent stability, and really nothing to dislike make Redis a must look at solution"
- Cache speed
- Support for high volume of transactions with elegant handling of data sets
- Ease of use - well structured and easy to implement
- Price per shard is a bit high but over all there are no issues worth mentioning
- I've heard some wishing it supported complex queries but this is asking the solution to support operations it wasn't intended for
- Big data manipulation
- Temporal data index structures
- Distributed solutions
- Publish/Subscribe model based solutions
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.
- It's an incredibly fast database with restrictions. It only has key-value combinations but good anyway.
- For caching, at the first request-> write to the cache and read from it since DB query is expensive.
- Persistence, It's like having your session active any time you want.
- Software-based so the high availability configuration is a little bit tricky.
- The expire function is manually managed, so keep all your variables well documented.
- Better to create a Proxy service to deal with Redis values in order to isolate your app from the complexity (not too much anyway).
Redis is atomic, that means you don't have to deal with variables to being blocked to ensure concurrency. So it's great for dashboards, leaderboards, and apps like that.
Redis is not a common database, so don't use it as your repository for data entry or visualization. Yes, it's fast but not that way.
- Handles huge data without any loss
- more number of request at same time
- node replication
- Since this is in-memory database but when you use it as persistence DB then pricing will increase.
- Does not support query like SQL
- High Performance. Compared to other similar technologies Redis is blazing fast.
- Built-in Data Structures. Redis facilitates the creation of Counts, Leaderboards, & Logs.
- Scale Out. Other technologies claim to do Active-Active replication but while rebalancing, the Cluster goes irresponsive. With Redis, this does not happen and requests are still being served.
- Management console still not quite polished.
- No built-in GUI for Debugging keys and values.
- Pricing model.
- Simplicity combined with power. The Redis API is very simple to use, but it also excels at handling large amounts of traffic.
- Redis is scalable and can seamlessly scale outwards to store and retrieve larger amounts of data.
- Redis has an incredibly strong community and tool suite. There is an ample amount of tutorials and connections, making it a great choice regardless of your tech stack.
- It would be better if there were some more advanced tooling. It doesn't feel quite as robust as some data storage options.
- It's unclear how much the core team is doing to advance the product. I'm not a hardcore follower, and there is little news about what is happening.
- Sometimes things can feel a little too abstracted. I've used it for a long time, but rarely know what is happening underneath the hood.
- Speed: Redis is, generally speaking, very fast. I typically place Redis somewhere within my internal network so the major factor in the speed of retrieving data is the size of the data cached.
- Configuration: Redis is very configurable to the point where you can utilize it as simply as a single instance running with no backups to a multi-tiered cluster running with permanent storage, data backups, and replication.
- Documentation: Redis has done a good job of documenting all of its capabilities as well as providing guidance in terms of what client libraries exist to help the developer's application(s) interface with it.
- I, as a rule, don't use Redis for persistent data, but it would be nice if Redis had an option to persist data to another data source such as MySQL or PostgreSQL.
- This is more a wish list item than a con but, it would be nice to have the ability to configure Redis as a write-through proxy. This is generally done by having a processor processes write-data to Redis, another process then reads the data from Redis and writes it to a database, and then finally the keys that have been written are flushed out of Redis.
- PubSub notifications: easy to use and just works.
- Redis has a lot of different data structures and it's easy to find the best one for any problem.
- Simple lightweight protocol.
- It just works and works fast!
- Single threaded nature of Redis can hurt if you not following best practices. For example, small values, don't use heavy blocking commands.
- Expiration can be set only on a key level, and cannot be set for a hash item.
- Automatic failover
- Exhaustive set of data structures
- If you want some simple messaging service, Redis pub/sub is excellent.
- It's difficult to understand the use cases initially. The website should talk about "why Redis" first, then "how".
- Adoption of Redis, gave us the ability to realize our goal of digitally transforming the process of filing returns, generating bills, and tracking the movement of goods across states.
- Using Redis Enterprise, we were able to reduce the time it took to generate an e-way bill by more than 85%. Just as important, we were able to dramatically reduce the burden on our SQL database and API calls.
- Highly available persistent caching solution recognized for its seamless compatibility with Microsoft SQL Server and Consistent end-to-end response times below 40ms.
- Flexible data structures and commands for efficient application in use cases beyond caching.
- Session management is currently being handled in memory by our SQL server, but as the number of concurrent sessions during peak times moves from today’s average of 50,000 to an expected 100,000, we’ll need to implement more efficient session and authentication management likely within Redis Enterprise.
- Manage the complexity of data in many different structures ranging from relational, to logs, to raw text. Handling of Streaming data, large volume of transactions/requests and data movement.
- The functionalities like Joins (inner/outer join), Set operations (Union/Intersect/Minus), Transactions, Full ANSI SQL support, Constraints (like RDBMS) are not easily supported.
- Simple Key Value storage
- Easy interface compared to other databases
- Reliable performance characteristics
- Redis needs better distributed support. I know this is not the point, but a distributed Redis with some CAP tradeoffs would be useful
- Redis should be more clear on its pooling capabilities. Should you use a pool or just use a single connection?
- It would be nice if Redis had a better CLI
If you need something that can be written and read by multiple services, that is as fast as possible, use Redis. The simplicity is its biggest strength, and making it more complex will just ruin the product.
- Response time - the time taken to store or retrieve something from Redis is minuscule compared to most of the alternatives that we are aware of.
- Value for the money - every time we offload data storage to Redis it saves us money, compared to using something like MongoDB or AWS.
- Better documentation.
- Very, very fast due to the in-memory data store, which makes it highly scalable on rational-sized hardware.
- Fills a number of different use cases: can build message broadcast, task queues, sorted sets (i.e. leaderboards), and database caching all with the same tool.
- A robust third-party ecosystem of deployment options (like AWS) and libraries in a number of common programming languages.
- Can be difficult to set up as it scales past a single write node.
- While Redis can preserve state by writing to the file system in a couple of ways, it can still be cumbersome to standup a cluster with history.
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|