Creating an Efficient CI/CD Pipeline for Java Applications Using Jenkins, Docker, Tomcat, and Git Branches

In today's fast-paced development environment, automating the build, testing, and deployment of applications is vital to improving efficiency and reducing manual effort. Continuous Integration and Continuous Deployment (CI/CD) pipelines have become essential tools for achieving faster, higher-quality software releases.

Recently, I implemented a robust CI/CD pipeline for a Java application using Jenkins, Docker, Tomcat, and Git branches, specifically focusing on automating the process using the pipeline branch. In this article, I’ll walk you through the pipeline setup, the benefits it offers, and how you can use a similar approach for your own projects.

?? Project Repository (Pipeline Branch): Mein Kampf Bio - GitHub

Why a CI/CD Pipeline?

CI/CD pipelines automate key stages of the software delivery process, from building and testing to deployment. By integrating continuous integration and deployment, teams can deliver updates faster, with higher quality, and minimize manual errors, which is essential for today’s agile workflows.

The Technology Stack:

Jenkins: For automating the CI/CD pipeline with stages for building, testing, and deployment.

Docker: To containerize the build environment, ensuring consistency across different systems.

Apache Tomcat: A reliable Java servlet container used to deploy the application.

Maven: Handles dependencies and automates the build process for Java applications.

JUnit: Ensures that unit tests are automatically run before deployment.

The CI/CD Pipeline Configuration

Here's the actual pipeline script used in Jenkins, which automates the process from code checkout to deployment:

pipeline {
  agent {
    docker {
      image 'maven:3.8.5-openjdk-17'
      args '--user root -v /var/run/docker.sock:/var/run/docker.sock' // mount Docker socket to access the host's Docker daemon
    }
  }
  stages {
    stage('Checkout') {
      steps {
        git branch: 'pipeline', url: 'https://github.com/arifislam007/mein-kampf-bio.git'
      }
    }
    stage('Java Build') {
      steps {
        sh 'mvn clean install'
      }
    }
    stage('Deploy to Tomcat Server') {
      steps {
        deploy adapters: [tomcat9(credentialsId: 'tomcat-access', path: '', url: 'https://192.168.207.132:8080')], contextPath: null, onFailure: false, war: '**/*.war'
      }
    }
  }
}        

Pipeline Breakdown

1. Dockerized Build Environment

To ensure consistent builds regardless of the underlying system, I used a Docker container in Jenkins with the maven:3.8.5-openjdk-17 image. This container runs Maven in a controlled environment, handling all dependencies and builds. Docker helps eliminate the "works on my machine" problem by providing a stable environment for all builds.

2. Code Checkout

In the Checkout stage, Jenkins automatically pulls the latest code from the pipeline branch in the GitHub repository. This ensures that any new commits or updates in the pipeline branch are immediately built and tested.

git branch: 'pipeline', url: 'https://github.com/arifislam007/mein-kampf-bio.git'        

This stage ensures that only the code from the pipeline branch is integrated into the CI/CD process, providing control over what gets deployed.

3. Java Build Using Maven

In the Java Build stage, Maven is used to compile the code, package the application, and run any tests. Running mvn clean install ensures that the project is cleanly rebuilt from scratch, including resolving dependencies and packaging the application into a WAR file.

sh 'mvn clean install'        

This step ensures that only code that passes the build process, including any tests, proceeds to the deployment phase.

4. Deployment to Tomcat Server

After a successful build, Jenkins automatically deploys the WAR file to an Apache Tomcat server. I used Jenkins' deploy-to-container plugin to deploy the application directly to the Tomcat server running at 192.168.207.132:8080.

deploy adapters: [tomcat9(credentialsId: 'tomcat-access', path: '', url: 'https://192.168.207.132:8080')], contextPath: null, onFailure: false, war: '**/*.war'        

This stage automates the deployment, ensuring that any new features or bug fixes are deployed without manual intervention.

Benefits of this CI/CD Pipeline

Consistency Across Environments: Using Docker ensures the build process is consistent, regardless of the machine or OS.

Automation: The entire process, from code checkout to deployment, is automated, saving time and reducing manual errors.

Faster Feedback: Developers receive immediate feedback on the success or failure of their code changes, enabling them to resolve issues faster.

Quality Assurance: The use of Maven for dependency management and JUnit for testing ensures that only code that meets quality standards is deployed.

Seamless Deployment: The deployment to Tomcat is fully automated, making it easier to roll out new updates without downtime.

Conclusion

This CI/CD pipeline setup using Jenkins, Docker, Tomcat, and Git branching is a powerful way to streamline the build and deployment process for Java applications. By automating each stage, we reduce human error, increase the speed of delivery, and ensure that only the best code reaches production.

Feel free to explore the pipeline branch on GitHub and experiment with the setup in your own projects. Let me know if you have any questions or thoughts about CI/CD or this specific pipeline configuration!

?? Project Repository (Pipeline Branch): [Mein Kampf Bio - GitHub](https://github.com/arifislam007/mein-kampf-bio/tree/pipeline)

#CI #CD #Jenkins #Docker #Tomcat #Java #DevOps #Maven #Automation #SoftwareDevelopment #JUnit #ContinuousIntegration