Integrating Jenkins with version control systems (VCS) is a fundamental aspect of automating your build and deployment processes. This module will guide you through the steps required to integrate Jenkins with popular VCS like Git, Subversion, and Mercurial.

1. Version Control Systems (VCS): Tools that help manage changes to source code over time.
2. Repositories: Storage locations for your code, typically hosted on platforms like GitHub, Bitbucket, or GitLab.
3. Webhooks: Mechanisms to notify Jenkins of changes in the repository.

• Automated Builds: Trigger builds automatically when changes are pushed to the repository.
• Continuous Integration: Ensure that code changes are continuously tested and integrated.
• Traceability: Track which changes triggered which builds, providing a clear audit trail.

Jenkins supports a variety of VCS, including but not limited to:

• Git
• Subversion (SVN)
• Mercurial
• CVS
• Perforce

1. Install Git Plugin:

   • Navigate to Manage Jenkins > Manage Plugins.
   • Go to the Available tab and search for Git Plugin.
   • Install the plugin and restart Jenkins if required.

2. Create a New Job:

   • Go to the Jenkins dashboard and click on New Item.
   • Enter a name for your job and select Freestyle project, then click OK.

3. Configure Source Code Management:

   • In the job configuration page, scroll down to the Source Code Management section.
   • Select Git.
   • Enter the repository URL. For example, https://github.com/username/repository.git.
   • If the repository is private, provide the necessary credentials.

4. Set Build Triggers:

   • Scroll down to the Build Triggers section.
   • Check the GitHub hook trigger for GITScm polling option to enable webhook-based triggering.

5. Add Build Steps:

   • Scroll down to the Build section.
   • Click on Add build step and select Execute shell.
   • Enter the build commands, for example:

     #!/bin/bash
     echo "Building the project..."
     ./gradlew build
     

6. Save and Build:

   • Click Save to save the job configuration.
   • Click Build Now to trigger a build manually.

Exercise: Integrate Jenkins with a GitHub repository and set up a job to build a simple Java project using Gradle.

1. Create a GitHub Repository:

   • Create a new repository on GitHub and clone it to your local machine.
   • Add a simple Java project with a build.gradle file.

2. Set Up Jenkins Job:

   • Follow the steps outlined above to create a new Jenkins job.
   • Configure the job to use your GitHub repository.
   • Add build steps to compile the Java project using Gradle.

3. Trigger a Build:

   • Push changes to the GitHub repository and observe Jenkins triggering a build automatically.

1. GitHub Repository:

   • Create a repository named simple-java-project.
   • Add a build.gradle file with the following content:

     apply plugin: 'java'
     repositories {
         mavenCentral()
     }
     dependencies {
         testImplementation 'junit:junit:4.12'
     }
     

2. Jenkins Job Configuration:

   • Repository URL: https://github.com/your-username/simple-java-project.git
   • Build Step:

     ./gradlew build
     

3. Trigger Build:

   • Push a commit to the repository and check Jenkins for the build status.

In this section, you learned how to integrate Jenkins with a version control system, specifically Git. You installed the necessary plugins, configured a Jenkins job to pull code from a Git repository, and set up build triggers to automate the process. This integration is crucial for implementing continuous integration and ensuring that your code is always in a deployable state.

Next, we will explore how to integrate Jenkins with various build tools to further automate your development workflow.