Managing performance and availability for complex applications on Kubernetes - Robin
Ripul Patel speaking on Nov 18 at Cloud Native Storage Day
Robin.io delivers hyper-automation for service delivery with 1-click application pipeline deployment, much lower infrastructure and operations cost, and facilitates a hybrid cloud strategy for all Telco applications.
Define & deploy applications stack or data pipeline as a bundle on Kubernetes on-prem or in the cloud
Enable self-service provisioning and management capabilities for the entire stack
Accelerate & enhance Dev/Test collaboration with application-aware cloning
Monitor the health of infrastructure, containers, and the entire application stacks
Dynamically scale-up/scale-out in minutes, without interrupting application operations
Consolidate multiple Databases like Oracle RAC clusters to reduce hardware and licensing cost
Migrate your customized and legacy application stacks to Telco cloud without refactoring
Protect your critical application stack with application aware snapshots and backup
Digital Transformation Demands Fast-paced Innovation
Operators need to be able to add intelligence, quickly adapt the software for different services and automate to rapidly scale the network with the most efficient utilization of the hardware. At the same time, these networks must be robust & resilient.
The ROBIN Telco Platform includes an application-aware automation fabric with
built-in application-aware high-performance Storage, ultra-high-speed networking and Data Management features to support the demands of the new applications for IoT and Wireless providers.
Compute – NUMA awareness, improved performance, higher IO performance, workload isolation
Network Data Path – Multiple network interfaces, high performance and speed networking, persistent IP addresses, dual-stack IPv4 and IPv6, improved utilization, lower cost
Data Services – Deployment of any complex database, big data, time series, message queue service in minutes, policy-based auto-scaling, snapshot, backup, clone, containers and VMs on same Kubernetes platform, define and deploy end-to-end Telco stack from RAN and Core to OSS on containers
Advanced Placement and Resiliency – Advanced affinity, anti-affinity, data locality, tenant isolation, auto healing, rapid failover and data resiliency
Automation – Simplified provisioning and management, life-cycle management with always on availability, workflow upgrade, deployment of complex distributed app pipeline in minutes, pre/post workflow hooks for extensibility
Visibility – Cluster-wide events, health metrics, service mesh, observability framework
ROBIN is a Software Platform for Automating Deployment, Scaling and Life Cycle Management of Enterprise Applications on Kubernetes. ROBIN automates the provisioning and day-2 operations so that you can deliver Telco stack and the associated services with 1-click deployment simplicity and enable hyper-automation and operational efficiency for hundreds of software components from any provider.
Robin enables financial institutions to automate deployment, scaling and lifecycle management of enterprise applications on Kubernetes. Robin simplifies the containerization of critical application pipelines including fraud analytics, real-time risk detection, & deep learning which are composed of multiple stateless and stateful applications.
Digital Transformation Demands Fast-paced Innovation Digital Transformation requires IT services to be delivered in a fast, agile and streamlined manner across the entire organization. Enterprises in the Financial Services industry constantly need to innovate to attract and retain customers demanding a rich digital and mobile experience. It is also critical to analyze security threats across diverse systems and applications in real-time and at the same time meet all the compliance requirements as well as achieve continous availability for critical applications.
The industry is looking at containerization and kubernetes to achieve IT agility, however, there are many challenges that significantly impact the ability of technology leaders to innovate: Infrastructure silos – Owing to years of organic growth, the application infrastructure landscape is very diverse.
Managing legacy applications and modern cloud-native applications at the same time can be challenging. Traditional methods take weeks to provision legacy applications or to provide dev/test refreshes. With release cycles shrinking due to the DevOps culture and modern architecture, developers need much faster turnaround times for their application pipeline that often include legacy applications, as many modern applications depend on legacy applications.
High licensing and Infrastructure costs – Creating dedicated clusters for individual “tenants” (teams, workloads, applications, etc.) is required due to challenges with performance isolation. Each cluster is deployed for peak capacity, leading to significant licensing and hardware costs.
Infrastructure lock-in – Migrating customized applications to the cloud is not easy. Locked into infrastructure choice limits your ability to scale and experiment with new ideas.
ROBIN is a Software Platform for Automating Deployment, Scaling and Life Cycle Management of Enterprise Applications on Kubernetes. ROBIN automates the provisioning and day-2 operations so that you can deliver a “Self-Service” experience with 1-click deployment simplicity for developers, DBAs, and Data Scientists
Automate Enterprise Applications on Kubernetes
Extend Kubernetes for data-intensive applications such as Oracle, Cloudera, Elastic stack, RDBMS, NoSQL, and other stateful applications.
ROBIN is a Software Platform for Automating Deployment, Scaling and Life Cycle Management of Enterprise Applications on Kubernetes. ROBIN provides a self-service App-store experience and combines containerized storage, networking, compute (Kubernetes), and the application management layer into a single system.
Robin.io helps enterprises increase productivity, lower costs – CAPEX and OPEX, and enables always-on automation with technology solutions for big data, databases, indexing and search, and industry solutions for financial services and telco.
This software-only solution runs on-premises in your private data center or in public-cloud (AWS, Azure, GCP) environments and enables 1-click deployment of any application. ROBIN enables 1-click simplicity for lifecycle management operations such as snapshot, clone, patch, upgrade, backup, restore, scale, & QoS control of the entire application. ROBIN solves fundamental challenges of running big data & databases in Kubernetes & enables deployment of an agile & flexible Kubernetes-based infrastructure for Enterprise Applications.
ROBIN Platform Stack Components
Application Management Layer – Manage Applications and configure Kubernetes, Storage & Networking with Application workflows.
Kubernetes – Run big data and databases in extended Kubernetes, eliminating limitations that restrict Kubernetes to micro-services applications.
Built-in 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, and tackle storage for applications that modify the Root filesystem.
Built-in Networking – Set networking options while deploying apps and clusters in Kubernetes and preserve IP addresses during restarts.
Rapid Deployment – Self-service 1-click
Slash deployment and management times from weeks and hours to minutes. Deploy and manage data-heavy apps and services in Kubernetes.
Control QoS – Dynamic control QoS for every resource – CPU, Memory, Network and Storage.
Get complete visibility into the underlying infrastructure, set min and max IOPs, eliminate noisy neighbor issue, and gain performance guarantee.
Rapid clones – Clone the entire application along with its data – thick, thin, or deferred.
No performance penalties, backup data with ease, share data among users and applications, among dev, test, and prod, with no additional storage.
Application Snapshots – Take unlimited full application cluster snapshots, which include application configuration + data
Restore or refresh a cluster to any point-in-time using snapshots. Roll back easily with 1-click to the last snapshot in case of data corruption.
Scale – Decouple compute and storage,
Scale out – add nodes. Scale up – increase CPU, Memory and IOPs.
High Availability – No single point of failure – get reliable crossover and detect failures.
Get automatic App-aware data failover for complex distributed applications on bare metal – ROBIN is the ONLY product to provide HA for apps that persist state inside Docker images.
Upgrade – Automated rolling upgrade of application containers that is integrated with
Safe-Upgrade technology guarantees that failed upgrades can be rolled back without disrupting the application.
Fortune 500 Financial Services Leader
Global Technology Company – Travel Industry
ROBIN Platform Datasheet
Digital transformation is key for competitive enterprises that need to make Customer Experience a top priority in today’s social and mobile world. To that end, Sabre, a technology leader in the hospitality industry, has made a strategic move to transform its Oracle RAC legacy environment into a self-service DBaaS using Robin.
In this webinar, Charles Hart, Senior Database Engineer at Sabre and Sricharan Mahavadi, Solution Architect at Robin, will discuss how to avoid the Oracle management issues that slow down innovation. They will illustrate how to simplify building and managing your own private cloud and database as a service for Oracle RAC on Kubernetes.
Jason Bloomberg is a leading IT industry analyst, author, keynote speaker, and globally recognized expert on multiple disruptive trends in enterprise technology and digital transformation. He is founder and president of Digital Transformation analyst firm Intellyx. He is ranked #5 on Onalytica’s list of top Digital Transformation influencers for 2018 and #15 on Jax’s list of top DevOps influencers for 2017, the only person to appear on both lists. Mr. Bloomberg is the author or coauthor of four books, including The Agile Architecture Revolution (Wiley, 2013). His next book, Low-Code for Dummies, is due later this year.
As the complexity of modern IT continues to explode with no limits in sight, organizations are increasingly leveraging cloud-native computing to bring the best practices of the cloud to their entire IT organization.
An essential enabling technology for this next-generation approach to architecting IT infrastructure is the use of containers in conjunction with the Kubernetes container orchestration platform.
Containers bring dramatically improved flexibility to the applications that enterprises put in front of customers but lack a sufficiently comprehensive way to maintain persistent information over time because containers are inherently stateless.
Managing state information in such a stateless environment, therefore, is one of the primary challenges facing enterprise deployments of Kubernetes. Both, ROBIN platform and ROBIN storage, solve the challenges by enabling stateful workloads that follow cloud-native principles.
For all its transformative power and business value, cloud computing has unquestionably been a lightning rod for hype.
This buzzwordiness continues with little hope of abating. Today, it swirls around such terms as cloud-native. In common parlance, cloud-native refers to software that developers have built-in – and for – the cloud.
This concept is strikingly important to how enterprises take advantage of the cloud – and even more so, extend the value of the cloud to their IT organizations at large.
From the enterprise perspective, this definition of cloud-native might apply to some of the new software they’re building, but the cloud-native world would forever be separated from the on-premises context for enterprise IT that has been with us for generations.
Fortunately, this definition is shifting. Today, ‘cloud-native’ is more than ‘cloud only.’ It means bringing cloud-centric best practices to software and IT generally, whether that be in the cloud or on-premises – or both.
See how easy it is for anybody to stand up an entirely new Oracle RAC environment including the grid infrastructure installation the ASM configuration and finally create the RAC database tool.
Log into the Robin Hyperconverged Kubernetes Platform console. Go straight to the application bundle screen. In this case, we just have a couple of simple bundles, one of which is our Oracle RAC bundle. So we’ll just simply click on that to provision Oracle RAC. On-click, we are immediately presented with the provisioning workflow associated with this application.
We will name our application. We’ll just call this Oracle RAC demo. Now we’ve got a couple of network interfaces we need to consider because for Oracle RAC both the public and private IP address ranges are available here. This is where we specify the public address because this is how the application will receive connection requests we’ve got the ability to specify the size of the cluster – both in terms of the number of nodes and the amount of compute and memory capacity.
This gives us the ability to shape the way in which the database will be laid out. In this case, we are going to change the default from flash to spinning disk because we, in this case, don’t have enough flash memory available for this particular deployment. We will then move down here to specify our private interconnect IP address and specify our single client address name for RAC. We’ll scroll on down to find a number of other environment variables which may be passed through robin for this deployment.
We’ve got the ability to define how we will declare ASM disk group redundancy – various credentials and then we have our placement rules where we can control how these resources will be deployed on the physical robin cluster. In this case, we need to be able to allow for multiple RAC instances on the same physical node in the cluster because we only have two nodes in our demo environment.
Simply click on provision application from that screen. This will kick off the deployment of our RAC environment. The provisioning process goes through a number of different phases beginning with the deployment of the V nodes or the actual virtual nodes or pods in the cluster running a variety of scripts to complete the configuration of the RAC environment itself from an Oracle perspective through the UI. After this, it is really just in a matter of minutes as we have our entirely fresh new RAC environment up and running.
View Provision Oracle RAC demo to learn more.
See how easy it is for anybody to stand up an entirely new Oracle RAC environment including the grid infrastructure installation the ASM configuration and finally create the RAC database tool.
You have seen how easy it is to deploy a fresh new Oracle RAC database environment. But what if we want to know how our workload might respond when adding a third node to the cluster? In other words, test the scalability of that particular workload when adding a third node.
So it’s really easy. We just click on “Scale Out” for the application and here we can define the number of nodes by which we want to extend this cluster. This is done simply by sliding across this bar but for this demonstration purpose, we need to add a single node. We can also explicitly
call out a hostname for the new node. We can go back and tweak some of the environment variables as input for this new operation but for this demo, we really don’t need to make any of these changes.
So let’s just close these out and just simply click on the “Scale Out” button to begin the process for extending our RAC cluster. Behind the scenes, Robin is making all the necessary calls to Oracle to affect the extension of the cluster – in very much the same way as you might through conventional means for any other installation ensuring that from an Oracle perspective things are all agreeable with the configuration. You can see the success of the operation in this window. We’ll close this window and now we are back on our application screen with the newly refreshed view to find that our third node has been added.
We can see the new IP addresses – the physical host on which the new container has been deployed. Let’s just jump back into the new container – rather do a similar verification to see that we have actually successfully reshaped RAC database environment with three nodes from two nodes. We now log into Oracle set our environment through SRB CTL. Let’s just do a status again of our Robin database so we can see that we’ve got our Robin three instance now, which has been added and it’s now running on our new V node.
In the new container in the Robin cluster, we can see the new vip is added and is up and running. The resources have been successfully configured across the new node and if we go back into SQL plus and log back into the database itself and do once again a query of gv$instance, we can see that we had the databases up and fully available across all three instances of the cluster. Okay, so we exit out of that. We’re back to the UI and so now what if we want to scale back in? So we need to shrink that cluster – testing is completed – so we need to shrink that cluster back to two nodes –
Watch the demo to understand how to scale back.
We have a database application that is up and running. Now let’s take a look at how easy it is to take snapshots of that application and then subsequently perform cloning operations.
Creating a snapshot is quite easy with Robin. We have the option to provide a name for the snapshot or just use the default – which is what we’ll do here. We can look at some of the operations behind the scenes that are going to occur with respect to freezing IO and quiescing the application to maintain consistency. We will then see the newly created snapshot.
From here we have the option for restoring back to that point in time or in this case we were going to perform a thin clone operation based on that snapshot. Here we want to name the clone. It’s essentially an entirely new application stack that will be stood up as part of this operation. So we need to give it a name just as we would give the original application when it was provisioned.
Therefore, we also need to specify both the public and the private IP addresses, because again, this is a RAC database application. We could tweak the capacity for this app and we’ll just leave that the same specify the private IP address and just simply launch the operation by clicking on the clone. This takes a few minutes.
We can again take a look at some of the operations that are occurring behind the scenes with respect to deploying the application. It’s relatively quick and at this point, we can close out this window.
Now we will be presented with the new application screen as it relates to this new clone cloned app with all the related information in terms of the new nodes that have been provisioned – IP addresses etc. So then if we go back and just click on the general application screen then we can get a summary. you can see the original application and the newly cloned deployment and the snapshot on which it was based.
– ESG validated how ROBIN Storage simplifies application management, protection, and portability
– ESG validated that ROBIN Storage can bring a new set of applications into the containerized world
– ROBIN Storage brings advanced data management capabilities to Kubernetes
This report describes how ROBIN Storage delivers bare-metal performance and enterprise data management for stateful containerized applications on Kubernetes.
As organizations continue to pursue digital transformation initiatives, many have adopted container technologies to streamline application needs, get applications to market faster, and make them more portable. At the same time, Kubernetes has become the orchestrator of choice for deploying, managing, and scaling containers. While development remains a key container target, more organizations are deploying containers in production applications. When ESG asked IT managers about their production container usage in 2018, 56% reported having already deployed applications in production, 24% reported testing with a plan to deploy within a year, and another 16% reported that they expected to start testing production containers in the next year.1
Why the increased interest? Container technologies abstract applications from hardware by virtualizing the operating system, which is a lightweight design that makes them efficient, reliable, scalable, and portable. Containers enable development autonomy and agility, as developers can do more on their own without IT provisioning or management. The infrastructure and staffing efficiency of containers result in lower costs and streamlined processes.
Stateless containers have no need to keep data persistent once the processes they are executing have finished. A key challenge for running enterprise-class, container-based production applications is that they are most often stateful: that is, the applications maintain data from each compute session, even when the container terminates. As a result, running applications such as databases, artificial intelligence/machine learning (AI/ML), or custom-built applications on Kubernetes requires external storage that outlasts the container. When running mission-critical processes, these applications need swift storage provisioning, predictable performance, full data protection and security, easy data sharing, and the flexibility to leverage hybrid/multi-cloud deployments.
There are numerous external storage solutions that support containers through Container Storage Interface (CSI)-compliant APIs to manage interactions between container orchestrators such as Kubernetes and storage arrays. However, these solutions do not provide the performance and data management capabilities that enterprise production applications demand. They provide storage at the volume level but cannot deliver application-level data services.
The Solution: ROBIN Storage
ROBIN Storage is a CSI-compliant, container-native, software-defined block storage solution that offers enterprise-class performance and data management capabilities for Kubernetes-orchestrated containers. It provides resilient storage (supporting HDD, SSD, and NVMe) with bare-metal performance, and has built-in data rebalancing, disk and I/O error-detection, volume rebuilds, and hotspot detection.
[button open_new_tab=”true” color=”accent-color” hover_text_color_override=”#fff” size=”jumbo” url=”/wp-content/uploads/2019/07/esg-technical-review-robin-storage-technical-review.pdf” text=”Read ESG Technical Review for ROBIN Storage” color_override=””]