ROBIN FOR ENTERPRISE APPLICATIONS

Enterprise Application Lifecycle Management Challenge

Traditional enterprise applications are the lifeblood of any business. Many of these applications were written more than a decade ago, and yet most companies are still struggling to deploy and operate these applications using the existing data center infrastructure and tooling. This puts an enormous burden on application developers and IT administrators to manually deploy applications and its dependencies, manage data lifecycle, and deliver the desired quality of service, all while meeting business SLAs.

Virtualization hasn’t helped ease management problems either. While Web and App components can be deployed in VMs, the supporting Database is often deployed on bare metal servers for performance reasons. This makes matters worse as the management processes and tools radically differ across application tiers and also between production and non-production environments.

Robin Addresses

Robin Solution for Enterprise Applications

Containers are lightweight, fast, agile, and solve all dependency issues related to the applications. Unfortunately, container technology like Docker has seen adoption mostly amongst new age applications – stateless, cloud-native, mobile, etc. The buzz created by Docker and microservices is so loud, that it often makes companies undertake unrealistic projects like rewriting their large estate of Enterprise Applications. Unfortunately, such projects are often time-consuming and an exercise in futility. Does this mean your existing enterprise application continue to suffer their current fate and not benefit from the advantages of containers?

Virtualization benefits with guaranteed bare metal performance – Robin’s container-powered virtualization platform gives the existing enterprise applications a new life. On the Robin platform, applications gain all the benefits of virtualization, but with guaranteed bare metal performance.

Benefits for Your Enterprise Applications

1-Click Deployment for all Applications

Ridiculously Simple - Robin for Docker & DevOPS
  • Simple and extensible mechanism for supporting packaged and custom applications
  • Create simple YAML file called application manifest to log all management requirements
  • Supply deployment inputs, leave all other processes to Robin

Containerize Your Existing Enterprise Applications
Watch on-demand webinar.

Robin provides a simple and extensible mechanism for supporting packaged and custom applications. The typical enterprise application is written in Java, Ruby, Python, etc and has a notion of a single logical application server and database.
To simplify deployment of such applications, Robin requires the creation of a simple YAML file called application manifest that describes the application components, container images (docker or LxC) for the components, its dependencies, resource (compute, network, and storage) requirements, affinity and anti-affinity rules, and custom actions required for management. The user is simply required to supply deployment inputs, and the rest of the heavy lifting like container placement, volume creation, data protection, replication, networking, etc is taken care of by Robin

Guaranteed App-to-Spindle Performance

performance-app-to-spindle-guarantee-robin-for-databases
  • 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.

Given the low average server utilization across the IT industry, consolidation has been the ultimate goal for most IT organizations. Unfortunately running multiple applications on the same hardware can lead to noisy neighbor issues, where applications compete with each other for resources and in turn suffer through unpredictable performance. This is very prevalent amongst databases which tend be very throughput and latency intensive, and any IO contention can impact the entire application performance.

Robin enables real multi-tenancy and consolidation by providing performance isolation for all applications. Robin’s unique App-to-Spindle Quality-of-Service Guarantee ensures that each application gets the exact amount of resources they desire. For each application, Robin allows administrators to set cpu, memory, and IOPS values, and these are honored no matter where the application components run on the platform. These resources values can also be changed dynamically and at real-time, without having to change any application parameters or configuration.

Full Application Clone & Time Travel

time-travel-for-applicatons-robin
  • Create duplicate copies with scheduled and on-demand snapshots of the entire application topology
  • Use snapshots as rudimentary backup to restore to a save point in time
  • Create rapid thin clones
  • Prioritize production IO over a cloned system IO
  • Avoid making a “Test Master” copy

Snapshots, Clone, Time Travel
Watch demo.

A common, recurring IT task is to create a duplicate copy of the application in production for stress or performance testing, or for reproducing a bug. Unfortunately, due to the existence of separate web/app and database operations teams and different cloning procedures, this process is often complicated and time-consuming, requires days to weeks to complete, and consumes an enormous amount of storage as compared to 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. With Robin, recovering from a bad upgrade or from data corruption, and the ability to create exact copies is reduced down to a single click action. Developers and testers now have self-service access to create as many copies as they like, whenever they want, and without incurring significant infrastructure costs.

Robin also identifies IO requests from a cloned application and can prioritize the production IO over the IO from a cloned system. This enables cloning directly from the production environment, and avoid the cost of maintaining an intermediate copy, often referred to as a ‘Test Master’ copy.

Automatic & Transparent Fault Tolerance

automatic-transparent-fault-tolerance
  • Monitor and guard all applications against hardware failures
  • Automatically reschedule a failed component to a different server
  • Retain same hostname, IP address and the storage volumes for a rescheduled failed component
  • Gain enterprise-grade data protection including replication, automatic disk fault detection, and initiation of repairs

Failover for an Oracle Database
Watch demo.

For most enterprise applications, high availability and automatic failover are critical. Unfortunately, each component of the application has its own solution for this. Enterprises, often, settle on a proprietary solution for the database, but leverage VM HA for the web and app components. While this may work on paper, it is complicated to maintain, very expensive, and can lead to unhandled application failures.

Robin, by default, monitors and guards all applications against hardware failures. If a compute server goes down, Robin automatically reschedules the failed component to a different server while retaining the same hostname, IP address, and the storage volumes. This ensures the application either does not even realize that its node was down, or will notice a downtime of only a few seconds. This capability is key for traditional applications which unlike modern distributed applications, were not designed to withstand prolonged downtime of its nodes.

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.

Application Scale Up and Out

application-scale-up-scale-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.

Typical enterprise applications tend to be very read and write intensive. Consequently, the performance of an enterprise application is heavily dependent on the database performance.

Robin supports both multiple forms of scaling. It provides the ability to add nodes (with underlying infrastructure) to the application server or database clusters, and also provides the ability to dynamically and at real-time add & remove resources like CPU, memory, read and write IOPs to application components.

With flexibility like this, Robin allows you to apply the appropriate scaling techniques to the appropriate tiers. For example, the web and app tiers, typically, benefit from horizontal scaling with the addition of new instances and their registration with a load balancer, while for the database layer, you would rather add or remove IOPs or CPUs based on the workload needs.