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 to simply add and remove resources dynamically and at real time to their databases to deal with temporary load variations.
Node 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.
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.
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.
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.
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.

NoSQL Databases

ROBIN Hyper-Converged Kubernetes for

Simple DevOps Operations

ROBIN hyper-converged Kubernetes platform is a software-only solution that runs on-premises in your private data center or in public-cloud AWS, Azure, GCP environments and enables you to provide a self-service deployment of any NoSQL or SQL database. ROBIN brings to life a 1-Click simplicity to deploy and also Snapshot, Clone, Patch, Upgrade, Backup, Restore, Scale, Control QoS of the entire application. This is done with a single mouse click or REST API call independent of the size and complexity of the application.

Customers Choose ROBIN hyper-converged Kubernetes platform to:

  • Leverage the power of Kubernetes for NoSQL databases
  • Slash deployment and management times from weeks to minutes
  • Share resources among multiple applications and users while guaranteeing performance isolation
  • Dynamically scale performance and capacity to meet changing needs

Focus on your NoSQL Database Apps, not infrastructure

NoSQL database applications like Cassandra, MongoDB, CouchDB, ScyllaDB, and others are popular tools used in a modern application stack. However, deploying NoSQL databases typically starts with weeks of careful infrastructure planning to ensure good performance, ability to scale to meet anticipated growth and continued fault tolerance and high availability of the service. Post deployment, the rigidity of the infrastructure also poses operational challenges in adjusting resources to meet changing needs, patching, upgrades, backup and the ability to snapshot and clone the database to create test and dev copies.

ROBIN hyper-converged Kubernetes platform takes an innovative new approach with an application management layer that natively embeds application workflows into Kubernetes and built-in storage and network. The developers and IT teams just describe the needs of their data-intensive applications, like NoSQL databases, without worrying about the assembly of the underlying infrastructure to host them. This patented innovation combines the benefits of Containers, Kubernetes, an integrated Application-Aware scale-out Storage stack as well as networking options and an application-aware workflow manager to provide an app-store like experience where complex applications can be deployed in minutes and their lifecycle managed through radically simplified 1-Click operations.

Focus on Applications and not on the infrastructure with ROBIN Hyper-Converged Kubernetes Platform

Deploy NoSQL Databases in Kubernetes with 1-Click

    • View and onboard any other Application bundles in an App-store like view to deploy with 1-click
    • Describe Application needs such as
      • The various services offered by an app; for example, ConfigServer, QueryRouter, Shards, RepicaSets for MongoDB
      • Seed and Member services for Cassandra
      • Docker or LxC images for each service
      • Placement constraints such as anti/affinity amongst services, or data-locality requirements
    • Specify Scale and Performance requirements
    • ROBIN hyper-converged Kubernetes platform automatically assembles compute, storage and networking infrastructure to deployment.

Provision Opscenter and a DataStax Cassandra Cluster

Deploy MongoDB on ROBIN Hyper-Converged Kubernetes Platform with 1-click

Snapshot Entire Database Cluster with 1-Click

    • Create application-consistent snapshots of an entire NoSQL database with 1-click from the UI, a single CLI command or programmatically through one single REST call
    • Capture full-application shapshots that include Application details
      • Configuration (topology and settings)
      • Data (app-consistent across multiple partitions and shards)
      • Policies (placement and QoS)
  • Take unlimited cluster snapshots at pre-defined intervals – specially before any major changes
  • Restore or refresh a cluster or entire data pipeline to any point-in-time using snapshots in a matter of minutes
  • Leverage snapshots and restore functions if anything goes wrong during a software upgrade or a configuration change

Clone Entire Database Cluster with 1-Click

  • Get rid of significant manual scripting to create clones with ROBIN
  • Remove the need of scripting work to coordinate storage volume clones from their snapshots hosted in a SAN or DAS environment
  • Create entire Application cluster from a previously taken snapshot with a 1-click operation from UI, a single command line or programmatically via a single REST call
  • Share unmodified cloned data for test/dev reports, UAT testing and for validating patches
  • Create fully writable clones and preserve any new updates made to the data in their own independent storage volumes

Dynamically Adjust Resources with 1-Click

  • Leverage ROBIN hyper-converged Kubernetes platform REST API to automate dynamic adjustment of resources
  • Increase resources when load spike happens
  • Decrease resources when the spike goes away
  • Adjust resources dynamically while the application is running without any downtime
  • Adjust CPU and Memory to reflect new core and memory allocations
  • Adjust Storage IOPs dynamically and prioritize IOs for multiple applications differently to ensure they meet their QoS settings

Scale to Meet Long-Term Growth with 1-Click

  • Allocate new Infrastructure resources with a 1-click operation or a single REST API call
  • ROBIN hyper-converged Kubernetes platform executes the entire workflow under the hood to
  • Accommodate the additional components, which includes CPU Cores, Memory, Storage Capacity etc.
  • Generate a new placement plan to determine the best servers to spawn the containers on
  • Carve out new storage volumes to meet the Application needs
  • Allocate new IP addresses from the pool of registered IP addresses
  • Bring containers online with new IP addresses and newly provisioned storage
  • Execute Application-specific hook scripts to make the running NoSQL database cluster aware of the newly added containers
  • Snapshot entire application prior to scaling to be able to revert back in case of error

Patch and Upgrade NoSQL Database Cluster with 1-Click

  • Remove patching and upgrading challenges
  • Validate a patch or upgrade with automated 1-click function
  • Automate the entire process of patching and upgrading via your CI/CD pipeline by integrating with ROBIN’s REST APIs.
  • Initiate a safe failure-proof upgrade or patch by clicking the “Update” button
  • Select “Test upgrade” checkbox to ensure that the update is first applied and verified on a clone of the application before it is committed to the source application

Zero downtime upgrade of the ELK stack on ROBIN

Patch and upgrade NoSQL databases with ROBIN Hyper-Converged Kubernetes Platform

Maximize Performance, Minimize Cost

  • Get enterprise class features and performance on commodity hardware with Robin’s integrated scale-out storage.
  • Leverage features such as Replication, Compression, Encryption, Thin-provisioning, QoS, Snapshots and Clones.
  • Get a very high performance storage stack that delivers the best IOPs, throughput and latency on commodity hardware, beating competing software-defined and SAN storage solutions.
Maximize performance, minimize cost with ROBIN Hyper-Converged Kubernetes Platform

Are Containers Ready to Run NoSQL Databases? On-Demand Webinar

  • How NoSQL databases like Cassandra can benefit from container technology
  • Can the current storage systems support containerized databases?
  • How to alleviate data management challenges for large databases
  • How ROBIN hyper-converged Kubernetes platform can deliver bare-metal-like performance while retaining all virtualization benefit

Robin Hyper-Converged Kubernetes Platform Benefits for NoSQL Databases - Simplified DevOps Operations

Guaranteed Performance Isolation

Share resources among multiple Applications and users while guaranteeing performance isolation

Time Saving

Slash Application and cluster deployment time from weeks to minutes with 1-click agile provisioning

Addressing Spikes and Growth

Dynamically scale performance and capacity to meet changing needs

Dev to Prod in Minutes

Tame the Cassandra-Datastax Dev/Test Challenge in Production Eco Systems