Continuous Integration Explained With Jenkins Deployment

Benefits of continuous integration

To understand more about the importance of CI, here are some of its benefits:

Reduces Risk

The frequent testing and deployment of code reduce the risk level of the project because code defects and bugs can now be detected earlier. This means that these bugs and errors are simple to fix and take less time, making the overall process less expensive. The general operation accelerates the feedback mechanism, making communication smoother and more effective.

Early bug detection and quick bug fixes

Numerous different kinds of checks may be included in the automated testing process:

• Validate application behavior from the viewpoint of the customer;
• contrasting coding practices with accepted industry practices;
• Check code for typical security flaws;
• Find security updates in dependencies on third parties;

Including these tests in your CI pipeline, tracking their results, and improving them is probably the easiest way to keep your software at an excellent standard. A CI tool gives developers immediate feedback on whether the new code they wrote works, introduces bugs, or represents a quality regression. Early errors are the easiest to correct.

Increase the frequency with which working software is delivered

Continuous integration allows your team to automatically build and test every source code change. This serves as the foundation for your overall software delivery process to be efficient, resilient, fast, and secure.

Reduced Waiting

The interval between the development, integration, testing, and deployment of the application is drastically shortened. When this period is shortened, any potential waiting periods in the middle are also shortened. No matter what, CI makes sure that all these processes continue to take place. Continuous Integration, Continuous Deployment, and Continuous Delivery are the three terms we came across. We need to consider how the three differ from one another.

Higher Product Quality

The detection of errors is made simple by features like code review and code quality detection that are provided by continuous integration. Emails or SMS messages will alert the user if the code does not conform to the standard level or contains an error. Developers can continually hone their coding skills with the aid of code reviews.

Better Communication

Code sharing is made simple and regularized by the Continuous Delivery workflow, which works in conjunction with the Continuous Integration process. As a result, team members can work together more openly during the process. Long-term, this increases communication efficiency and ensures that everyone in the organization is speaking the same language.

Challenges of Continuous Integration

Here are some of the challenges of continuous integration:

Internal Resistance

That is most likely a subjective disadvantage, but it is still a common one. Not all developers are willing to take on the challenge of relearning processes to save time. They may prefer to complete their tasks without the use of bureaucratic procedures. The practices outlined above, however, should overcome the unwillingness to learn something new.

Organizational Culture Shifts

When it comes to software development, many businesses still favor traditional methodologies. They would need to retrain their staff and alter current procedures to implement continuous integration. Most businesses tend to be resistant to change and want to quickly achieve their goals.

Higher Costs

Adopting CI/CD-based development necessitates significant effort, time, and financial investment. Hiring and retaining DevOps engineers, as well as putting your repositories in Git, are just a few of the processes that must be completed. However, there is some good news. All of the processes are manageable. All you need is a good budget planning strategy.

Not Easy to Maintain

It is not easy to create an automated code repository. Teams must create the appropriate testing infrastructure and devote more time to writing test cases than to writing code. At first, this might cause them to lag and lose hope of finishing their projects on time. If the testing suite isn't stable, it might perform flawlessly on some days but not on others. The investigation into what happened would then require more time from the team.

Jenkins installation on Ubuntu using AWS Ec2 instance

I'll show how to install Jenkins using an E2E process on an AWS EC2 Linux instance. It is advised that we read the official Jenkins deployment guide before we start the deployment process to know all the precise requirements and processes, we must meet to set up and execute Jenkins.

Check the Java version before you run the script below. The script installs openjdk-8-jre, and current Jenkins releases will not start on it. Jenkins dropped Java 8 after LTS 2.346.1 in June 2022. LTS 2.555.1, released in April 2026, runs only on Java 21 or Java 25, as recorded in the Jenkins Java support policy. On a current Ubuntu instance, install openjdk-21-jre in place of openjdk-8-jre.

The apt setup has changed as well. The official Jenkins Linux install guide now writes a dated signing key, jenkins.io-2026.key, to /etc/apt/keyrings/jenkins-keyring.asc rather than to the undated key path used in the script below. Jenkins rotates that key, so copy the key URL from the current guide instead of from an older tutorial, then point the signed-by option of your sources.list.d entry at the same file.

Phase 1: Creating the configuration script

So, the Jenkins deployment on Linux is what we're looking for. The commands that we must execute are listed below:

Let's write the script we'll use to set up the Linux machine.

Part1: Deploying JDK

JDK deployment as it was one of the requirements for installing Jenkins sudo apt update -y sudo apt install openjdk-8-jre -y

Part 2: Deploying Maven

We also need to install Maven to enable Jenkins' build creation process (Otherwise this step will fail) $ sudo apt install maven -y

Part 3: Deploying Jenkins

curl -fsSL https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo tee  /usr/share/keyrings/jenkins-keyring.asc > /dev/null 
echo deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc]  
https://pkg.jenkins.io/debian-stable binary/ | sudo tee  
/etc/apt/sources.list.d/jenkins.list > /dev/null 
sudo apt-get update 
sudo apt-get install jenkins

The final script:

#!/bin/bash
sudo apt update -y
sudo apt install openjdk-8-jre -y
sudo apt install maven -y
curl -fsSL https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo tee  /usr/share/keyrings/jenkins-keyring.asc > /dev/null 
echo deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc]  
https://pkg.jenkins.io/debian-stable binary/ | sudo tee  /etc/apt/sources.list.d/jenkins.list > /dev/null 
sudo apt-get update 
sudo apt-get install jenkins

Phase 2: Creating the EC2 instance

This stage involves setting up and configuring the Ubuntu instance: Open AWS EC2 instance creation page : https://us-east1.console.aws.amazon.com/ec2/v2/home?region=us-east-1#Instances: and launch a new instance:

Select the ubuntu version:

Select instance type:In this example, I will use the primary t2.micro instance type as it covers all the prerequisites to install Jenkins.

Open the "Advanced details" section and copy the script details under "User data"

Configure security groupSo, Jenkins is a web server, and we can access it from the web using port 8080

Create a new Key Pair:

Create an instance and access Jenkins:

Open a browser and go to http://<your-instance-public-ip>:8080. The screenshot below uses the public IP of the instance created for this walkthrough, and yours will differ.

The retrieval of Jenkins credentials will be the following step that is required. We'll need to use an SSH connection to get access to the instance to do that.

Once you have access to the instance, use cat to open the security file and get the pass:

root@ip-172-31-47-2:/var/lib/jenkins# cat 
/var/lib/jenkins/secrets/initialAdminPassword 
e12e28a79e4b48e8a7b1c6979965960a 
root@ip-172-31-47-2:/var/lib/jenkins#

Copy it to the Jenkins log-in page and click "Continue"

The ability of Jenkins to use plug-ins to carry out laborious and time-consuming tasks is thus its main strength. Let's add NodeJS as our build tool and start the deployment.

After the installation is finished, you will be prompted for your credentials:

Now we all set, press "Save and Finish"

Important clarification regarding the EC2 instances that we are using is that the IP is changing after each reboot (we can fix it using Elastic/static IPs but that is in future articles). So once you reboot your machine, please remember to retrieve the new IP so you can still get access to your Jenkins server (This is for learning purposes only).