![\"software-configuration-and-release-management-best-practices\"](\"http:\/\/www.scmgalaxy.com\/tutorials\/wp-content\/uploads\/2010\/05\/software-configuration-and-.png\")
<\/p>\n<\/p>\n
Introduction<\/span><\/span><\/strong><\/p>\n The development of software applications is an <\/span><\/a><\/a>evolutionary<\/span><\/span> process, moving towards some predetermined end goals. These goals are usually in the form of a Release<\/strong>, either internal or external, to deliver a set of required functionality. Software Release Management <\/strong>is the process of ensuring releases can be reliably planned, scheduled and successfully transitioned (deployed<\/strong>) to Test and Live Environments. Software Release Management is not just about “automating the path to production” although that is certainly an important part. It also about adopting a holistic view of application changes, using the “Release” as the container to ensure that changes are packaged, released and tested in a repeatable and controlled manner. Release Management is often likened to the conductor of an orchestra, with the individual changes to be implemented the various instruments within it. Software Release Management is intrinsically linked with the more well understood and adopted Software Change and Configuration Management <\/strong>disciplines.<\/span><\/span><\/p>\n This article defines a set of good practices for helping in the successful adoption of Software Release Management. Although this article is about Software Release Management, many of the practices are generic and can also apply to Release Management in its wider sense as described in the <\/span><\/span>IT Infrastructure Library (ITIL<\/span><\/span><\/a>) whereby all aspects of hardware installation (e.g. do we need new PCs?), infrastructure upgrade (e.g. do we need to upgrade inter-site links?) and end-user training are considered. In some cases such a release might not include any software artefacts at all.<\/span><\/span><\/p>\n Defintions<\/span><\/span><\/strong><\/p>\n In order to define some good practices it is first worth defining some terms which are used in Software Release Management. The following table lists of set of generic terms which are taken both from service management and application development.<\/span><\/span><\/p>\n Term<\/span><\/strong><\/p>\n<\/td>\n Definition<\/span><\/strong><\/p>\n<\/td>\n<\/tr>\n RFC (Request for Change)<\/span><\/strong><\/p>\n<\/td>\n A high-level change request that captures the detail of a change that is to be made to a new or existing application. RFCs are usually decomposed down to lower level work requests or tasks for software development.<\/span><\/p>\n<\/td>\n<\/tr>\n CAB (Change Advisory Board)<\/span><\/strong><\/p>\n<\/td>\n The collection of stakeholders who review all RFCs at specific intervals to assess whether they should be implemented, assign priorities and allocated them to a Release.<\/span><\/p>\n<\/td>\n<\/tr>\n Release<\/span><\/strong><\/p>\n<\/td>\n A stable, executable version of a product\u00a0 intended for deployment to testing and production.<\/span><\/p>\n<\/td>\n<\/tr>\n Release Package<\/span><\/strong><\/p>\n<\/td>\n A logical container that defines the set of RFCs and Deployment Units (sometimes called Release Units) that are to be included in a Release. It also includes metadata such as the type of release (see Release Type) and its planned dates (see Release Calendar).<\/span><\/p>\n<\/td>\n<\/tr>\n Release Type<\/span><\/strong><\/p>\n<\/td>\n The type of release that is to be implemented, i.e. Major, Minor, Emergency. Each Release Type will usually have a different workflow.<\/span><\/p>\n<\/td>\n<\/tr>\n Release Policy<\/span><\/strong><\/p>\n<\/td>\n An organizations published policy that determines under which circumstances different Release Types should be used as well as the standard set of milestones that selecting a particular Release Type implies in the Release Calendar.<\/span><\/p>\n<\/td>\n<\/tr>\n Release Calendar<\/span><\/strong><\/p>\n<\/td>\n A set of published milestones that details when Releases are planned to transition through the different development, test and production phases.<\/span><\/p>\n<\/td>\n<\/tr>\n Baseline<\/span><\/strong><\/p>\n<\/td>\n A snapshot of the exact versions of Configuration Items, including executables, libraries, configuration files and documentation that are to be deployed.<\/span><\/p>\n<\/td>\n<\/tr>\n Build<\/span><\/strong><\/p>\n<\/td>\n An operational version of a product or part of a product. Not all builds are released but builds are typically carried to transform inputs (source code) into executed and installable Deployment Units.<\/span><\/p>\n<\/td>\n<\/tr>\n Deployment Unit<\/span><\/strong><\/p>\n<\/td>\n A physical, self-contained, installable release of an application.<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n An example of how these different definitions relate to one another is illustrated in the diagram below:<\/span><\/span><\/p>\n The Best Practices<\/span><\/span><\/strong><\/p>\n The following good practices are based on many years implementing and observing Software Release Management. They are listed in no particular priority or order.<\/span><\/span><\/p>\n 1. Define regular, targeted release dates<\/span><\/span><\/strong> 2. Always have a tested back-out plan<\/span><\/span><\/strong> 3. Have a documented Release Policy<\/span><\/span><\/strong> 4. Construct Deployment Units as early as possible<\/span><\/span><\/strong> 5. Use an independent team to construct all external releases<\/span><\/span><\/strong> 6. All deployments should be performed by a team independent of the Development team<\/span><\/span><\/strong> 7. Test the deployment process at least once before deploying to Live<\/span><\/span><\/strong> 8. Automate as much as possible \u2013 use integrated tools for Configuration, Change Management and Deployment Management<\/span><\/span><\/strong> 9. Use a mature Software Configuration Management process and tool to support the development of multiple releases in parallel<\/span><\/span><\/strong> 10. Link all release documentation and scripts to your Deployment Unit<\/span><\/span><\/strong> \n","protected":false},"excerpt":{"rendered":" Introduction The development of software applications is an evolutionary process, moving towards some predetermined end goals. These goals are usually in the form of a Release, either internal or external, to deliver a set of required functionality. Software Release Management is the process of ensuring releases can be reliably planned, scheduled and successfully transitioned (deployed)…<\/p>\n","protected":false},"author":1,"featured_media":4377,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_kad_post_transparent":"","_kad_post_title":"","_kad_post_layout":"","_kad_post_sidebar_id":"","_kad_post_content_style":"","_kad_post_vertical_padding":"","_kad_post_feature":"","_kad_post_feature_position":"","_kad_post_header":false,"_kad_post_footer":false,"_kad_post_classname":"","_joinchat":[],"footnotes":""},"categories":[2],"tags":[4137,282,4143,2709,4145,244,4146,92,4142,4139,4140,4144,179,4138,4141],"class_list":["post-257","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-uncategorised","tag-best-pactices","tag-configuration","tag-configuration-management-best-practices","tag-good-practices","tag-intruction","tag-management","tag-recommend","tag-release","tag-release-management-best-practices","tag-scrm","tag-scrm-best-practices","tag-scrm-best-practices-guide","tag-software","tag-software-configuration-and-release-management","tag-software-configuration-and-release-management-best-practices"],"_links":{"self":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/257","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/comments?post=257"}],"version-history":[{"count":3,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/257\/revisions"}],"predecessor-version":[{"id":4380,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/257\/revisions\/4380"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/media\/4377"}],"wp:attachment":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/media?parent=257"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/categories?post=257"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/tags?post=257"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}\n\n
\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
\nYou should strictly plan and manage your releases and deliver releases regularly. Create a Release Calendar<\/strong> for each type Product’s Release Package<\/strong> to ensure that release progress is effectively communicated and planned. If a number of releases are being developed in parallel, create and communicate a high-level release milestone plan. The Release Calendar should communicate both internal (development, testing) and external (deployment to live) milestones. The Release Packages and Release Calendar are more easily managed and communicated if the details are kept within a database or workflow tool.<\/span><\/span><\/p>\n
\nFor releases that are being deployed to managed live environments you should always have a tested back-out plan. For example, if you deploy a new Internet Banking product release onto the live servers and subsequently find that there are problems with it, there should be a process in place for removing this release and rolling back to the previous one. In this scenario it is desirable that this process is as automatic as possible. The acceptance testing and rollout scenario should be part of the workflow defined for each Release Package<\/strong>.<\/span><\/span><\/p>\n
\nYour Software Release Management processes and policies should be clearly defined and documented. This should include the definition of the types of release you will manage, their workflows, the default calendars, as well as roles, responsibilities and artifacts. Usually this type of information is captured in a Release Management Plan<\/strong>. Make sure that this plan clearly states who is responsible for each part of the release process, i.e. who plans and manages the release, who builds and delivers the release internally and who packages and deploys the release externally. All the artefacts that are to be produced as part of the release process, i.e. Release Plan, Release Notes, Installation Instructions, should be clearly documented (and example templates given) along with who is responsible for generating them.<\/span><\/span><\/p>\n
\nEvery time you build your application you should be constructing Deployment Units<\/strong> with the potential to be installed, for example a J2EE .EAR file or a Windows .MSI package. These Deployment Units might not be released beyond the development team but the point is that the build, packaging and installation process is proven early and at each phase.<\/span><\/span><\/p>\n
\nIf your team is very small then the developers might be able to carry out the build and construct the Deployment Unit<\/strong>. However, for any medium to large size product it is desirable to have a separate release team. This team usually manages the build process and packages up the results of the build into the Deployment Unit. They usually deploy internally (and sometimes externally) or pass the deployment unit to a separate deployment team. The release team is also responsible for creating the logical Release Package’s and communicating release dates.<\/span><\/span><\/p>\n
\nDevelopers should not be allowed to transition Deployment Units into a live environment. There is a potential conflict of interests in this situation. For audit ability and traceability it is better to have a separate team deploy the release to Live (and usually Acceptance Testing)<\/span><\/span><\/p>\n
\nThe deployment process should be tested at least once before any release is put into a live environment. This is normally carried out by having an Acceptance Test environment that mimics the live environment and is controlled in the same way.<\/span><\/span><\/p>\n
\nSoftware Release Management can be a repetitive and error prone manual process, therefore as much as possible should be automated. At the very least, the inputs and outputs of the release process (including the build components and release documentation) should be versioned using a Configuration Management tool (e.g Perforce,Subversion,Clearcase,TFS,etc) A Change Management tool can be used for controlling the content of the release and making Requests For Changes (RFCs) to it. A Deployment Management tool can be used to move the release to different environments or to install onto multiple desktop machines. Obviously, this all works best if these tools are integrated through to the Release Management process and its supporting tool(s).<\/span><\/span><\/p>\n
\nWhen you are developing, building and deploying multiple releases in parallel it is critical that you have a Software Configuration Management tool that supports parallel development. Such tools are sometimes high-end, expensive toolsets (not open-source\u00a0 but they can significantly help to automate and reduce errors in the otherwise manual branching and merging process.<\/span><\/span><\/p>\n
\nWhen a release is deployed you should be able to identify from the Deployment Unit <\/strong>all the related hardware and software that is required to support the release.\u00a0 The Release Package is a good container for managing these relationships. The Release<\/strong> Package <\/strong>can either relate all this together in documentation form or better still reference entries in a database. Such a database should identify for each product that is built and released: the required hardware, supporting third-party software and the Installation and Configuration instructions. In the <\/span><\/span>ITIL<\/span><\/span><\/a> world such a database is often called the CMDB (Configuration Management Database).<\/span><\/span><\/p>\n