The 10 Foundations of DevOps for Traditional Applications: Virtual Machines are Not Dead

Copyright © 2019 VMware, Inc. All Rights Reserved.

Much has been written about the benefits of adopting containers and Kubernetes and about application refactoring and modernization to take advantage of the capabilities of these modern platforms. But what about cases where refactoring application code is either not possible or not worthwhile? Some examples could be:

• A COTS application that is business critical but not provided in containerized form.
• A large complex enterprise application where the effort and associated cost involved to refactor the entire codebase is simply not worthwhile or at least not worthwhile to complete in the near term.
• A hybrid application where some traditional, virtual machine based pieces are being retained while other new functionality is being containerized.

These applications will require non-container based provisioning and we want to ensure our traditional applications can be maintained, updated and partially or completely refactored in the most expedient way. To meet these and many other use cases for traditional application deployment we need to apply modern deployment and management principles.

In this post I’m going to look at how we would apply our 10 Foundations of DevOps, as detailed in the blog post: A Foundation for DevOps: Establishing Continuous Delivery along with our Guiding Principles of DevOps described in the VMware White paper: DevOps and Agile Development

Goals and Constraints

The high level goal of this solution is to implement a modern solution for the deployment and management of traditional applications

1. Implement the Guiding Principles of DevOps with a focus on:
   • Infrastructure as code.
   • Automate the delivery pipeline.
   • Immutable Infrastructure.
2. Address the 10 Foundations of DevOps
3. Create a standardized solution set that could be implemented across multiple clouds both private and public.

The Components

The diagram below shows the major components selected for this solution and a basic indication of how they will fit together, this is subject to change as the build out progresses.

Note: This diagram does not show the actual application code or the automated build of the artifact (application binaries).

10FoD Traditional Apps

The components for this solution have been selected with the above goals and constraints in mind. As we proceed through the build out of the solution additional components may need to be added. This is just a starting point.

Some of the highlights of the component selections are as follows:

vRealize Cloud – Cloud Assembly:

Cloud Assembly provides a GitHub integrated mechanism for creating yaml based blueprints. These blueprints can either be written to be cloud agnostic or with minor modifications can be utilized to provision to different cloud endpoints. Cloud endpoints available at the time of writing are:

• AWS
• Azure
• GCP
• vSphere-based clouds including VMware Cloud on AWS

vRealize Cloud – Code Stream

Code Stream is a CI/CD platform supporting the deployment of Cloud Assembly generated Virtual Machines with extensibility to integrate with multiple third part tools.

Bitnami Application Catalog

The Bitnami Application Catalog provides a huge selection of pre-configured templates of commonly used software stacks configured in a standardized way. These pre-configured application stacks are available for a wide range of deployment types, which, crucially for this solution include:

• AWS EC2
• Azure
• vSphere

Standardizing on Bitnami provided software stacks will mean that the baseline deployments are consistent across multiple clouds, whether we deploy to AWS EC2, Azure or vSphere.

Conclusion

By implementing the documented Guiding Principles of DevOps, the 10 Foundations of DevOps model and selecting components a standardized set of components and tools that are interoperable with multiple cloud endpoints customers can modernize the way their traditional applications are delivered, managed and maintained.

As noted above, the diagram excludes the piece of the process showing the application binary being built. There are many different tools and processes to achieve this outcome. A possible example could be to use a combination of Git, Maven and Jenkins to commit code, automate the binary build process and then store it in Artifactory.

James Wirth (@jameswwirth) is a member of the emerging technologies team within VMware Professional Services and focuses on DevOps, Site Reliability Engineering, Multi-Cloud architectures and new and emerging technologies. He is a proven cloud computing and virtualization industry veteran with over 15 years’ experience leading customers through their cloud computing journey.