Experiment to Setup Jenkins and Demonstrating Continuous Integration

 Title: Setting up Jenkins and Demonstrating Continuous Integration

Objective:

The objective of this experiment is to set up Jenkins and demonstrate Continuous Integration (CI) by automating the build process of a simple Java project whenever changes are pushed to the version control repository.

Prerequisites:

• Java Development Kit (JDK) installed on your system
• Apache Maven installed on your system
• Git installed on your system
• Jenkins installed on a server or local machine

Experiment Steps:

Step 1: Install Java Development Kit (JDK)

1. Download and install the latest JDK version compatible with your operating system.
2. Set the JAVA_HOME environment variable to the JDK installation directory.

Step 2: Install Apache Maven

1. Download the latest Apache Maven binary distribution from the official website (https://maven.apache.org/download.cgi).
2. Extract the downloaded archive to a directory on your system.
3. Set the MAVEN_HOME environment variable to the Maven installation directory.
4. Add the Maven bin directory to the system's PATH variable.

Step 3: Install Git

1. Download and install Git from the official website (https://git-scm.com/downloads).
2. Configure Git with your username and email using the following commands:

git config --global user.name "Your Name"

git config --global user.email "you@example.com"

Step 4: Install Jenkins

1. Download and install Jenkins on your server or local machine by following the official installation guide (https://www.jenkins.io/doc/book/installing/).
2. Start the Jenkins server and access the Jenkins web interface using a web browser.

Step 5: Set up Jenkins for CI

1. Access the Jenkins web interface (usually at http://localhost:8080) and complete the initial setup by providing the Administrator password and installing the recommended plugins.
2. Create a new Jenkins pipeline project:
3. Click on "New Item" on the Jenkins dashboard.
4. Enter a name for the project (e.g., "MyJavaApp").
5. Select "Pipeline" and click "OK."
6. Configure the pipeline:
7. Under the "Pipeline" section, choose "Pipeline script from SCM."
8. Select "Git" as the SCM (Source Code Management) and provide the repository URL.
9. Save the configuration.

Step 6: Create a Simple Java Project with Version Control

1. Create a new directory for your Java project.
2. Inside the project directory, create a new Java source file with a simple Java class (e.g., HelloWorld.java).
3. Initialize Git in the project directory:

git init

• Add the Java source file to the Git repository:

git add HelloWorld.java

• Commit the initial version of the project:

git commit -m "Initial commit"

• Create a remote repository (e.g., on GitHub, GitLab, or Bitbucket) and link it to the local repository:

git remote add origin <repository_url>

git push -u origin master

Step 7: Configure Jenkins to Trigger CI

1. In the Jenkins pipeline project, click on "Build Now" to manually trigger the first build.
2. Verify that the build is successful.

Step 8: Test CI by Pushing Changes

1. Make some changes to the HelloWorld.java file.
2. Commit the changes to the Git repository:

git add HelloWorld.java

git commit -m "Updated HelloWorld.java"

• Push the changes to the remote repository:

git push origin master

• Observe that Jenkins automatically triggers a new build due to the code changes.

Conclusion:

In this experiment, we successfully set up Jenkins and demonstrated Continuous Integration (CI) by automating the build process of a simple Java project whenever changes were pushed to the version control repository. Jenkins continuously monitored the repository for changes and automatically initiated the build, ensuring that the application remained in a deployable state at all times. CI practices help streamline development workflows, reduce integration issues, and improve collaboration among development teams.