Architecture

Hyper-Converged Kubernetes for Big Data, Databases and AI/ML

Hyperconverged Kubernetes White Paper

Application Management

ROBIN’s Application Management layer is the “intelligent” component of the Robin platform. This is the management component that orchestrates the entire infrastructure from an application perspective and manages data as well as Application lifecycle.

1-Click Deployment

Taking an application as the payload, the application-aware manager automatically decides the placement, provisions containers and storage for each application component, and configures the application – thus enabling 1-click deployment of even the most complex applications.

High Availability

ROBIN Application management layer 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 and infrastructure QoS Guarantee.

Application-Driven Data Lifecycle Management

ROBIN’s application-centric data management approach greatly simplifies application lifecycle management. The 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 a minuscule amount of additional storage. Even a 100TB database can be cloned in a snap using only a few GBs of additional storage.

Container Technology

ROBIN hyper-converged Kubernetes platform leverages container technology to consolidate applications with complete runtime isolation. A container is a lightweight, OS-based virtualization technology that allows the 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.

Performance-Sensitive Workloads

ROBIN is the first and only product in the industry that brings application lifecycle management benefits to all types of enterprise applications – including Kubernetes-based highly performance-sensitive workloads such as big datadatabases, indexing and search, and AI/ML.

Appropriate Container Configuration

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.

High Availability

When used with bare-metal servers, ROBIN enables “zero-performance-impact” consolidation of data-heavy databases, and other distributed applications such as Elasticsearch, with Application lifecycle management features, resulting in significant operational efficiency gains and cost reduction.

ROBIN Storage

As opposed to traditional storage technology, ROBIN hyper-converged Kubernetes platform storage is industry’s first application-aware storage subsystem 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. With ROBIN you can get decoupled compute and storage, application-driven data lifecycle management, and intelligent data protection.

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.

Storage Persistency

Many Big Data and Database applications predate both Docker and Kubernetes and have made strong assumptions around how network and storage persistency is preserved in the event of POD restarts.  ROBIN’s handling of both network and storage ensures that these applications function correctly when running on a Kubernetes cluster.

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 web servers, are allocated standard volumes.

By providing enterprise-grade data protection at the storage layer, ROBIN obviates the need for 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 Storage Benefits

  • Allocate storage while deploying an application or cluster
  • Share storage among apps and users
  • Get SLA guarantees when consolidating
  • Support for data locality, affinity, anti-affinity and isolation constraints
  • Tackle storage for applications that modify the Root Filesystem

ROBIN Networking

ROBIN hyper-converged Kubernetes platform extends Kubernetes networking via both Calico and Open vSwitch based CNI drivers. This offers flexibility in using either overlay networks to create flexible L3 subnets that span multiple data centers or cloud environments or use bridged networking to get wire-speed network access for high-performance applications. In both modes, ROBIN also enhances the CNI driver to retain the IP address of the POD when it is restarted or moved from one host to another. This provides greater flexibility during scaling, migration and high availability.

ROBIN Networking Benefits

  • Set networking options while deploying applications and clusters
  • Provide network persistence in the event of Application Pod failures
  • Gain flexibility during scaling, migrate, on and availability
  • Ensure with ROBIN networking that the applications function well while running on Kubernetes cluster
  • Leverage Calico and Open vSwitch based CNI drivers
  • Get enhanced CNI driver to retain IP addresses during a move or restart

ROBIN Hyper-Converged Kubernetes Platform

For big data, databases, and AI/ML

ROBIN hyper-converged Kubernetes platform is a Container-based pure software solution that sits between the application and the infrastructure, lets application workflows dynamically control storage, compute, and networking resources, across on-premise and cloud. It requires no changes to the applications, has REST APIs and hooks to interface with the rest of your environment.

ROBIN CLI/GUI – Robin programs Kubernetes – The RCM automates all tasks pertaining to the creation, scheduling and operation of clusters, and equips each cluster with dynamic QoS controls for CPU, memory, network and storage. RCM also provides data locality with data-aware placement of containers and auto-creates StatefulSets, Persistent Volumes, Claims, Services, etc., to meet application needs.
Helm – Kubernetes can become very complex with all the objects you need to handle ― such as ConfigMaps, services, pods, Persistent Volumes ― in addition to the number of releases you need to manage. These can be managed with Kubernetes Helm and ROBIN brings 1-click simplicity to Helm tasks.
Built-in flexible networking – OVS, Calico, VLAN, Overlay networking – Set networking options while deploying apps and clusters in Kubernetes and preserve IP addresses during restarts.
Built-in Robin Application-Aware Scale-Out Storage – Allocate storage while deploying an application or cluster – Share storage among apps and users – Get SLA guarantees when consolidating – Support for data locality, affinity, anti-affinity and isolation constraints – Tackle storage for applications that modify the Root filesystem.
Kubectl – Kubernetes command-line interface (CLI)—kubectl—allows for running commands against Kubernetes clusters.