Application-Aware, Intelligent
Software-Defined Infrastructure Platform

Robin is the next-generation virtualized infrastructure platform that runs applications with bare-metal performance, guaranteed QoS, and application-aware infrastructure management. Robin software pools your existing commodity hardware into a scalable, elastic, fluid pool of compute and storage resources that can be dynamically allocated to applications based on business needs or QoS requirements. Robin enables you to:

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 Architecture

Application-aware intelligent software-defined infrastructure platform for application lifecycle management, bare-metal performance & guaranteed QoS

Application-Aware Agile Compute

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.

Application-Aware Scale-Out Storage

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.

Decoupled Compute and Storage

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.

Intelligent Data Protection

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.

Application-Driven Data Lifecycle Management

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.

Application-Aware Fabric Controller

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.

Bare-metal Performance
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 Features 

Block Storage 

  • Enforce application-level policies
  • Address storage needs of disparate applications
  • Format volume to file systems or use as raw volumes

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.

Guaranteed IOPS

  • Consolidate disparate applications
  • Bring performance predictability with end-to-end QoS
  • Guarantee MAX and MIN IOPS at the container-level & storage-volume level
  • Thin-clone quickly without affecting performance adversely

Managing Min and Max IOPS with Robin
Watch demo.

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

Snapshots - Robin for Docker & DevOPS
  • Single click to create application-consistent snapshots and clones for any application
  • Safe patch an application & recover from any failure with time-travel feature

Snapshot, Clone & Time Travel
Watch demo.

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.

Application-to-Spindle Insight

  • Gain complete bi-directional insight to troubleshoot IO-related problems
  • Map each IO all the way from container running to application
  • Identify IO hotspots and generate chargeback and compliance reports

App-to-Spindle Quality of Service Control
Watch demo.

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?

FeatureROBINCephGlusterEMC Scale-IO
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.

Robin Features

1-Click Deployment for All Applications

Ridiculously Simple - Robin for Docker & DevOPS
  • Enable 1-click deployment of all applications with extremely extensible platform
  • Deploy modern microservices-based architecture
  • Deploy traditional enterprise applications
  • Manage Application lifecycle

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

  • Get persistent storage layer as part of the platform
  • Run on any commodity hardware
  • Eliminate expensive storage arrays
  • Achieve data locality, disk affinity, and anti-infinity
  • Get data protection, IOPS QoS and replication for every application

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

Application cloning, thin cloning - - Robin for Docker & DevOPS
  • Take scheduled and on-demand snapshots of the entire application
  • Utilize snapshots to restore to a saved point in time
  • Use snapshots to create space-efficient thin clones leveraging copy-on-write technology
  • Free up admins by giving self-service access to developers

Snapshot, clone, time travel
Watch demo.

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

  • Guard all applications against hardware failures
  • Achieve low or no downtime
  • Gain enterprise-grade data protection
  • Save time and resources by leveraging Robin features to rebalance workloads across the cluster

Failover for an Oracle Database
Watch demo.

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

  • Scale up/down for transient spikes – Dynamically add/remove resources such as CPU, memory, read and write IOPs in real time
  • Scale out for steady and consistent increase in load – Add nodes to distributed application clusters

Managing IOPS with Robin
Watch demo.

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)*

Robin supports flexible convergence model

Decoupled Model

  • Achieve fast separation of compute and storage
  • De-link compute from storage
  • Right size hardware for each layer
  • Buy high CPU and memory configuration for compute nodes
  • Optimize storage nodes for capacity

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.

Hyperconverged Model

  • Co-locate compute and storage layer on the same physical servers
  • Enable data and compute locality for applications like Hadoop
  • Avoid performance bottlenecks while moving very large data volumes

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.

RoleWorkload PatternCPUMemoryStorageNetwork
Data NodesBalanced12-16 cores64-256 GB12 * 2 TB disks1 GB onboard
Data NodesCompute Intensive12-16 cores128-256 GB12 * 2 TB disks1 GB onboard
Data NodesStorage Intensive8-12 cores64-256 GB12 * 16 2 TB disks1 GB onboard
Name NodesALL8 cores64-256 GB4-6 * 2 TB disks1 GB onboard
Resource ManagerALL8 cores64-256 GB4-6 * 2 TB disks1 GB onboard

Robin Benefits

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.