The Complete Beginner’s Guide to Jenkins and CI/CD Automation

Introduction

In today’s fast-paced software development world, Continuous Integration (CI) has become a crucial practice for teams to deliver quality software faster. One of the most popular tools for implementing CI is Jenkins.

In this blog, we will dive into what Jenkins is, why it’s used, and how you can set it up for your own projects.

What is Jenkins?

Jenkins is an open-source automation server written in Java, designed to streamline and automate repetitive tasks in the software development lifecycle. Primarily used for Continuous Integration (CI) and Continuous Deployment (CD), Jenkins supports building, testing, and deploying software applications efficiently. Its versatility extends to database management tasks, making it a valuable tool for automating MySQL database operations. By integrating Jenkins with MySQL, teams can automate processes such as schema updates, backups, performance testing, and deployment, ensuring seamless and reliable database workflows alongside application development.

It allows developers to automate various tasks, such as:

• Building code
• Running tests
• Deploying applications
• Notifying teams about the build status

Why Jenkins?

There are several reasons why Jenkins has become the go-to tool for many software development teams:

• Open-Source: Jenkins is free to use, and its source code is available for modifications.
• Large Ecosystem: Jenkins has a vast library of plugins, allowing you to integrate it with almost any tool in your development pipeline.
• Scalability: Jenkins can scale from a single developer’s local setup to a large enterprise-level deployment.
• Easy Configuration: Jenkins provides a user-friendly interface that allows easy configuration and monitoring of your projects.
• Support for Multiple Platforms: Jenkins supports various operating systems like Windows, macOS, and Linux.

How Jenkins Works

Jenkins uses a master-slave architecture where the Jenkins server (master) schedules and monitors tasks, and the slave nodes (also called agents) handle the actual execution of the tasks. Here’s how it works in a typical CI/CD pipeline:

• Code Commit: A developer commits their code to a version control system (e.g., GitHub).
• Trigger Build: Jenkins automatically triggers a build job on the server whenever a change is detected.
• Build Execution: Jenkins pulls the latest code from the version control system and compiles it.
• Automated Testing: Jenkins runs automated tests to check if the new code breaks existing functionality.
• Deploy: If the tests pass, Jenkins deploys the application to a staging or production environment.

Setting Up Jenkins: Step-by-Step Guide

Installing Jenkins

To get started with Jenkins, you first need to install it on your system. Here’s how to install Jenkins on a Ubuntu system:

Step 1: Update your system:

sudo apt update
sudo apt upgrade

Step 2: Add the Jenkins repository:

curl -fsSL https://pkg.jenkins.io/debian-stable/jenkins.io-2023.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

Step 3: Install Jenkins:

sudo apt update
sudo apt install jenkins -y

Step 4: Start Jenkins:

sudo systemctl start jenkins
sudo systemctl enable jenkins

Step 5: Open Jenkins in your web browser: Go to http://localhost:8080 or http://<your_server_ip>:8080.

Unlock Jenkins

When you first access Jenkins, you will be asked to unlock it by providing an initial password. To get the password:

sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Copy the password and paste it into the Jenkins web interface to unlock it.

Install Suggested Plugins

Once you’ve unlocked Jenkins, it will prompt you to install plugins. Click on the “Install suggested plugins” button to install the most commonly used plugins.

Set Up Your First Jenkins Job

Once Jenkins is installed, it’s time to set up your first job. Follow these steps:

• Step 1: From the Jenkins dashboard, click on New Item.
• Step 2: Choose the type of job you want to create. For beginners, Freestyle Project is a simple choice.
• Step 3: Name your job and click OK.
• Step 4: Configure your job by specifying the source code repository (e.g., GitHub) and build steps.
  • Under Source Code Management, enter the repository URL.
  • Under Build, specify the build tool, like Maven or Gradle, or simply run shell commands.
• Step 5: Under Post-build Actions, you can add steps like sending notifications to Slack or emailing the team.

Click Save once you’re done. You can now trigger this job manually or set it to trigger automatically on code commits.

Configuring Jenkins Pipelines

Jenkins supports both Declarative and Scripted Pipelines to automate your CI/CD workflows.

1. Declarative Pipeline

This is a more structured and easier-to-understand syntax, often preferred by beginners. A simple Jenkinsfile looks like this:

pipeline {
    agent any

    stages {
        stage('Build') {
            steps {
                echo 'Building the project...'
                // Add build steps here
            }
        }

        stage('Test') {
            steps {
                echo 'Running tests...'
                // Add test steps here
            }
        }

        stage('Deploy') {
            steps {
                echo 'Deploying application...'
                // Add deploy steps here
            }
        }
    }

    post {
        always {
            echo 'This will always run after the pipeline finishes.'
        }
    }
}

2. Scripted Pipeline

A scripted pipeline is more flexible but also more complex. It allows full control over the flow of the build process. A scripted pipeline looks like this:

node {
    stage('Build') {
        echo 'Building the project...'
        // Add build steps here
    }

    stage('Test') {
        echo 'Running tests...'
        // Add test steps here
    }

    stage('Deploy') {
        echo 'Deploying application...'
        // Add deploy steps here
    }
}

Jenkins Plugins

Jenkins has a rich ecosystem of plugins that extend its functionality. Some of the most useful plugins for beginners include:

• Git Plugin: For integrating Jenkins with Git repositories.
• Maven Plugin: For Maven-based Java projects.
• Slack Plugin: To send build notifications to Slack channels.
• JUnit Plugin: For testing and reporting results in JUnit format.
• Docker Plugin: To build and deploy Docker containers.

You can install plugins directly from the Manage Jenkins section by navigating to Manage Plugins.

Monitoring Jenkins Builds

Once your Jenkins jobs are running, you can monitor the status of your builds:

• Build History: Jenkins displays the history of your builds on the job page, showing the success or failure of each build.
• Build Logs: You can view the detailed logs of each build by clicking on the individual build number.
• Notifications: Jenkins can notify you when builds succeed or fail via email, Slack, or other channels.

Conclusion

Jenkins is a powerful tool that helps automate and streamline the software development lifecycle. By implementing Jenkins for Continuous Integration and Continuous Deployment, you can ensure your software is always in a deployable state, reducing manual errors and increasing productivity.

As you explore Jenkins more, you can dive into more advanced topics like Jenkins pipelines, distributed builds, and advanced plugin configurations. But for now, this guide should help you get started with your first Jenkins setup and job.

Happy building!