Robin Cloud Platform for NoSQL Databases - Simplify Lifecycle Management and Consolidate - Cassandra, MongoDB, Elasticsearch, PostgreSQL, MySQL - Challenges

NoSQL Databases

Simple Lifecycle Management & Database Consolidation

Typical NoSQL Database Challenges

Low Utilization and Lack of Consolidation – NoSQL databases such as Cassandra clusters are, typically, created per use case. In fact, the common practice is to give each team its own cluster.

To avoid performance issues, most enterprises stay away from virtual machines. This means that underlying hardware has to be sized for peak workloads, leaving large amounts of spare capacity and idle hardware due to varying load profiles. Challenges include:

Complex cluster lifecycle & fault tolerance

Given the need for physical infrastructure (compute, network and storage), provisioning NoSQL database clusters, such as Cassandra, on-premise can be time-consuming. The challenge here is estimating the read and write performance that will be delivered by the designed configuration, which will require extensive testing and experimentation.

Node failures

The other key planning exercise for NoSQL databases is for node failures. Failures are the norm and have to be planned for from the get go. While Cassandra is designed to withstand temporary node failures, it still has to be resolved by adding replacement nodes, and it poses additional load on the remaining nodes for data rebalance – post failure and again post addition of new nodes.

Manual backups and restore

Unlike traditional databases such as Oracle, DB2, or SQL Server, newer NoSQL databases such as Cassandra are still limited in its tooling. For example, Cassandra does not come with utilities that automatically back up the database. It only offers backup in terms of snapshots and incremental copies, but they are quite limited in features and have to be done per node. Similarly, data recovery is fairly involved, and requires manual steps on every node of the cluster.

The cloning challenge

The other challenge with large NoSQL databases is cloning them for dev and test use. Traditional techniques are time-consuming and require significant amounts of storage — thus restricting agility, which is increasingly becoming one of the key requirements for DevOps.

Costly Scaling

With the ability to scale NoSQL databases such as Cassandra linearly, most administrators are quite accustomed to adding nodes (or scale out) to expand the size of clusters. With each node you gain additional processing power and data capacity. But while node addition is good for steady increases in load, how does one deal with transient spikes? Administrators need the ability simply add and remove resources dynamically and at real time to their databases to deal with temporary load variations.

Database Consolidation and Management Challenge

The database is the quintessential data dependency for any application. Databases in production environments tend to be performance sensitive and rely on consistent and predictable performance from their underlying infrastructure. Virtualization, despite its wide adoption and various benefits, has limited penetration in this space due to the hypervisor overhead and its inability to guarantee SLAs. Consequently, these databases are deployed on bare metal servers leading to sprawl, low hardware utilizations, over-provisioning for peak demand, and poor isolation.

All is not wrong with virtualization. Virtualization makes development and test databases agile and portable. Databases in VMs are fast to deploy and clone, have improved consolidation and hardware utilization by sharing infrastructure, are fully isolated, benefit from VM high availability and failover, and are easy to move across data centers and clouds.

So how can we achieve bare-metal-like performance, while retaining benefits of virtualization, all from the same management layer and at a significant cost saving?

Robin Application Virtualization Platform for NoSQL Databases - Simplify Lifecycle Management and Consolidate - Cassandra, MontoDB

Robin Solution – Simple Application and Data Lifecycle Management

White Paper - Simplifying Data Management with DataStax & RCP

Users interact with Robin entirely at the database level and provision as well as manage the underlying infrastructure transparently.

  • Get bare-metal-like performance
  • Retain virtualization benefits
  • Enable cost savings
  • Manage everything from a single management layer

Apache Servers and DataStax on Robin Cloud Platform

Run NoSQL Databases - Robin Cloud Platform for NoSQL Databases - Simplify Lifecycle Management and Consolidate - Cassandra, MongoDB, Elasticsearch, PostgreSQL, MySQL

RCP Benefits for Simple Lifecycle Management

https://robinsystems.com/wp-content/themes/salient/css/fonts/svg/basic_bolt.svg

40% Higher Hardware Utilization

Cluster consolidation and App-to-spindle QoS

https://robinsystems.com/wp-content/themes/salient/css/fonts/svg/basic_chronometer.svg

Time Saving

Deploy applications and clusters with a single-click with agile provisioning

https://robinsystems.com/wp-content/themes/salient/css/fonts/svg/basic_folder_multiple.svg

Elastic Scaling & Cloning

Scale up or out for seasonal spikes & create thin clones on the fly

https://robinsystems.com/wp-content/themes/salient/css/fonts/svg/basic_elaboration_cloud_refresh.svg

Easy Data Sharing

Share data among dev, test & prod or between applications/clusters

  • How NoSQL databases like Cassandra can benefit from container technology
  • Can the current storage systems can support containerized databases?
  • How to alleviate data management challenges for large databases
  • How Robin Containerization Platform can deliver bare-metal-like performance, while retaining all virtualization benefits

Consolidation Across Physical and Virtual Environments

  • Achieve 50% Reduction in Hardware footprint
  • Accomplish significant improvement in hardware utilization
  • Realize up to 40% gain in database performance
Robin Cloud Platform for NoSQL Databases - Simplify Lifecycle Management and Consolidate - Cassandra, MongoDB, Elasticsearch, PostgreSQL, MySQL - Consolidation across physical and virtual environments

Robin’s container-based, application-aware, compute and storage platform liberates databases from servers, VMs, and storage limitations. The Robin software transforms commodity hardware into a compute, storage, and data continuum such that multiple databases can be deployed per machine, ensuring the best possible hardware utilization.

1-click, rapid, self-service Cassandra deployment

  • Build elastic infrastructure that provides all resources to each application as needed
  • Create single-click clone of entire data pipeline
  • Get out-of-the-box 2-way or 3-way replication
  • Create thin clones on the fly without affecting data in production
  • Achieve data sharing pointing HDFS of one cluster to another
Robin Cloud Platform for NoSQL Databases - Simplify Lifecycle Management and Consolidate - Cassandra, MongoDB, Elasticsearch, PostgreSQL, MySQL - 1-click rapid deployment

It is necessary to scale up or out as demand for resources spikes and then comes back to normal. Robin enables you to scale up with a single click by allocating more resources to the application. Robin enables you to scale out easily when you need to add nodes and helps you clone parts of your data when you need give data to developers and analysts for analytics, test upgrades, testing changes or for integration testing.

Guaranteed Availability and App-to-Spindle Performance

  • Eliminate cluster sprawl with data pipeline components on the same shared hardware
  • Enable multi-tenancy with performance isolation and dynamic performance controls
  • Leverage dynamic QoS controls for every resource – CPU, memory, network and storage
Robin Cloud Platform for NoSQL Databases - Simplify Lifecycle Management and Consolidate - Cassandra, MongoDB, Elasticsearch, PostgreSQL, MySQL - Guaranteed IOPS and App-to-Spindle QoS

Robin eliminates cluster sprawl by deploying a data pipeline on shared hardware. This also results in better hardware utilization. The key to successful multi-tenancy is the ability to provide performance isolation and dynamic performance controls. The Robin application-aware fabric controller equips each virtual cluster with dynamic QoS controls for every resource that it depends on – CPU, memory, network, and storage. This creates a truly elastic infrastructure that delivers CPU, memory, network and storage resources – both capacity and performance – to an application exactly at the instant it is needed.

Application Time Travel

  • Take unlimited cluster snapshots
  • Restore or refresh a cluster to any point-in-time using snapshots
Robin Cloud Platform for NoSQL Databases - Simplify Lifecycle Management and Consolidate - Cassandra, MongoDB, Elasticsearch, PostgreSQL, MySQL - Time travel for NoSQL databases

Robin provides out of the box support for application time travel. Cluster level distributed snapshots at pre-defined intervals can be really useful to restore the entire pipeline or parts of it if anything goes wrong. Robin recommends admins to take snapshots before making any major changes. Whether you are upgrading the software version or making a configuration change make sure to have a snapshot. If anything goes wrong the entire cluster can be restored to the last known snapshot in matter of minutes.