The journey from application lifecycle management (ALM) to IT infrastructure library/IT service management (ITIL/ITSM) can be a mysterious and challenging transition. ALM usually puts the spotlight on rapid iterative development while the operations wizards use their capabilities to keep essential business services running twenty four hours a day, seven days a week—along with managing changes, often at a very rapid pace. In fact, many technology professionals thrive on creating complex applications while secretly dreading the dangerous realm of large-scale application deployments—generally resigning themselves to giving up yet another weekend. Many successful organizations are rising to this challenge and embracing zero-touch deployments. This article will help you get started on your way to implementing completely automated release and deployment.
Zero-touch Deployments—Myth or Reality?
The target goal of implementing fully automated, (i.e., zero-touch) deployments may seem like a wish that can never be fulfilled. ITIL has also been criticized for being an elusive ivory tower and idealistic framework. Deployments are complicated with many moving parts and changing requirements. In the real world, deployments are often very difficult to fully automate. Having been burned by painful deployments, many technology professionals surrender to the notion that deployments are always painful and don't even consider how they might be able to engineer their systems to be more deployment friendly. Dare we even consider the possibility that applications can be engineered to deploy smoothly in what some veterans are now calling zero-touch deployment?
Checklists Are Essential
You gotta start somewhere, and a pragmatic first step is to document on paper each step, even if only at first. While checklists are essential, they also provide the motivation for putting a full court press on automation. So checklists may be essential, but scripting and automating the build, package, and deploy is an absolute requirement.
What About Ant, Maven, and Make?
Experienced technology professionals are aware of the value of automating the build using tools like Ant, Maven, or Make. These tools are great and have withstood the test of time. Developers and build engineers use build tools to create reliable scripts to compile and package applications. Some scripts get pretty elaborate and others are elegantly simple. Whether you decide to dive into the complexities of the Maven build lifecycle supported by a repository manager or just whip together some Ant scripts, your journey to release automation needs to include these old friends.
Components and Builds
It is always wise to create your build automation in components. You might have one script that retrieves the code from the version control system (VCS) and another script for creating classes and jars, followed by configuring the packaged release for a specific environment (e.g., QA, UAT, or production). The first time that you have to switch from one VCS to another, you will realize that it is always best to break this effort into chunks, which also helps to reduce complexity and make maintenance much easier. Using components is a true best practice, although you should also plan on connecting the different components together.
Scripting the Essential Pieces Together
After you have each component working independently, you will want to be able to run the entire batch (sometimes called a job stream). This component-based approach has an additional benefit of allowing you to approach your effort in an iterative and agile way. You can quickly create a script to automate a specific piece of this effort and create scripts to run each step as part of a comprehensive and coordinated job stream. Obviously, this also makes it much easier to support and maintain each piece that is structured as a discrete step that can, in turn, be run by an end-to-end job stream.
Deployments Can Be Complex
Make no mistake, many deployments are extremely complex and you may find yourself only able to automate some parts of this effort. Deployment frameworks that implement application release and deployment automation provide the structure to help manage this complexity. This effort often involves managing many changing parts and even dealing with rapidly changing architectures. This is especially intense when the technology being built is very new—often with its own risk and changing requirements. Deployments can be tamed despite the level of complexity,.
Deployments Can Be Tamed
By breaking the deployment effort into manageable chunks, you are also able to improve traceability and visibility including IT governance. Application release and deployment automation tools provide a convenient approach that allows you to see which steps have been completed and which ones still need to be executed (or perhaps even re-executed). Compliance is also served by this approach by providing an independent build capability that may meet your audit requirements for separation of controls. IT governance and compliance are essential, although the application release and deployment automation tools framework can also be moved upstream to directly support development.
Development Benefits from Deployments
The application release and deployment automation tools framework can be moved upstream to directly support the application development effort. This is accomplished, in part, through continuous integration, including deployment to test environments and, of course, smoke testing. Development can benefit from deployment automation and even warrants design considerations to help realize the synergy of automated deployments.
Just as test-driven development has become extremely popular among many developers, so too is designing an application so that it can be easily deployed. The scope of this effort is generally just to ensure that the application can be deployed in a reliable and consistent way. These considerations directly support rapid iterative development and result in improved productivity and quality. This work does take some effort, but it yields considerable benefits from its successful implementation.
Your best approach is to start small and iteratively develop your automation based upon a checklist. Make sure that you consider the big picture throughout this effort and by all means adopt a comprehensive application release and deployment automation framework to help you manage this effort’s inherent complexities. Your reward will be improved traceability and transparency supporting IT governance and compliance. You will also see your team better able to support rapid iterative development along with improved quality and productivity.
Alon Eizenman is responsible for Nolio's technological vision and direction, including product conception, product innovation and research and development. Alon has over 13 years of management experience in emerging and high growth enterprise software. He served as VP R&D and co-founder of Coridan (acquired by BEA), along with senior research and development positions at Mercury Interactive (acquired by HP) and Conduct (acquired by Mercury Interactive). Alon has broad experience in conception complete product life-cycle development of enterprise and information technology software. He holds a B.Sc. in Mathematics & Computer Science from the Bar-Ilan University.