How to Deploy a Spring Boot Application on Azure App Service with Jenkins CI/CD - Step-by-Step Guide

Explanation:

  1. Jenkins: Represents the Jenkins CI/CD pipeline, including steps like building the application with Maven and deploying it to Azure.
  2. GitHub: Represents the GitHub repository that contains the Spring Boot source code.
  3. Azure App Service: Represents the Azure service hosting the Spring Boot application after it's deployed from Jenkins.


To deploy a Spring Boot application on Azure App Service using Jenkins for CI/CD (Continuous Integration and Continuous Deployment), follow this end-to-end example:

Prerequisites:

  1. Azure Account: You need an active Azure account. If you don’t have one, you can create it here.
  2. Jenkins Server: A Jenkins instance up and running (either locally or in the cloud).
  3. Spring Boot Application: A Spring Boot project ready for deployment.
  4. Azure CLI: Installed on your Jenkins server (or use Azure DevOps pipelines for automated setup).

Step 1: Set up Azure App Service

  1. Create an App Service Plan:

    • Go to the Azure Portal.
    • Search for App Services and click Create.
    • Fill in the required details like subscription, resource group, and region.
    • Select the appropriate App Service Plan for your Spring Boot app.

  2. Create a Web App:

    • In the App Services section, click Create.
    • Provide a name for your web app, choose the runtime stack (Java 11 or higher), and select your App Service Plan.
    • Once the app is created, you’ll get a URL to access your app (e.g., https://your-app-name.azurewebsites.net).

  3. Enable Deployment from GitHub or Jenkins:

    • Go to the Deployment Center in the Azure portal for your web app.
    • Select Jenkins or GitHub as the source, and provide necessary configurations (you may need to configure Jenkins integration later).

Step 2: Set up Jenkins

  1. Install Jenkins Plugins:

    • Ensure that Jenkins has the required plugins:
      • Azure CLI Plugin: For deploying to Azure.
      • Git Plugin: For pulling your Spring Boot code from a Git repository.
      • Maven/Gradle Plugin: Depending on your project build tool.
      • Pipeline Plugin: For CI/CD pipeline setup.

  2. Configure Azure CLI on Jenkins:

    • Install Azure CLI on your Jenkins server (if not already installed).
    • On Jenkins, configure the Azure CLI plugin:
      • Go to Manage Jenkins → Configure System.
      • Under Azure CLI, provide the credentials (Client ID, Secret, Tenant ID) for your Azure account (these can be obtained by registering an application in Azure Active Directory).

  3. Configure Jenkins Credentials:

    • Go to Manage Jenkins → Manage Credentials → Global Credentials and add your Azure Service Principal credentials for authentication.
    • If you use GitHub, add GitHub credentials as well.

Step 3: Configure Your Jenkins Pipeline (Jenkinsfile)

  1. Create a Jenkinsfile: This file defines your CI/CD pipeline for Jenkins. It should be in the root of your Spring Boot project.

    Here's an example Jenkinsfile for a Spring Boot application:

    pipeline {
    agent any

    environment {
        AZURE_SUBSCRIPTION_ID = 'your-azure-subscription-id'
        AZURE_TENANT_ID = 'your-azure-tenant-id'
        AZURE_CLIENT_ID = 'your-azure-client-id'
        AZURE_CLIENT_SECRET = 'your-azure-client-secret'
        APP_NAME = 'your-app-name'
        RESOURCE_GROUP = 'your-resource-group'
    }

    stages {
        stage('Checkout') {
            steps {
                // Checkout the code from GitHub or any repository
                git 'https://github.com/your-repo/your-spring-boot-app.git'
            }
        }

        stage('Build') {
            steps {
                script {
                    // Build the Spring Boot app with Maven or Gradle
                    sh 'mvn clean package -DskipTests'
                }
            }
        }

        stage('Deploy to Azure') {
            steps {
                script {
                    // Login to Azure
                    sh '''
                    az login --service-principal -u $AZURE_CLIENT_ID -p $AZURE_CLIENT_SECRET --tenant $AZURE_TENANT_ID
                    az account set --subscription $AZURE_SUBSCRIPTION_ID
                    '''
                    
                    // Deploy the built jar file to Azure App Service
                    sh '''
                    az webapp deploy --resource-group $RESOURCE_GROUP --name $APP_NAME --src-path target/your-app.jar --type jar
                    '''
                }
            }
        }

        stage('Clean Up') {
            steps {
                // Clean up the workspace (optional)
                cleanWs()
            }
        }
    }

    post {
        success {
            echo 'Deployment to Azure App Service was successful!'
        }
        failure {
            echo 'Deployment failed!'
        }
    }
}
    • This Jenkinsfile defines:
      • Checkout: Pulls your Spring Boot code from the Git repository.
      • Build: Builds the project using Maven (you can replace mvn with gradle if you use Gradle).
      • Deploy to Azure: Deploys the generated JAR file to Azure App Service.
      • Clean Up: Cleans the workspace after the job.

  2. Configure the Jenkins Pipeline Job:

    • In Jenkins, create a new Pipeline job.
    • In the Pipeline Script section, select Pipeline from SCM and point it to your GitHub repository where the Jenkinsfile is located.

Step 4: Trigger the Pipeline

  1. Manual Trigger:
    • Once the Jenkins job is set up, you can trigger it manually by clicking Build Now in Jenkins.
  2. Automatic Trigger:
    • To automate the process, you can configure Jenkins to trigger on GitHub push events (e.g., when code is pushed to the main branch). This can be done by setting up GitHub Webhooks in the Jenkins job configuration.

Step 5: Monitor the Deployment

  • After Jenkins runs the pipeline, check the Azure App Service for the deployed application.
  • You can monitor logs in the Azure portal under App Service Logs or use the Azure CLI for more details.

Optional: Using Azure DevOps

If you'd like to integrate Azure DevOps for CI/CD, you can use Azure Pipelines instead of Jenkins. Azure Pipelines supports Spring Boot apps natively and integrates seamlessly with Azure App Services.

Summary:

This end-to-end guide shows how to set up Jenkins CI/CD for a Spring Boot application, deploying it to Azure App Service. The pipeline:

  1. Checks out the code from GitHub.
  2. Builds the project using Maven.
  3. Deploys the JAR file to Azure App Service.
  4. Cleans up the workspace and provides deployment status.

Unlock Your Microservices Mastery for Only $9!

Get your copy now for just $9! and start building resilient and scalable microservices with the help of Microservices with Spring Boot 3 and Spring Cloud.

Comments

Post a Comment

Popular posts from this blog

Spring Boot OpenAI Integration: Step-by-Step Guide

Image
Here's a simple explanation: User Interaction : The User interacts with Postman to send requests (e.g., test API endpoints of the Spring Boot application). Postman : Postman sends requests to the Spring Boot Application . Spring Boot Application : Postman calls the Controller in the Spring Boot application. The Controller handles the incoming requests and delegates the logic to the Service layer. The Service interacts with the OpenAiClient to perform the actual communication with OpenAI. External System : The OpenAiClient sends the request to the OpenAI API to get a response. The response flows back through the layers ( OpenAiClient → Service → Controller ) and is returned to the user via Postman . To integrate ChatGPT into a Spring Boot application, you can use the OpenAI API to send requests to ChatGPT and get responses. Below is an example of how you can create a simple Spring Boot service that integrates with OpenAI's API to use ChatGPT. 1: Set up your Spring Boo...
Read more

Orchestration-Based Saga Architecture and Spring Boot Microservices Implementation Guide

Image
The image illustrates an orchestration-based saga pattern for handling distributed transactions across two microservices: Order Service and Customer Service . This approach uses a central orchestrator (the saga) to coordinate the interactions between services and ensure consistency. Here’s an end-to-end explanation of the flow: 1. Order Creation Request A client sends an HTTP POST /orders request to the Order Controller in the Order Service . The Order Controller is responsible for receiving the request and delegating it to the Order Service . 2. Order Creation in the Saga The Order Service invokes the create() method in the Create Order Saga . The Create Order Saga is the orchestrator responsible for coordinating the steps involved in completing the transaction. 3. Order Aggregate Creation The Create Order Saga initiates the creation of the Order aggregate in the Order Service . The Order aggregate represents the state and business logic of the order. 4. Reserve Credit Com...
Read more

Spring Boot 3 + Angular 15 + Material - Full Stack CRUD Application Example

Image
In this section we will develop a full-stack application that is a basic Student management application using Spring Boot 3, Angular 15, Material and PostgreSQL. You could download the source code from our GitHub repository, the download link is provided at the end of this article. After completing this tutorial what we will build?   We will build a full-stack web application that is a basic Student Management Application with CRUD features:  Create Student List Student Update Student  Delete Student Technologies used: Spring Boot 3+ Spring Data JPA PostgreSQL Java 17 Angular 15 Angular Material UI 1. Backend Development Creating a Spring boot web application First, open the Spring initializr: https://start.spring.io/   Then, Provide the Group and Artifact name. We have provided Group name com.knf.dev.demo and Artifact spring-boot3-postgresql-crud-app . Here I selected the Maven project - language Java 17 ,  Spring Boot 3.1.4  (latest) and add Sp...
Read more