In conjunction with our last article, Automated Builds, highly configurable software takes advantage of automated deployments to further streamline the process. A singular deployable artifact for all environments is the key characteristic produced by highly configurable software that is vital to automated deployments. A singular deployable artifact is defined as the output from an automated build process that does not require further modification to be deployed to any environment. Modification is defined as any changes to the artifact such as unpacking it to switch or modify file(s). A singular configurable artifact produces horizontally, scalable deployments and saves time by eliminating human errors in the deployment process.
Let us look at an example. Assume that Application A is to be deployed onto one-thousand different servers. In a typical software project, each instance of the deployed application requires custom configuration before it is usable. Most projects apply these changes at build time, causing an inefficient process that results in one-thousand different builds. Even with automation, this incurs an enormous loss of time in redundant build cycles. Alternatively, highly configurable software enforces that one build cycle will be used across each of those one-thousand servers. To use this singular deployable artifact across many environments, it is recommended to use a centralized repository management solution that stores each version of the resulting artifacts. This creates a centralized location where automated deployment systems can find and use these artifacts.
Through our use of automated deployments, we have found several common pitfalls that must be avoided. First, as the number of servers grow, the number of properties should not grow linearly. Each new environment may incur some subset of new properties, but the properties should not grow at an order of magnitude. For example, if the application starts with five hundred properties, adding a new server should not add another five hundred properties. This does not scale as the deployed environment grows and is an indicator that properties are being blatantly duplicated. Another common pitfall that we have observed is manually managing post deployment property updates across servers. Identifying the correct updates on each individual server is a time-consuming, manual task that introduces human error and these properties tend not to be stored using any configuration management. Ideally, there should never be configuration changes required after the deployable artifact is built. Hierarchical properties in conjunction with URI based properties solve these two common pitfalls.
In conclusion, automated deployments are a necessity in streamlining the development lifecycle. The key characteristic of automated deployments produced by highly configurable software is a singular artifact for all environments. Our next article’s topic, URI based properties, exemplifies how application configuration points stored on a centralized service complete the above design, requiring only a restart of the application in order to reconfigure the application.