Give an example of scripted jenkinsfile and explain each section of configuration

Question

Accepted Answer

A Scripted Jenkinsfile is the original implementation of Pipeline as Code, built on the Groovy programming language. Unlike Declarative Pipeline's structured format, Scripted Pipeline gives developers the full power of Groovy to create complex, conditional, and highly customized CI/CD workflows. The entire script runs on the Jenkins controller and requires a `node` block to allocate an executor and workspace. This example demonstrates a complete Scripted Pipeline with all common sections explained. node { // 1. Node block
    // 2. Stage level properties
    stage('Initial Setup') { // 3. Stage definition
        // 4. Environment variables
        def projectName = 'my-app'
        def version = '1.0.0'
        
        echo "Starting pipeline for ${projectName} version ${version}"
    }

// 5. Try-catch for error handling
    try {
        stage('Checkout') {
            // 6. SCM operations
            checkout([
                $class: 'GitSCM',
                branches: [[name: '*/main']],
                userRemoteConfigs: [[url: 'https://github.com/example/repo.git']]
            ])
        }

stage('Build') {
            // 7. Shell execution
            sh '''
                echo "Building application..."
                mvn clean compile
            '''
            
            // 8. Capture output
            def buildVersion = sh(script: 'git describe --tags', returnStdout: true).trim()
            echo "Built version: ${buildVersion}"
        }

stage('Test') {
            parallel(
                unit: {
                    sh 'mvn test'
                },
                integration: {
                    sh 'mvn verify'
                }
            )
            
            // 9. Publish test results
            junit 'target/surefire-reports/*.xml'
        }

stage('Deploy to Staging') {
            // 10. Conditional execution
            if (env.BRANCH_NAME == 'main') {
                sh './deploy-staging.sh'
            } else {
                echo 'Skipping staging deploy - not main branch'
            }
        }

stage('Integration Tests') {
            // 11. Input step for manual approval
            input message: 'Deploy to production?', ok: 'Yes'
            
            sh '''
                echo "Running integration tests..."
                sleep 30
            '''
        }

} catch (Exception e) {
        // 12. Error handling
        echo "Pipeline failed: ${e.message}"
        currentBuild.result = 'FAILURE'
        throw e
    } finally {
        // 13. Cleanup
        stage('Cleanup') {
            echo 'Cleaning up workspace...'
            cleanWs() // Clean workspace
        }
    }

// 14. Post-build status
    if (currentBuild.result == 'SUCCESS') {
        echo 'Pipeline completed successfully'
    } else {
        echo 'Pipeline failed'
    }
} **1. Node Block**: The mandatory `node` block allocates an executor on a Jenkins agent and creates a workspace for the build. Without a node block, Scripted Pipeline cannot execute any steps. This is where the actual build work happens. **2. Stage-Level Properties**: Scripted Pipeline allows Groovy variable declarations anywhere in the script. These variables can hold configuration values, build metadata, or results from previous steps. **3. Stage Definition**: Stages are defined with the `stage` keyword and a name. Unlike Declarative, Scripted Pipeline doesn't require stages to be inside a `stages` block—they can appear anywhere in the code flow. **4. Environment Variables**: Groovy variables can be defined for build configuration. These can be simple strings or capture outputs from shell commands using `sh(returnStdout: true)`. **5. Try-Catch Block**: Scripted Pipeline uses Groovy's native exception handling. The `try-catch-finally` structure provides fine-grained control over error scenarios and cleanup operations. **6. SCM Operations**: The `checkout` step checks out source code from version control. Scripted Pipeline uses the same step syntax as Declarative but with full Groovy flexibility. **7. Shell Execution**: The `sh` step runs shell commands. Multi-line strings (triple quotes) allow complex shell scripts to be embedded directly in the pipeline. **8. Output Capture**: Scripted Pipeline can capture command output using `sh` with `returnStdout: true`, enabling dynamic configuration based on build results. **9. Parallel Execution**: The `parallel` block runs multiple tasks concurrently. Each task is defined as a closure that can contain its own stages and steps. **10. Conditional Execution**: Scripted Pipeline uses standard Groovy `if/else` statements for conditional logic, providing complete flexibility for complex branching. **11. Manual Approval**: The `input` step pauses the pipeline and waits for human approval. This is essential for production deployment gates. **12. Error Handling**: The `catch` block captures exceptions and allows setting build status with `c

Give an example of scripted jenkinsfile and explain each section of configuration

A Scripted Jenkinsfile uses Groovy-based scripting within a node block to define the entire CI/CD workflow with full programmatic control, including stages, environment variables, error handling, and post-build actions

Scenario Questions

Follow-up Questions