Application-Aware, IntelligentSoftware-Defined Infrastructure Platform
Virtualize Databases or Big Data without the Hypervisor Overhead
Using container-based virtualization, Robin completely eliminates hypervisor performance penalty and improves IO throughput by 40%-60%
Consolidate Workload with Guaranteed QoS
Robin’s application-to-spindle performance guarantee eliminates noisy neighbor impact and delivers predictable QoS for your most critical applications
Simplify Application Lifecycle Management
Robin enables 1-click application deployment, clone creation, and snapshots for time-travel for test & dev environments – for the most complicated distributed applications: Hadoop, or NoSQL databases such as Cassandra & Mongo.
Robin leverages container technology to consolidate applications with complete runtime isolation. Container is a lightweight, OS-based virtualization technology that allows creation of compartmentalized and isolated application environment on top of the standard OS. Just as a hypervisor abstracts OS from the underlying hardware, containers help abstract applications from OS and everything underneath, leading to simplified application deployment and seamless portability across hardware and operating platforms.
Robin is the first and only product in the industry that brings containerization benefits to all types of enterprise applications – including highly performance-sensitive workloads such as databases and Big Data.
Robin’s Adaptive Container technology picks the appropriate container configuration depending on the application types. Traditional applications are deployed within “system containers” to provide VM-like semantics and Robin supports the deployment of stateless microservices applications such as Docker containers.
When used with bare-metal servers, Robin enables “zero-performance-impact” application consolidation of databases, Hadoop clusters, and other distributed applications such as Elasticsearch, resulting in significant operational efficiency gains and cost reduction.
Traditional Storage technology lacks application-awareness and is not designed to handle rigors of containerized environments.
Robin storage is industry’s first application-aware storage subsystems that is capable of managing and controlling storage and IO resources at per-application level. It is designed from the ground up to support agile sub-second volume creation, 100,000-plus-variable-sized volumes, and varied file systems and data protection needs of applications running within the containers.
By decoupling storage from compute, Robin ensures data protection against compute failure and enables seamless application mobility. As no persistent data is stored on the compute nodes, compute layer can be elastically expanded or shrunk without any data movement or copy.
Robin “understands” the data protection needs of application components to minimize overhead and maximize performance. For instance, stateful applications such as databases are assigned “protected volumes” using replication or erasure-coding techniques whereas the stateless components, such as webservers, are allocated standard volumes.
By providing enterprise-grade data protection at the storage layer, Robin obviates the need of inefficient application-level data protection, such as 3-way replication used by Hadoop and other distributed applications. This results in 50% or more storage savings and helps improve the write performance.
Robin’s application-centric data management approach greatly simplifies application lifecycle management. Developer can create quick application clones and snapshots for agile development and testing. Using thin provisioning, compression and copy-on-write technologies, Robin ensures that clones and snapshots are created in seconds using minuscule amount of additional storage. Even a 100TB database can be cloned in a snap using only a few GBs of additional storage.
Robin’s application-aware fabric controller is the “brain” of the Robin platform. This is the component that orchestrates the entire infrastructure fabric from an application perspective. Taking an application as the payload, the fabric controller automatically decides the placement, provisions containers and storage for each application component, and configures the application – thus enabling single-click deployment of even the most complex applications.
It also continuously monitors the entire application and infrastructure stack to automatically recover failed nodes and disks, failover applications, and ensures that each application dynamically gets adequate disk IO and network bandwidth to deliver the Application-to-Spindle QoS Guarantee.
|Guaranteed I/O QoS|
|Decoupled compute and storage (independent compute and storage scaling, centralized data management)|
|Push button Big Data and database cluster provisioning|
|Elastic Application-to-Spindle Scaling (CPU, Memory, IOPS)|
|Multi-tier application, database distributed snapshots and cloning|
|Transparent application portability to Cloud|
For many users, containers are merely a form of virtualization, and often they mistakenly assume that storage for containers is nothing different from storage for virtual machines (VMs). Containers are much lighter than virtual machines and thus can be instantiated and scaled very quickly. Containers running Big Data applications require a distributed storage system that is natively elastic and can support creation and deletion of storage volumes at a very fast rate.
Robin’s container-aware software-defined storage is designed from the ground up to support agile sub-second volume creation, 100,000-plus-variable-sized-volumes, and varied file systems and data protection needs of applications running within the containers.
Robin’s application-aware block storage stack exposes several fine-grained controls that enforce application-level policies based on the type of application being deployed. Block storage also allows addressing storage needs of disparate applications. On Robin, a block storage volume can either be formatted to file systems such as ext4, xfs or any other as required by the application or be used as raw volumes as required by Oracle ASM and HDFS for Big Data applications.
Managing Min and Max IOPS with Robin
Robin is tailor made for consolidation of disparate applications. Bringing performance predictability to a consolidated environment requires end-to-end enforcement of QoS policies. Most incumbent storage products were designed in the monolithic era when application consolidation was not very common and hence QoS guarantees are either not implemented or are very rudimentary and not capable of functioning in the container era.
Robin is the only product that can guarantee both MAX and MIN IOPS at the container level and not just at the storage-volume level. Max IOPS cap prevents a single application from hogging resources and Min IOPS guarantee ensures predictable application performance.
As Robin Storage is application-aware it can distinguish IO traffic between original and cloned volumes and automatically enforce different priorities to each. Hence any application can be quickly thin-cloned without adversely affecting the performance of the original application.
Distributed Snapshot and Clone
Snapshot, Clone & Time Travel
Snapshots, cloning, and patching of multi-tiered and distributed applications require complex coordination among containers, network, and the storage stack. Just being storage-volume level consistent is not sufficient to guarantee application consistency. Traditional storage products are only capable of creating individual volume-level snapshots/clones but Robin’s storage layer is application-aware and it completely understands an application’s topology. Hence with just a click of a button, one can create application-consistent snapshots and clones for any application (even those that don’t have built-in snapshotting and cloning capabilities). This capability also extends to safe patching of an application and recovering from any failure via our unique application time-travel feature.
App-to-Spindle Quality of Service Control
Troubleshooting IO-related problems require end-to-end insight of the IO pipeline – all the way from the application, where IO originates, to disks, where data resides. No storage product in the market today is capable of this insight because they lack any presence on the compute side of the IO pipeline. Robin is the only infrastructure product that provides complete bi-directional insight. One can map each IO all the way from the container running an application, through the physical host on which the container is running, via the network ports used to reach the storage node and the disk on that node where data is persisted. In the reverse direction, each disk provides an up-to-date insight on which application has what type of data stored on that disk and how much of it is currently in use. Together, both these insights help in quickly identifying IO hotspots and generating chargeback & compliance reports.
How does Robin storage compare with other software-defined storage products?
|Scale-out Block Storage Choice of File System, Raw Volumes, Oracle ASM|
|Min and MAX IOPS guarantee Container, Application Cluster Level|
|Distributed Snapshots and Clones|
|High Performance, Low Latency Required for OLTP databases|
|Application Topology-Aware Storage Orchestration|
|Thin Provisioning, Compression|
Container technology such as docker and LXC, while designed to ship and run applications, is not sufficient by itself. To support seamless deployment and management of ALL applications (modern distributed or traditional enterprise), you need robust orchestration that integrates both – an application’s components and its underlying infrastructure (compute, network, and storage). Robin Fabric Controller is the brain of the Robin Platform, and is designed with the goal of simplifying application management by making infrastructure application-aware. With that in mind, Robin Application-Aware Fabric Controller is built by including some great features.
Robin Fabric Controller is unique from the rest in that it caters to all classes of applications, whether they are modern distributed or traditional enterprise applications. It also extents its scope beyond just application orchestration by also scheduling and managing the underlying compute, network, and storage infrastructure components. Thereby being the most comprehensive solution for all your enterprise needs.
1-Click Deployment for All Applications
Containerize Your Existing Enterprise Applications
Watch on-demand webinar.
To support an application on the Robin platform requires the creation of a simple YAML file called application manifest that describes application components, its dependencies, resource (compute, network, and storage) requirements, affinity and anti-affinity rules, and custom actions required for management. This makes the platform extremely extensible and thus enables deployment of various applications, be it the modern microservices-based architecture or the traditional enterprise applications. This also, truly, enables 1-click deployment of all applications, as Robin does the heavy lifting of deploying and managing both the application components and the underlying infrastructure required to support it.
Persistent Storage Volume Management
Every application will eventually require storage to persist data. Since Robin provides a persistent storage layer as part of the platform that can run on commodity hardware, there is no need to depend on external, expensive storage arrays. Most orchestration tools lack storage capabilities and provide limited storage support via abstract volume drivers. Robin’s integrated nature enables it to support features such as data locality, disk affinity and anti-affinity, data protection, IOPS quality of service, and replication for every application.
Self Service Data Management
Snapshot, clone, time travel
A common, recurring IT task is to create a duplicate copy of a production application for stress or performance testing, or for reproducing a bug. This process is often complicated and time-consuming, requires days to weeks to complete, and consumes the same amount of storage as the source copy. Robin simplifies this task by providing the ability to take scheduled and on-demand snapshots of the entire application topology. These snapshots can then be used as rudimentary backups to restore to a saved point in time or to create rapid thin clones that are both time and space efficient due to its use of copy-on-write technology. Finally, to free the administrators from the burden of this task, Robin gives self-service access to developers and testers, so they can create as many copies as they like, whenever they want, without incurring significant infrastructure costs.
Automatic & Transparent Fault Tolerance
Failover for an Oracle Database
Robin, by default, monitors and guards all applications against hardware failures. If a compute server goes down, Robin automatically reschedules the container to a different server while retaining the same hostname, IP address, and the storage volumes. This means the application either does not even realize that its node was down or will notice a downtime of only a few seconds.
Similarly, at the storage layer, Robin provides enterprise-grade data protection capability such as replication, and the ability to automatically detect disk faults and initiate repairs.
Such capabilities can also be utilized for planned maintenance to manually move containers off a host, for hardware upgrades, for rebalancing workloads across the cluster, and will invalidate the need for replacing faulty nodes with new ones for distributed apps like Hadoop, Cassandra, etc, thereby forcing a data rebalance which is time and resource intensive.
Application Scale Up and Out
Managing IOPS with Robin
A common adage about scaling is that traditional applications scale up, while modern applications scale out. While this is true given the distributed nature of modern applications, both scaling methods still hold true to this day. While scaling out is effective for steady and consistent increase in load, scale up/down is more effective for transient spikes.
Robin supports both scaling methods. It provides the ability to add nodes (with infrastructure) to distributed application clusters, and also provides the ability to dynamically and at real-time add & remove resources like CPU, memory, read and write IOPs to traditional and modern applications.
Container Managment Landscape
*Only Robin solves the hard problems
|Basic Container Orchestration|
|Persistent Storage Volume Orchestration|
|Push Button Distributed Apps Cluster Deployment|
|Container-aware, Scale-Out Storage*|
|Automated Application Cluster Scaling*|
|Guaranteed, Predictable QoS*|
|Distributed (Cluster-Level) Snapshot and Cloning*|
|Enterprise Application and Database Support (Oracle)*|
Decoupled mode allows separation of compute and storage. This enables users to right size hardware for each layer. Users can buy high CPU and memory configuration for the compute nodes and while the storage nodes can be optimized for capacity.
It also allows users to decouple compute from storage and scale each layer interdependently. Tightly coupling compute and storage requires users to scale both these layers in lock-steps which could lead to resource wastage. For instance, if users need more storage capacity for data, they are forced to add compute capacity as well. Similarly, when users just need more compute capacity, they are unnecessarily adding storage capacity as well. For
For data-heavy application, data volume growth will most likely will be much faster than growth in concurrent workload. Not having a way to scale storage independent of compute is therefore not a viable option in many case. This is one of the many reasons traditional hyper convergence is not always suitable for data-heavy workload.
If some users really like the “hyper-converged” mode, Robin supports that as well.
In converged node deployment mode both compute and storage layers are co-located on the same physical servers. This allows for data and compute locality for applications like Hadoop (to avoid network becoming a performance bottleneck while moving very large data volumes).
Only Robin provides users the flexibility to choose either decoupled or hybrid modes – or use a combination of the two – depending on the business/application needs.
Supported Hardware configurations
Robin is a platform purpose built for any data intensive workload. So, hardware configurations vary depending on the type of workload being executed. Robin recommends users to follow the application specific reference architecture guidelines in conjunction with Robin best practices.
Here is a recommended configuration to execute Hadoop workloads.
|Data Nodes||Balanced||12-16 cores||64-256 GB||12 * 2 TB disks||1 GB onboard|
|Data Nodes||Compute Intensive||12-16 cores||128-256 GB||12 * 2 TB disks||1 GB onboard|
|Data Nodes||Storage Intensive||8-12 cores||64-256 GB||12 * 16 2 TB disks||1 GB onboard|
|Name Nodes||ALL||8 cores||64-256 GB||4-6 * 2 TB disks||1 GB onboard|
|Resource Manager||ALL||8 cores||64-256 GB||4-6 * 2 TB disks||1 GB onboard|
Reduce hardware & software CAPEX, eliminate VM and data sprawl by consolidating multiple applications within a machine.
Simplify operations and improve user experience through guaranteed Application-to-Spindle Quality of Service.
Achieve operational agility & maximize developer productivity with fast application deployments, seamless application portability, and application-driven data lifecycle management.