ScaleOut Software is excited to announce the release of ScaleOut In-Memory Database™, which offers a new, highly scalable, clustered server platform for running Redis commands. This platform uses ScaleOut’s patented, quorum-based clustering technology to replace open-source Redis’s cluster implementation and fully automate cluster management, while preserving the use of open-source Redis code to process commands. By doing this, ScaleOut In-Memory Database enables enterprise Redis deployments to eliminate most of the complexity of managing a server cluster and lower both their acquisition and management costs (TCO) — while preserving a fully native execution environment for Redis applications. ScaleOut In-Memory Database runs on both Linux and Windows systems.
ScaleOut’s Cluster Architecture
When ScaleOut Software first developed its clustering technology for scalable, in-memory data storage back in 2003, we recognized that we had to tackle several technical challenges. We needed to implement a scalable cluster membership, partition the in-memory data store across multiple servers, replicate updates with zero data loss (i.e., avoid eventual consistency), and maximize throughput with multi-threading on multicore servers. We also realized that it was important not to expose all these complexities to users; otherwise, we risked making the cluster hard to manage, requiring a steep learning curve for system administrators. It was also vital to maintain a straightforward view of the data store for applications (that is, maintain location transparency and full consistency) so that it would be easy to target by developers.
As a result, we first released our cluster architecture in 2005 with the ability to self-organize multiple servers into a cluster, automatically partition data and distribute it across the cluster, and load-balance stored data as servers are added or removed. It also automatically creates and maintains replicas, detects server and network failures, recovers from failures by promoting replicas to replace failed primary partitions, and “self-heals” by creating new replicas to replace those that were lost. The server cluster uses peer-to-peer algorithms to avoid single points of failure, runs on one or more servers, and it maintains availability to applications if even all but one server fails. It uses a patented quorum algorithm to implement full (strong) consistency when updating stored data across multiple servers, and it simultaneously executes multiple requests using a multi-threaded architecture.
ScaleOut’s cluster architecture does all this without exposing its inner workings to either developers or system administrators. Developers see a single, reliable data store that happens to be distributed across multiple servers. System administrators see a set of servers on a single network subnet, each running a single service process. Once the service is configured to select a specific subnet (if multiple NICs are in use), it joins the cluster with a single click and is ready to take on its share of the workload. Building a server cluster is just a matter of adding servers (called “nodes” in Redis documentation) in this manner:
All of this automation minimizes the workload for system administrators, thereby lowering costs and increasing uptime. Administrators are unaware of the cluster’s data partitioning mechanism and replica placement. They do not need to intervene if a server fails or becomes isolated in order to recover and heal the data store. They also do not need to spin up multiple service processes per node to extract more throughput from multicore servers.
First created in 2009 for use on a single server with clustering added in 2015, open-source Redis has gained widespread popularity because of its rich set of data structures and commands. With its fast-growing adoption across many applications and its increasing use in enterprise-class deployments, the need to streamline management procedures and increase data reliability has become more urgent.
ScaleOut In-Memory Database was created to meet this need. This product integrates open-source Redis code (version 6.2.5) that implements all the popular Redis data structures (such as strings, lists, sets, hashes, streams, and more) into ScaleOut’s cluster architecture and execution platform. Instead of requiring system administrators to manage Redis concepts like hashslots and shards, ScaleOut takes over these tasks using its built-in, fully automated mechanisms. Automated recovery and self-healing eliminate the need for manual intervention and increase uptime. In addition, ScaleOut’s quorum-based updates replace Redis’s eventual consistency mechanism to deliver reliable data storage across servers. Applications can depend on the server cluster to survive a server failure without data loss, and the cluster remains available even if multiple servers fail.
To boost throughput and automatically take full advantage of all available processing cores, ScaleOut In-Memory Database integrates Redis command execution with its multi-threaded processing of client requests. Accomplishing this required eliminating Redis’s native, single-threaded event-loop execution model without introducing a global lock that would constrain performance. The net result is that each server in the cluster can simultaneously run Redis commands on all processing cores using a single service process.
Power with Simplicity
Because ScaleOut’s peer-to-peer cluster architecture was designed to serve as the foundation for all user services, functions like clearing the database and backup/restore were designed from the outset to run in parallel across all servers. This approach reduces the system administrator’s workload and delivers fast performance. To give Redis users the benefit of a fully parallel architecture, ScaleOut In-Memory Database provides a cluster-wide implementation of appropriate Redis commands, such as PUBLISH and FLUSHALL.
ScaleOut In-Memory Database overcomes the single-server limitation of the Redis SAVE command and provides a cluster-wide implementation of backup/restore using its built-in parallel backup/restore utility. This enables system administrators to backup all Redis objects with one button-click in ScaleOut’s management console, and it delivers parallel speedup by running simultaneously on all servers either to local disks:
or to a single, shared disk:
System administrators can minimize their workload by restoring backup files to a different cluster configuration than was used to make the backup. For example, a backup from a 3-server cluster can be restored to a 2-server cluster with a different hashslot mapping:
There’s a lot more in the new ScaleOut In-Memory Database than there’s room to fully discuss in this blog post. For example, ScaleOut’s cluster automatically stalls Redis command execution when it moves hashslots between nodes for load-balancing or performs recovery so that clients always have a consistent view of the cluster. Also, the cluster stores Redis objects in their own ScaleOut namespace side-by-side with objects managed by ScaleOut’s native APIs. This lets users access the full power of ScaleOut’s in-memory computing features, including cluster-wide, data-parallel operations and stream processing with digital twins.
ScaleOut In-Memory Database opens the door to a new era of scalable processing for enterprise Redis users. By automating cluster management, improving data reliability, and adding multi-threaded command execution, this product can significantly drive down the total cost of ownership for Redis deployments even in comparison to commercial Redis alternatives. We invite you to check it out and see how it performs for you. We’d love to hear your feedback.