You’ve been reaping the rewards of DevOps on a small scale, and your one-off DevOps effort has earned a lot of positive attention – now management would like you to implement DevOps for all the projects! So how do you spread the DevOps wealth, and what do you need to be aware of?
Delivering DevOps
What is DevOps
For this article, we’ll need shorthand “DevOps” to mean the code bits – such as bash/posh/cmd for scripting, TF/CLI for IAC, and YAML for Azure DevOps CI/CD pipelines. Start with identifying the valuable bits from your current DevOps efforts and use that as a basis for what you want to disseminate to all other projects.
Cross-Project DevOps
Not all projects will have the exact DevOps requirements. Still, over time you will build up a collection of useful scripts and templates that are generic enough to provide value across all software projects in your organization.
But you can’t simply copy/paste these files into every repo, as that would be a massive headache to manage and keep updated. Instead, you’ll want to version and package these scripts so that every project that adopts the enterprise DevOps approach can track and plan for DevOps package updates.
Custom Package Repository
The easiest way to distribute file packages is through a custom package repository. Chances are your software project is already using at least Nuget, NPM, Maven, or PyPI. Azure DevOps can create all of these kinds of repositories, which is how you can seamlessly distribute your company-proprietary DevOps package without making it publicly available. These custom repositories are also handy as a local cache for public packages.
DevOps Integration
Usually, downloaded packages are not committed to the repo, only the reference to the package – then the build/release agents download them as needed. But for DevOps packages, should be committed to the repo for a variety of reasons. To do that, include an install script with your package, like this example for an NPM package:
#!/usr/bin/env node
const path = require('path');
const fse = require('fs-extra');
const rootFolder = path.resolve('../..'); // backwards from “./node_modules/<package>”
const installFolder = `${rootFolder}/.devops`;
const oldInstallFolder = `${rootFolder}/.devops.backup`;
const nodePkgFolder = path.resolve('.');
const srcFolder = `${nodePkgFolder}/src`;
let oldFolderRenamed = false;
// rename .devops to .devops.backup
if (fse.existsSync(installFolder)) {
oldFolderRenamed = true;
if (fse.existsSync(oldInstallFolder)) {
console.log('removing last [.devops.backup] folder...');
fse.removeSync(oldInstallFolder);
}
console.log('renaming [.devops] as [.devops.backup]...');
fse.renameSync(installFolder, oldInstallFolder);
}
// copy package src folder to install folder
console.log('installing devops package...');
fse.copySync(srcFolder, installFolder);
// read version from package.json and save to installFolder
const packageJson = fse.readFileSync(`${nodePkgFolder}/package.json`);
const package = JSON.parse(packageJson);
fse.writeFileSync(`${installFolder}/pkg_version.txt`, package.id);
if (oldFolderRenamed) {
console.warn('Existing devops configuration has been backed up and replaced, please manually merge your configuration back into the new devops package!');
console.log(`Please read ${nodePkgFolder}\\changelog.md`)
} else {
console.log(`Devops package has been installed, please read ${nodePkgFolder}\\readme.md`)
}
This script copies the DevOps package from the node_modules (NPM package cache) directory into the project’s root directory. If the DevOps package directory is already present, it renames the old directory and copies it in the new one. It is then trivial to diff the old and new directories for changes and merge them.
For NPM install, use the –no-save option, as we are using NPM as a downloader/installer so it doesn’t need to save the reference in the package.json
Package Versioning
DevOps package files should be tracked in a Version Control System like Git, and each feature should then be developed in a separate branch, then PR’d, and each PR should create a new version of the DevOps package. You can then Devops your Devops by setting up CI pipelines to automatically publish new package versions whenever the master branch is changed.
Don’t forget to document! Include a readme for first-time consumers and a changelog for updates.
Adopt and Migrate Incrementally
Generally, DevOps development will follow this kind of flow:
- Implement a project-specific DevOps functionality
- Test, Fix and Refine
- Generalize and extract useful bits of functionality
- Test, Fix and Refine
- Repeat
When integrating an enterprise DevOps package, a similar process can be followed:
- Migrate project-specific DevOps functionality to use the enterprise DevOps package
- Test, Fix and Refine
- Generic and extract useful bits of functionality
- Test, Fix and Refine
- Merge the generically useful bits into the enterprise DevOps package
- Repeat
Standardize and Prevent Making Changes
A critical benefit of the DevOps package approach is that it allows for the standardization of DevOps processes across the enterprise and provides a straightforward way to keep all projects in sync. A bug fix or new process can be quickly rolled out to all consumers of the package.
Standardization could also be accomplished using Azure DevOps Pipelines or Task Groups, but any change to those will immediately affect all consumers and invisibly break things. But if the DevOps package is stored in the project repo, those projects are insulated from breaking changes and bugs.
Track Changes and Update Easily
Each project will likely have a separate set of custom configuration files that must be modified from the package baseline to customize the build and release pipelines. It is essential to separate these files and keep track of changes to them after a package update. Conversely, all the other files in the DevOps package should not be modified to ensure a smooth update. Suppose one of the package files must be modified. In that case, it should be either A) temporary with the expectation of merging the changes up to the package or B) copied locally to the custom configuration directory so that it is evident that it must be inspected during the package update process.
Enterprise DevOps Principles
To sum everything up, there are several themes here that will ensure a successful enterprise DevOps approach:
- Consistency – standardize DevOps processes across the enterprise
- Modularity – design DevOps processes so that each component is focused and reusable – follow DRY and SRP guidelines
- Resiliency/Stability – make DevOps processes resistant to unexpected changes
- Traceability – easily understand changes to DevOps processes and merge quickly
Example
Consider this NPM package:
- scripts/install.js – module install script
- src/config – all project-specific customization and scripts
- src/pipelines – enterprise-wide CI/CD pipelines
- src/scripts – enterprise-wide bash/posh/cmd scripts
- src/tf – enterprise-wide terraform templates
- src/Update-DevopsPackage.ps1 – helper script that triggers the download of the latest package
- changelog.md – description of differences between versions, upgrade notes
- package.json – NPM publishes metadata, contains version
- readme.md – introduction to DevOps package, contains getting started instructions, directory, and file descriptions
- And here’s what a consuming project may look like:
- .devops/config – src/config directory from package
- .devops/pipelines – src/pipelines directory from package
- .devops/scripts – src/scripts directory from package
- .devops/tf – src/tf directory from package
- .devops/version.txt – text file containing the package version (handy for tracking updates)
- .devops/Update-DevopsPackage.ps1 – copied from src directory from package
- src/ – project source code, etc.
Another new year, another