From Code to Deployment: A Complete Hands-On Guide to CI/CD!

DevOps continues to grow in popularity among software development teams. It’s not surprising, given the benefitss: a streamlined workflow leads to faster release frequency and deployment cycles, quicker bug detection, efficient rollback in case of any error, and a more productive team overall. DevOps engineers ensure that the processes and practices of code development, testing, and release are streamlined to reduce inefficiency, risk, and time to market. Coupled with continuous integration (CI) and continuous delivery (CD), DevOps helps IT organizations streamline their development process by automating manual tasks related to code deployment. Let’s explore how you can adopt CI/CD to improve your organization’s efficiency and delivery pipeline.

Continuous Integration

First, let’s take a look at what CI/CD is and what its benefits are. Although these two concepts are often discussed together, each has its own role in the software development process.

Continuous integration is the process of automating the build and testing of code. It requires a SaaS build service (like Harness Hosted Builds) or an on-premise build server responsible for taking code from a source control system (such as Git), compiling it, and testing it to ensure it’s error-free. This helps to keep software projects on track by ensuring that errors/mistakes/bugs get spotted as soon as they occur. If a build is broken, it halts the rest of the process until it’s been fixed. As a result, the build process is much more streamlined.

Continuous Delivery & Deployment

Continuous delivery automates the release process. It ensures that code is always in a releasable state. This process includes taking the code from the build system and routing it through a staging environment to ensure it’s suitable for release. The outcome is a fully automated deployment process, which can be controlled by the team or triggered by triggers outside the team (such as when a developer pushes or commits a code to the main branch). The key difference between CI and CD is that the former is focused on building code, while the latter focuses on releasing the final product.

The below diagram depicts the difference between CI, CD, and continuous deployment.

Continuous deployment is the final and most desired stage of the CI/CD process. It’s the point at which the team can deploy the code with zero-touch automation. This is the difference between continuous delivery and deployment. When the deployment of the code is done via manual intervention, it is delivery. However, if the code is deployed in an automated fashion without any manual intervention, it is called continuous deployment.

How to Implement CI/CD in Your Organization

Before implementing CI/CD in your organization, you should know why you are implementing it, the goal, and which metric you would like to focus on. For example, DevOps teams usually focus on four key (DORA) metrics:

• Lead time for changes
• Change failure rate
• Deployment frequency
• Mean time to recovery

Your goal with CI/CD can also be as simple as moving away from traditional software delivery practices to cloud-native ones. This way, understanding the basics of DevOps concepts becomes very important.

If you haven't already, you may need to adopt a version control system, implement a build system, and introduce staging environments. Once these basics are in place, you can begin the CI/CD process:

1. First, you’ll start with CI. This process ensures the code is tested and is clean and ready to deploy.
2. You can then move on to the CD part, where you’ll be able to deploy code to staging and ready for review by the team.
3. You can deploy the code to the production environment once everything is approved.

Next, you need to evaluate different CI/CD tools to understand which best suits your organization. Unfortunately, there are a plethora of tools that can be overwhelming to some of you. In this article, we will use a prominent CI/CD tool, Harness, to explain how CI/CD works through a simple hello world application. A well-established CI/CD pipeline also makes it easier for your team to identify areas for improvement and take action to mitigate risks that may exist in your system. It also makes it easier to implement process changes as your team grows and changes over time.

CI/CD Tutorial

Pre-Requisites

• Free Harness account to do CI/CD (on-premise)
• Kubernetes cluster access from any cloud provider to deploy our application (you can also use Minikube or Kind to create a single node cluster).
• Docker, preferably Docker Desktop
• Download and install Node.js

Follow the complete step-by-step tutorial shared below.

Learn How to Build and Push a Docker Image to a Container Registry

Docker has become a popular tool in DevOps for the containerisation and deployment of applications. It provides a standardised way to package applications along with their dependencies and runtime environment into a container, which can be easily distributed and run on different environments. To make this process even more efficient, container registries have been introduced, which allow developers to store and manage their container images. In this tutorial, we will walk through the process of building a Docker image, configuring and pushing it to a container registry. By the end of this tutorial, you will have a better understanding of the containerisation process and be able to use container registries for efficient and scalable deployment of your Docker applications.

What is a Docker Image?

A Docker image is a lightweight, standalone, and executable package that contains everything needed to run an application, including the application code, runtime, libraries, and system tools. Docker images are created using a Dockerfile, which is a script that specifies the steps to build the image.

To build a Docker image, you need to first create a Dockerfile that specifies the base image, any additional dependencies, and the commands to install and configure the application. Once the Dockerfile is created, you can use the "docker build" command to build the image.

The "docker build" command takes the path to the Dockerfile and uses it to build the image. The command first reads the Dockerfile, downloads any necessary dependencies, and creates an image from the specified configuration. The resulting image can then be used to run containers.

Here are the basic steps to build a Docker image:

We will automate the above process using Harness, a continuous delivery tool. We just need to have the Dockerfile in the application repository (which we have in our sample repo).

Building a Docker image is an essential step in the containerisation process, as it allows developers to package their applications in a standardised and portable format that can be easily shared and deployed.

Prerequisites

• Docker, preferably Docker Desktop
• Free Harness CI module to automate the process of building and pushing our Docker image
• A sample application to experiment. We have a sample Node.js application repository. Fork it and use it.
• A free Docker Hub account. We will be using DockerHub as our container registry to push our image.

Below is a complete step-by-step tutorial on how to build and push a Docker image to a container registry.

Accelerate CI/CD with Ephemeral Environments

Gone are the days when manual testing and deployment used to take days to complete. These new tools automate and streamline the software development pipeline. Typically, whenever any application is created, it’s entered into a continuous integration (CI) tool or platform that tests the code through various frameworks. If the tests are passed, the code will be deployed.

However, increasing velocity is difficult if your processes and tools are tedious and complex to configure. That’s why ease of use is non-negotiable for every developer evaluating any new tool. Developers like a CI tool that’s not only easy to set up but can also scale to test their applications. Configuring infrastructure and other related tasks is daunting and time-consuming, taking resources away from deployments.

This is where a concept called ephemeral environments comes in. Ephemeral environments can be used to test your applications much faster by spinning up short-lived environment instances and automatically destroyed after the work is done. This tutorial will discuss ephemeral environments, how they work, and how to configure them.

What are Ephemeral Environments?

Ephemeral environments are an excellent way for engineering and development teams to collaborate and test new features quickly and efficiently. They provide a temporary, isolated environment for running tests and previewing features without worrying about making any permanent changes that may impact production systems. This allows for rapid iteration and development without committing to long-term changes.

Configuring an ephemeral environment allows you to customize the environment to meet specific needs and preferences, such as the preferred operating system, number of servers, or type of memory and storage. Once the environment is set up, you can utilize that environment to run tests and experiments on your application.

Running an application in an ephemeral environment is relatively simple. All of the necessary files and configurations will be packaged into a single deployable artifact. This can then be deployed to the ephemeral environment and quickly spun up, allowing for rapid application development and testing.

The process is usually automated, allowing for continuous deployments and the environment to be easily rolled back if necessary. Additionally, the process can be configured to run certain tests or other checks before the deployment is finalized. This helps ensure that the application runs as expected and is free of errors or issues.

Create Ephemeral Environments

Harness is a modern continuous delivery platform helping various organizations with their DevOps journey.

With Harness, you can setup and configure ephemeral environments automatically. With just a click of a button, you will be presented with an environment to utilize. Harness offers hosted virtual machines (VMs) to run your builds, so you can test and build your code without worrying about setting up anything. Harness can provide the infrastructure, so you can focus on developing great software.

Learn how to create ephemeral environments from this step-by-step tutorial.

Mastering CI/CD is a critical skill for any software development team. It enables teams to stay competitive in the fast-paced world of software development, and deliver high-quality software quickly and reliably. By implementing a robust CI/CD pipeline and continuously improving it, teams can achieve their goals and deliver value to their customers.

Deploying an Application on Kubernetes

Kubernetes is an open-source platform for automating the deployment, scaling, and management of containerized applications. It is a popular tool for container orchestration and provides a way to manage large numbers of containers as a single unit rather than having to manage each container individually.

Importance of Kubernetes

Kubernetes has become an essential tool for managing and deploying modern applications, and its importance lies in its ability to provide a unified platform for automating and scaling the deployment, management, and scaling of applications. With Kubernetes, organizations can achieve increased efficiency and agility in their development and deployment processes, resulting in faster time to market and reduced operational costs. Kubernetes also provides a high degree of scalability, allowing organizations to scale their applications as their business grows and evolves easily.

Today, we will see how to automate simple application deployment on Kubernetes using Harness.

Prerequisites

• Free Harness cloud account
• Download and install Node.js and npm
• GitHub account, we will be using our sample notes application
• Kubernetes cluster access, you can use Minikube or Kind to create a single-node cluster

Below is a complete tutorial that shows how to deploy an application on Kubernetes.

I hope you enjoyed this month's newsletter. I'll be consistent from now on and promise to share more such fabulous tech pieces in the coming days.

If you liked the newsletter content, kindly give a like, share and subscribe to the Developer Advocacy newsletter.