Prerequisites

Before setting up the pipeline, ensure you have the following:

A Java project managed by Maven or Gradle.

A GitHub repository containing your source code.

A remote Tomcat server accessible via SSH.

SSH credentials (private key) stored securely in your GitHub repository secrets.

Configuring GitHub Secrets

To keep your deployment secure, never hardcode sensitive information in your workflow files. Navigate to your GitHub repository, go to Settings, then Secrets and variables, and add the following:

SSH_HOST: The IP address or domain of your Tomcat server.

SSH_USER: The username for the server.

SSH_PRIVATE_KEY: The private key used to authenticate with the server.

Creating the Workflow File

Create a file in your repository at .github/workflows/deploy.yml. This file defines the automation steps. The workflow will trigger on every push to the main branch.

Defining the Build and Deploy Steps

The workflow consists of two main phases: building the artifact and deploying it to the server.

name: Java CI/CD to Tomcat

on: push: branches: [ main ]

jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - name: Set up JDK 17 uses: actions/setup-java@v3 with: java-version: '17' distribution: 'temurin' - name: Build with Maven run: mvn clean package - name: Upload Artifact uses: actions/upload-artifact@v3 with: name: webapp path: target/*.war

deploy: needs: build runs-on: ubuntu-latest steps: - name: Download Artifact uses: actions/download-artifact@v3 with: name: webapp - name: Deploy to Tomcat via SCP uses: appleboy/scp-action@master with: host: \({{ secrets.SSH_HOST }} username: \){{ secrets.SSH_USER }} key: \({{ secrets.SSH_PRIVATE_KEY }} source: "*.war" target: "/opt/tomcat/webapps/" - name: Restart Tomcat uses: appleboy/ssh-action@master with: host: \){{ secrets.SSH_HOST }} username: \({{ secrets.SSH_USER }} key: \){{ secrets.SSH_PRIVATE_KEY }} script: sudo systemctl restart tomcat

Understanding the Pipeline Logic

Build Phase: The pipeline uses the ubuntu-latest runner to check out the code, set up the Java environment, and run the Maven package command. This generates the WAR file. The artifact is then uploaded to GitHub so it can be passed to the next job.

Deploy Phase: The pipeline downloads the WAR file and uses the appleboy/scp-action to securely copy the file to the Tomcat webapps directory.

Restart Phase: Finally, the pipeline executes a remote SSH command to restart the Tomcat service, ensuring the new version of the application is loaded.

Best Practices for Production

For production environments, consider adding a testing step after the build phase to run unit tests. Additionally, instead of restarting the entire Tomcat service, you can use the Tomcat Manager API to deploy the WAR file without downtime. Always ensure your server has restricted firewall rules, allowing SSH access only from trusted IP addresses.

Introduction

Nexus Repository Manager serves as a powerful tool for managing software artifacts, while Jenkins is a widely-used automation server for building, testing, and deploying applications. Integrating these two tools allows developers to automate the entire lifecycle of their applications, from code commit to deployment. This document will guide you through the setup and configuration required to achieve seamless integration between Nexus and Jenkins.

Prerequisites

Before starting the integration process, ensure you have the following:

Jenkins Installed: Make sure you have Jenkins installed and running. You can download it from the Jenkins website.

Nexus Repository Manager Installed: You can download Nexus from the Sonatype website.

Jenkins Plugins: Install the following Jenkins plugins:

Nexus Artifact Uploader

Pipeline (if using Jenkins Pipeline)

Nexus Repository: Create a hosted repository in Nexus where you will deploy your artifacts.

Step 1: Configure Nexus Repository

Log in to Nexus: Access your Nexus Repository Manager by navigating to its URL in your web browser.

Create a Hosted Repository:

Go to the "Repositories" section.

Click on "Create repository" and select the type (e.g., Maven2 (hosted)).

Configure the repository settings (name, version policy, etc.) and save.

Generate a User Token:

Navigate to "Administration" > "Security" > "Users".

Create a new user or use an existing one with the necessary permissions to deploy artifacts.

Generate an API token for this user, which will be used for authentication in Jenkins.

Step 2: Configure Jenkins

Install Required Plugins:

Go to "Manage Jenkins" > "Manage Plugins".

Search for and install the "Nexus Artifact Uploader" plugin.

Configure Nexus Credentials:

Go to "Manage Jenkins" > "Manage Credentials".

Add a new credential:

Kind: Username with password

Username: Your Nexus username

Password: Your Nexus API token

ID: nexus-credentials (or any identifier you prefer)

Create a New Job:

Click on "New Item" in Jenkins.

Choose "Pipeline" or "Freestyle project" based on your preference.

Name your job and click "OK".

Step 3: Create a Jenkins Pipeline

If you are using a Pipeline job, you can define your CI/CD process in a Jenkinsfile. Below is a sample Jenkinsfile that demonstrates how to build a Maven project and deploy the artifact to Nexus.

pipeline { agent any

environment {
    NEXUS_CREDENTIALS = credentials('nexus-credentials')
    NEXUS_URL = 'http://your-nexus-url:8081/repository/your-repo/'
}

stages {
    stage('Build') {
        steps {
            script {
                // Run Maven build
                sh 'mvn clean package'
            }
        }
    }

    stage('Deploy to Nexus') {
        steps {
            script {
                // Upload artifact to Nexus
                nexusArtifactUploader artifacts: [
                    [artifactId: 'your-artifact-id', 
                     classifier: '', 
                     file: 'target/your-artifact.jar', 
                     groupId: 'your.group.id', 
                     version: '1.0.0']
                ],
                nexusUrl: "${NEXUS_URL}",
                groupId: 'your.group.id',
                version: '1.0.0',
                repository: 'your-repo',
                credentialsId: 'nexus-credentials'
            }
        }
    }
}

}

Explanation of the Pipeline

Agent: Defines where the pipeline will run. any means it can run on any available agent.

Environment Variables: Store Nexus credentials and URL for easy access.

Stages:

Build: Executes the Maven build command to create the artifact.

Deploy to Nexus: Uses the nexusArtifactUploader to upload the built artifact to the specified Nexus repository.

Step 4: Run the Jenkins Job

Save the Pipeline: After configuring the Jenkinsfile, save your job.

Build the Job: Click on "Build Now" to trigger the pipeline.

Monitor the Build: Check the console output for any errors and ensure the artifact is successfully uploaded to Nexus.

Step 5: Verify Artifact in Nexus

Log in to Nexus: Go back to your Nexus Repository Manager.

Navigate to Your Repository: Find the repository where you deployed the artifact.

Check for the Artifact: Verify that your artifact appears in the repository with the correct version.

Conclusion

Integrating Nexus with Jenkins allows for a streamlined CI/CD process, enabling teams to automate the deployment of artifacts efficiently. By following the steps outlined in this document, you can set up a robust pipeline that not only builds your applications but also manages artifact deployment seamlessly. This integration enhances collaboration, reduces manual errors, and accelerates the delivery of high-quality software.