Reviews (26-50 of 73)
- Ease of use.
- Variety of use cases.
- Support faster SSL access, currently bring performance down by 50% with SSL.
- Cost - Most providers not cheap.
- Native support to access search through a variety of data formats.
Less suitable if persistence is required.
- 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.
- Filtering out duplicates
- Implement rate limits
- Store access tokens or revoked credentials
- Storing complex data (go for a traditional database instead)
- 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.
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.
- 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
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.
- 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
- 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.
- Caching strategy
- Redis is not a panacea for fast and quick access to the frequently used data. There were times the development team had to go back to JVM cache to achieve the use case.
- Maintaining Redis as a separate persistence has its price ( in operation and maintenance).
- HA and DR was a biggest challenge with the widespread adoption of Redis
- 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.
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.
- Has featureFree Trial Available?Yes
- Has featureFree or Freemium Version Available?Yes
- Has featurePremium Consulting/Integration Services Available?Yes
- Entry-level set up fee?Optional
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|