Filter Ratings and Reviews
Filter 178 vetted Redis reviews and ratings
Reviews (1-25 of 75)
[It's being used as a] Caching service for quick key lookups.
- Quick key lookups.
- Distribution of data is easy and reliable.
- Almost HA.
- HA automatic failover for master and promoting slave on own.
- Doesn't handle 1M r/s sadly.
- Cross DC replication not so great.
January 07, 2020
Redis Solves many application caching problems.
We used Redis for application data caching. Redis is used by more than one department and is an enterprise standard offering. We have since moved away from Redis as we were able to simplify our architecture given our more powerful database servers after our latest tech refresh. When we were using Redis, our application response times were too slow for certain transactions so we cached the data to improve performance. There are other use cases that we considered like caching of session data. Again our goal was to simplify our architecture and Redis was one of the products we eliminated, not because it wasn't a good product but because we no longer needed it for our application.
- Application data caching.
- Session data caching.
- Managing cache misses better.
November 26, 2019
Best DB for a gaming company willing to scale overnight
Redis is used across all the organization. It is used by our main games to store user data, session data, game data, and indexing some information related to it.
Having backend systems that support casual games, like Trivia Crack, must support instant virtualization and big spikes that can happen during holidays, Christmas, and so on. Consequently, it is important to have a sub-millisecond database to be able to increase the requests rate very rapidly.
Having backend systems that support casual games, like Trivia Crack, must support instant virtualization and big spikes that can happen during holidays, Christmas, and so on. Consequently, it is important to have a sub-millisecond database to be able to increase the requests rate very rapidly.
- Answer requests at sub-millisecond latency: by having all the data in memory, the latency has no comparison to other disk based DBs.
- Simplicity: it is incredibly simple and straightforward to use. You can download Redis and start using it during the next five minutes.
- Reliable & scalable: when working with a cluster (and if you have a proper sharding strategy), your DB can scale to pretty high numbers and not to die in the middle of any spike.
- Cost: by having all the data in memory, it can be very expensive. There should be an option for having some data stored on disk, at least initially (and with the tradeoff of some higher latency).
- Lack of some basic permissions: there should be a way of having a user with restricted commands (i.e.: no keys *, now write commands, etc).
- Multi-module available on the same Redis instance (as far as I know, this is not possible yet).
April 06, 2020
Redis is a great product offering from Amazon
Our organization uses data a lot. It is essential that we deal with a huge set of data and in a quick and timely fashion. Our data services in order to achieve this, we use Amazon's Redis cache. It's been working great for us and we have been using Redis for 1.5 years now. It is reliable and helps speed up our services by at least 40% and reduces the DB calls.
- As with other service offerings from Amazon, Redis is fully managed as well and eliminates a lot of burden on our team.
- It's easy to get hold of all the metrics as it is integrated with Cloudwatch.
- Very quick and easy to deploy and configure the Redis services into our environment.
- It becomes expensive over time and need to keep a close watch on the usage.
- If the instance goes down, there is no backup preserved.
Redis is being used as our main nonSQL database store. We run PostgreSQL as the main relational data store, Our entire platform used within the business unit utilizes Redis and is also customer facing. The stability, reliability and scalability are great and it's also easy to easy to set up and implement.
- 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
April 07, 2020
Great in-memory database solution
Redis was used in a project to merge live data from different sources. Then by using Lua scripting we were able to make some further aggregations and data binding for better results. It was essential for us as preparation for next steps.
We also used it as session storage manager for some other projects.
We also used it as session storage manager for some other projects.
- It's fast for key value hashes operations.
- Lua Scripting extension is really powerful.
- Single-threaded.
We're using Redis in many ways and across different departments in the organization. The most simple use case is to store locks so the backend services can reject duplicated API requests. A little more advanced use case is to use it as a buffer for queues of messages or requests. We're also exploring ways to use the new Graph type to support Data Science models in development.
- Redis has many data types that suit a variety of use cases such as caching, message queues, graphs.
- Redis is an open-sourced tool with a growing community, as well as 3rd party support (Amazon managed version) if you need additional help with the set-up.
- Both the clients and the command line tool are easy to use and well-documented.
- Scaling has always been an issue with Redis. Routing to shards is not automatic.
- There's no GUI for managing the keys and values stored in Redis. The command-line tool is useful but not friendly to non-engineering users.
- The data types as in data structures have many choices, but inside of the key-value pair, the content is always stored as a string.
October 14, 2019
Improve performance at a reduced cost
We use Redis in our back end messaging platform for database, cache synchronization functions. Redis is being used throughout our entire organization and is the basis for our EMR messaging platform.
- 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 has been a vital component in our design, it's usage is mainly for caching API requests, but it also extends to other applications such as rate limiting and pub-sub mechanism.
- Latency.
- In-memory.
- Ease of use.
- Open source licensing was ambiguous.
Redis is being used across the whole organization as a better cache/message broker service, replacing SQL Server.
- Caching
- Message broker
- Different OSs
September 24, 2019
Redis, a fast, reliable and well supported data storage system
We're currently using Redis to support distributed caching and synchronization across our app. Our application runs on multiple servers so ensuring all infrastructure is in sync and key operations are atomic is critical. It's being used by the backend development team in core infrastructure. Redis is well suited to solve this problem as it offers both performance and reliability.
- 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.
Redis is being used as our primary NoSQL key-based database store. In the specific platform that Redis is being used the most, we have PostgreSQL as the main relational data store, Memcache for expiring key-based caching and Redis. The entire platform used within the business unit utilizes Redis but other departments are starting to use it as well given the ease of use, stability, and reliability.
- 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.
Redis Enterprise helps us by making clustering, sharding, backups and some more very easy to set-up, control, and monitor. It's quite nice being able to sleep at night knowing that despite all your database is on volatile memory (RAM) or a hybrid solution (Redis on Flash), and still have the information clustered, sharded, replicated, and constantly being backed up, with just a few clicks. The support is really great, and the ease of use and set-up are also big selling points.
- 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.
September 18, 2019
If you need lots of user sessions, this is the product to use
Redis is used by our organization to deliver schedules to the users of livestreams and playlists. We needed something that could deliver very high requests per second and also allow us database updates without impact to our customers. This has been accomplished with Redis.
- 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
September 16, 2019
Get a cache server on steroids with Redis and get rid of those Memcached instances
We use Redis as a Cache DB in a microservices environment to store auth tokens, temporary data and sync flags to coordinate processes that are handled by multiple parties asynchronously.
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.
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.
We use Redis as a cache for our Django application, and as the result storage for Celery, our distributed task runner.
- Simple
- Fast
- Has a variety of data types
- Transaction support
- Automatic command when a connection closes
- Negative acknowledgement support in streams
May 21, 2019
Redis : Effective cache management solution
First, I would like to clarify that Redis is not being used in production by my organization currently. Right now, I am involved in an R&D project, where I am experimenting on how to induce Redis on various modules. I am planning to use Redis as a cache management solution in our application for now. On successful implementation, we will extend Redis usage to manage other functionality as well.
- 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.
September 07, 2019
Super fast and easy to integrate
We currently use Redis in only one core internal application, however, this application handles around 90% of our company's internet traffic. This application load balances requests intelligently across multiple downstream server clusters. Prior to this, we used to frequently run into bottlenecks at the DB layer when web server scaling alone was insufficient.
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.
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.
August 08, 2019
Perfect for caching and expiring data storage
We use Redis as a distributed cache for many internal tools across the entire organization. Some tool uses Redis as a filter to remove millions of duplicated jobs every day.
- Really fast.
- Data model simple to understand.
- Very simple to use.
- Support batches of operations to increase performances.
- Nothing, it just works.
We use Redis to cache huge responses received from 3rd party services in our Backend to Frontend (BFF) layer, to improve performance and loading time in the frontend single page web application. It is used to cache pricing, product data which would stay fixed for a given amount of time. We were able to drastically reduce the loading time of pages in the frontend due to this caching mechanism using Redis.
- Performance
- Error resilient
- Easy to use
- Learning curve is steep
- Developing in a local environment can be difficult.
We have used Redis in an in-memory key-value store.
- Binary key-value store support
- Simple data structures
- Very well documented
- Nested use of data structures
- GUI tool in better shape
- More courses on Redis
Redis has helped us to improve the performance of our database performance by using it as a buffer/cache to the most frequently accessed pieces of data while doing data analytics. It provides us with a faster and simpler way to ship data from the database to the client's computer. It also helps us work with real-time data efficiently and reliably.
- Excellent performance
- Scalability
- Reliability
- Real-time analytics
- Few commands
September 11, 2019
Redis is the best cache database on the market
We use Redis to store data such as ID sessions, card tokens. We have a cluster with three servers in three different environments, and it's working very well.
- Very scalable.
- High performance.
- Easy to use.
- Management tool could be better.
- Books in Spanish.
May 08, 2019
Redis: the best cache store you can get!
Redis is being used by our product engineering team. We use it for caching and as a store for our background processing engine.
- 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.
Our development team uses it extensively.
- 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.
Redis Scorecard Summary
Feature Scorecard Summary
About Redis
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.
Categories: Open-Source Database, NoSQL Databases
Redis Screenshots
Redis Video
Redis Downloadables
Redis Integrations
Apache Spark, OpenShift, CData, Pivotal Cloud Foundry
Redis Competitors
Pricing
- 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 | |
|---|---|---|
| Phone | ||
| Live Chat | ||
| Forum/Community | ||
| FAQ/Knowledgebase | ||
| Social Media | ||
| 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 |
| Supported Countries: | Global |
| Supported Languages: | https://redis.io/clients |