Jenkinsfile & Pipeline Execution

Go to the Pipeline tab at the bottom of the job configuration page, select Pipeline script from the dropdown, and paste the following script.

Groovy
pipeline {
    // 1. DEFINE THE DYNAMIC DOCKER AGENT
    // This agent block tells Jenkins to start a new container
    // from your custom image (defined in Jenkins Agent Dockerfile) for this job.
    agent {
        docker {
            image 'gcp-jenkins-agent:latest'
            label 'gcp-build-agent'
        }
    }

// 2. DEFINE ENVIRONMENT VARIABLES
// These are static variables from your cloud setup (Required Cloud Environment & Credentials)
    environment {
        PROJECT_ID     = 'hclsw-gcp-rbd'
        CLUSTER_NAME   = 'kube-cluster'
        LOCATION       = 'us-central1'
 CREDENTIALS_ID = 'hclsw-service_Account' // ID of the credential from Jenkins Platform Setup (Prerequisites)
IMAGE_REPO     = 'us-central1-docker.pkg.dev/hclsw-gcp-rbd/hcl-rbd2/hcl-rbd2'
    }
    
    // 3. DEFINE PARAMETERS
    // These are the user-provided inputs from section 1
    parameters {
string(name: 'GIT_REPO_URL', defaultValue: 'https_github.com_your-repo.git', description: 'Git repo URL')
        string(name: 'GIT_BRANCH', defaultValue: 'main', description: 'Git branch to build')
string(name: 'WAR_FILE_PATH', defaultValue: 'target/app.war', description: 'Path to the .war file in the repo')
 string(name: 'IMAGE_TAG', defaultValue: 'latest', description: 'Docker image tag')
 password(name: 'TOMCAT_PASSWORD', description: 'Password for the Tomcat manager')
    }

    // 4. DEFINE PIPELINE STAGES
    stages {
        
        stage('Checkout SCM') {
            steps {
          cleanWs() // Clean the workspace from previous builds
echo "Checking out ${params.GIT_BRANCH} from ${params.GIT_REPO_URL}"
                // Clone the repo which contains:
                // 1. Application Dockerfile (Defining the Application Container (Dockerfile))
                // 2. K8s Manifests (Defining the Deployment Target (Kubernetes Manifests))
                // 3. The .war file
 git branch: params.GIT_BRANCH, url: params.GIT_REPO_URL
            }
        }

        stage('Set Dynamic Image Name') {
            steps {
                script {
 // Combine the repo URL and tag to create the full image name
env.IMAGE_NAME = "${env.IMAGE_REPO}:${params.IMAGE_TAG}"
                    echo "IMAGE_NAME set to: ${env.IMAGE_NAME}"
                }
            }
        }

        stage('Authenticate & Configure Docker') {
            steps {
 // Use the 'Secret file' credential from ChapJenkins Platform Setup (Prerequisites)
 withCredentials([file(credentialsId: env.CREDENTIALS_ID, variable: 'SERVICE_ACCOUNT_JSON')]) {
 sh """
 echo "Activating GCP Service Account..."
gcloud auth activate-service-account --key-file="\$SERVICE_ACCOUNT_JSON" --project="${env.PROJECT_ID}"
                        
  echo "Configuring Docker to authenticate with Artifact Registry..."
 gcloud auth configure-docker ${env.LOCATION}-docker.pkg.dev --quiet
                    """
                }
            }
        }

 stage('Build & Push Docker Image') {
   steps {
 // This 'docker build' command is executed by our agent container,
 // but it controls the *host's* Docker engine via the mounted socket.
  sh """
  echo "Building image: ${env.IMAGE_NAME}"
                    docker build \
                      --build-arg WARFILE='${params.WAR_FILE_PATH}' \
                      --build-arg TOMCAT_USER='tomcat' \
                      --build-arg TOMCAT_PASSWORD='${params.TOMCAT_PASSWORD}' \
                      -t "${env.IMAGE_NAME}" .
                      
                    echo "Pushing image: ${env.IMAGE_NAME}"
                    docker push "${env.IMAGE_NAME}"
                """
            }
        }

        stage('Deploy to GKE') {
            steps {
    // Use credentials again to get cluster access
     withCredentials([file(credentialsId: env.CREDENTIALS_ID, variable: 'SERVICE_ACCOUNT_JSON')]) {
                    sh """
                    export GOOGLE_APPLICATION_CREDENTIALS="\$SERVICE_ACCOUNT_JSON"
                        
  echo "Authenticating kubectl to GKE cluster: ${env.CLUSTER_NAME}"
  gcloud container clusters get-credentials ${env.CLUSTER_NAME} --zone ${env.LOCATION} --project ${env.PROJECT_ID}
                        
 echo "Replacing IMAGE_NAME placeholder in Deployment.yaml"
 # Use a different separator (like |) in case IMAGE_NAME contains slashes
  sed -i.bak "s|IMAGE_NAME|${env.IMAGE_NAME}|g" Deployment.yaml
                        
             echo "Applying Kubernetes manifests..."
               kubectl apply -f Deployment.yaml
               kubectl apply -f service.yaml
               kubectl apply -f ingress.yaml
                    """
                }
            }
        }
    }
    
    // 5. POST-BUILD ACTIONS
    post {
        success { echo "Pipeline completed successfully." }
        failure { echo "Pipeline failed — check logs." }
    }
}
