Continuous integration (CI) and continuous delivery (CD) are considered best practice in software development today. In short, these are processes where builds of your code are integrated and deployed frequently. This integration with continuous delivery means that once a change is approved, it can be deployed almost immediately.
But what happens when your code is already in production? How do you deploy changes when you already have users relying on the software and experiencing it in the wild? More importantly, how do you rollback changes if something goes wrong?
To answer these questions, you need to set up a top-level CI/CD process that includes testing, deploying to production, and, if needed, rolling back.
Set Up the Environment
The first step in creating a CI/CD process is to set up the environment. This environment will consist of the type of machine you are going to use, what operating system you are going to install, what version of.NET, Python, or other programming languages you will used, and so on.
To get started, you’ll need a development machine with the required tools installed. From there, you can deploy to either a staging area or your production environment.
Create a Git Repository
A Git repository (short for “Git repository”) is a special type of storage area used in software development. It is designed to keep track of source code as it is modified over time. Git provides version control with the ability to revert back to previous states at any time. This makes it ideal for tracking and reporting changes as they happen. Creating a Git repository for your project is easy enough. Simply go to your terminal and use the following command:
$ git init
This will create a Git repository (initially empty) in the current working directory. After you’ve initialized a Git repository, you can add additional files to it using the following command:
$ git add
Now that you have a Git repository set up, you need to get the software tested. To do this, you need a machine running the latest version of Windows 10 with.NET Core installed.
Install the Nightly Builds
In addition to setting up the development environment, you also need to install the nightly builds of your chosen programming language or framework. Keep in mind that not all frameworks and programming languages are supported by all CI/CD tools. Some require additional setup that may be difficult to complete if you’re not already familiar with the process. In these cases, you may need to look into alternative solutions. But for the most part, most CI/CD tools are compatible with the majority of the frameworks and languages utilized in modern development.
Set Up Your Build Process
Once the environment is set up and you have installed the needed tools, you can set up your build process. The type of process you choose will depend on your needs. As a starting point, you can use either the integrated build system provided by Microsoft or an open-source alternative such as Jenkins or Travis CI.
The process can be as simple or as complex as you need it to be. But generally, you will want to include the following stages:
- integration testing
- functional testing
- performance testing
- security testing
- staging area or production
- automated provisioning
If you have access to multiple environments (such as staging and production), you can use either one of them as a default target for your builds. Your choice will depend on your workflow and how frequently you need to switch back and forth between the two. Regardless of which one you choose, remember to always commit the results of your builds to source control to keep record of what was tested and delivered.
Set Up Your Release Process
In addition to setting up your build process, you also need to create a release process. This process will consist of the following stages:
prepare for deployment deployment monitoring maintenance
The first part of the release process is preparing for deployment. This includes backing up any critical data, configuring the software for the targeted environment, and so on. Once this is completed, you can deploy the software to the environment and monitor its behavior. If everything goes well, you can deploy to another environment and repeat the process.
This is a fairly straightforward process and one that can be easily automated. Depending on your needs, you can use either a CI/CD tool or a suite of tools from GitHub to handle all of this for you. You may also decide to create an individual task that is attached to a commit in your version control system to track this process. This will make it much easier to identify which commits correspond with each stage of the process.
Use a Version Control System
Version control systems, such as Git, provide a lot of benefits to software development. Version control systems keep track of all changes made to a project over time. This enables them to be rolled back if needed. It also provides a historical record of all changes made, which can be used to examine the effects of any particular change. Version control systems make it much easier to track changes as the project evolves over time and ensure that each change is attributed to the person who made it.
To take advantage of all the features version control systems provide, you must first establish a convention to identify the unique changes made with each new commit. This is known as the delta algorithm and is covered in much more detail in the Git documentation. In an ideal situation, you will want to utilize the delta algorithm from the git commit command to generate a patch for each new commit. You can then use this patch to verify changes and determine what should be tested and deployed. Once this is set up, using version control should not be a problem and will make any deployment much smoother and more straightforward. Creating a patch from the changes in each commit is a simple process that can be automated using tools like git-diff or github-diff.
Test Your Code
The last but not least step in creating a CI/CD process is to test your code. This testing phase includes verifying that the code works as expected and identifying any bugs prior to deployment. To properly test your code, you will need at least two environments: one for development and one for testing. Depending on the size of the code base, you may want to create a third environment specifically for code review. During the testing phase, it’s important to ensure that you test all modes of operation (i.e., stable, edge, and nightly builds) and that all requirements are covered. To start, you can use tools such as unittest, doctest, or python’s built-in testing module. While these tools can be helpful, they are not intended to replace the need for manual testing.
In addition to unit testing, you should also engage in a form of integration testing. This involves testing the functionality of your codebase with other parts of the application or system it interacts with. For instance, if your code interacts with a data store, you should test this interaction thoroughly. One important thing to keep in mind is that integration testing should not be considered a final step in the testing phase. During this stage, you are still searching for issues that could arise as a result of the code’s deployment. In most cases, integration testing will uncover issues that were not picked up during previous stages. So doing it at this stage makes little sense since the results of the testing could be detrimental to the final release. Once all issues have been identified during testing, you can proceed to the next stage.