6. Building Quarkus Backend via Jenkins and Gitea

Welcome, fellow developers! Today, we're diving into the world of Continuous Integration (CI) and automating our Quarkus application builds using Jenkins Pipelines. This blog post will guide you through the process, from setting up Jenkins to running your first pipeline, with a sprinkle of theory to solidify your understanding.

The Power of CI/CD and Pipelines

Before we jump into the practical steps, let's briefly touch on the importance of CI/CD (Continuous Integration/Continuous Delivery) and pipelines.

• Continuous Integration (CI): A practice where developers frequently integrate their code changes into a central repository. Each integration is verified by an automated build and test process. This helps detect integration errors early and improves code quality.

• Pipelines: In the context of CI/CD, pipelines are automated workflows that define the steps involved in building, testing, and deploying software. Jenkins Pipelines, in particular, allow us to define these workflows as code, providing version control and reproducibility.

Setting Up Jenkins: The Foundation

Our journey begins with installing Jenkins and the necessary plugins.

1. Jenkins Installation:

   • If you haven't already, install Jenkins on your server or local machine. You can find detailed instructions on the official Jenkins website (https://www.jenkins.io/doc/book/installing/). Or you can also follow the guide set up in this website (https://sangama.hashnode.dev/3-starting-a-jenkins-service-in-microk8s). Jenkins is a java based application, so make sure you have a jdk installed.

   • Once installed, access Jenkins through your web browser (usually http://localhost:8080 but it is a better to use it as a NodePort rather than limiting it just to one system).

2. Plugin Installation:

   • Navigate to "Manage Jenkins" -> "Manage Plugins."

   • Go to the "Available" tab.

   • Search for and install the "Pipeline" and "Git" plugins.

   • These plugins are crucial for creating and executing pipeline jobs and integrating with Git repositories.

   • Theory: Jenkins plugins extend its functionality, allowing it to integrate with various tools and technologies. The "Pipeline" plugin enables us to define build workflows as code, while the "Git" plugin provides seamless integration with Git repositories.

Creating Your First Pipeline Job: The Blueprint

Now, let's create a new pipeline job to automate the build and test process for our Quarkus application.

1. New Item Creation:

   • On the Jenkins dashboard, click "New Item."

   • Enter a descriptive name for your pipeline (e.g., "Quarkus-Build-Test").

   • Select "Pipeline" and click "OK."

2. Pipeline Configuration:

   • In the "Pipeline" section, we'll define our pipeline's source and script.

   • Definition: Choose "Pipeline script from SCM." This tells Jenkins to retrieve the pipeline script from a source code management (SCM) system.

   • SCM: Select "Git."

   • Repository URL: Enter the URL of your Git repository containing the Quarkus application (e.g., https://github.com/your-username/your-quarkus-app.git).

   • Branches to build: Specify the branch you want to build (e.g., "main").

   • Script Path: Ensure this is set to "Jenkinsfile." This tells Jenkins to look for a file named "Jenkinsfile" in the root of your repository.

   • Theory: Using "Pipeline script from SCM" promotes Infrastructure as Code (IaC), allowing us to manage our pipeline configurations alongside our application code. Git, as a distributed version control system, provides a robust platform for managing these configurations.

3. Saving the Pipeline:

   • Click "Save" to save your pipeline configuration.

Writing the Jenkinsfile: The Workflow Definition

The "Jenkinsfile" is where we define the steps of our pipeline. Here's a basic example for a Quarkus application:

Groovy

pipeline {
    agent any // Run on any available agent
    stages {
        stage('Checkout') {
            steps {
                git branch: 'main', url: 'https://github.com/your-username/your-quarkus-app.git'
            }
        }
        stage('Build') {
            steps {
                sh './mvnw clean package' // Build the Quarkus application
            }
        }
        stage('Test') {
            steps {
                sh './mvnw test' // Run unit tests
            }
        }
    }
}

• agent any: Specifies that the pipeline can run on any available Jenkins agent.

• stages: Defines the different stages of the pipeline (Checkout, Build, Test).

• steps: Contains the commands to execute within each stage.

• git: Checks out the code from the Git repository.

• sh: Executes shell commands (e.g., Maven commands).

• Theory: The Jenkinsfile uses Groovy-based Domain Specific Language (DSL) to define the pipeline. Stages divide the pipeline into logical sections, enhancing readability and providing a clear view of the workflow.

Running the Pipeline: Putting it into Action

1. Build Now:

   • In your pipeline job's page, click "Build Now."

2. Monitoring the Build:

   • You can monitor the build progress in the "Build History" section.

   • Click on a build number to see the console output and stage view.

   • The console output will show the logs of each step, and the stage view will show the progress of each stage.

   • Theory: Jenkins agents execute the pipeline steps. The console output provides a detailed log of the build process, allowing us to diagnose any issues. The stage view offers a visual representation of the pipeline's execution.

Troubleshooting Tips

• If your build fails, check the console output for error messages.

• Ensure your Git repository URL and branch name are correct.

• Verify that Maven is correctly configured on your Jenkins agents.

• If you are running this in a kubernetes enviroment, ensure that the agent has access to git, and maven.

Conclusion

By following these steps, you've successfully automated your Quarkus application builds using Jenkins Pipelines. This is just the beginning. You can further enhance your pipeline by adding stages for deployment, code quality checks, and more. Remember, CI/CD is a continuous journey of improvement.