The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Declarative vs Scripted Pipelines

Next ►
►

In Jenkins, pipelines can be defined using two different syntaxes: Declarative and Scripted. Understanding the differences between these two approaches is crucial for creating efficient and maintainable CI/CD pipelines.

Key Concepts

Declarative Pipelines

  • Structure: Declarative pipelines provide a more structured and opinionated syntax. They are defined within a pipeline block.
  • Ease of Use: Easier to read and write, especially for beginners.
  • Error Handling: Built-in error handling and validation.
  • Stages and Steps: Clearly defined stages and steps.
  • Best Practices: Encourages best practices by design.

Scripted Pipelines

  • Structure: Scripted pipelines use a more flexible and powerful Groovy-based syntax.
  • Flexibility: Offers more control and flexibility, suitable for complex workflows.
  • Learning Curve: Steeper learning curve due to its flexibility and complexity.
  • Customization: Allows for extensive customization and scripting.

Comparison Table

Feature Declarative Pipelines Scripted Pipelines
Syntax Structured, opinionated Flexible, Groovy-based
Learning Curve Easier for beginners Steeper, more complex
Error Handling Built-in validation and error handling Requires manual error handling
Readability High, due to structured format Lower, can be complex
Flexibility Limited to predefined constructs Highly flexible, allows custom scripting
Use Case Simple to moderately complex pipelines Complex and highly customized pipelines

Practical Examples

Declarative Pipeline Example

pipeline {
    agent any

    stages {
        stage('Build') {
            steps {
                echo 'Building...'
                // Add build steps here
            }
        }
        stage('Test') {
            steps {
                echo 'Testing...'
                // Add test steps here
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying...'
                // Add deploy steps here
            }
        }
    }
}

Explanation:

  • pipeline: The root block for a declarative pipeline.
  • agent any: Specifies that the pipeline can run on any available agent.
  • stages: Contains a sequence of stages.
  • stage: Represents a phase in the pipeline (e.g., Build, Test, Deploy).
  • steps: Contains the actual steps to be executed within a stage.

Scripted Pipeline Example

node {
    try {
        stage('Build') {
            echo 'Building...'
            // Add build steps here
        }
        stage('Test') {
            echo 'Testing...'
            // Add test steps here
        }
        stage('Deploy') {
            echo 'Deploying...'
            // Add deploy steps here
        }
    } catch (Exception e) {
        echo "An error occurred: ${e.message}"
    } finally {
        echo 'Pipeline completed.'
    }
}

Explanation:

  • node: The root block for a scripted pipeline, indicating the pipeline runs on a Jenkins node.
  • try-catch-finally: Used for error handling.
  • stage: Represents a phase in the pipeline (e.g., Build, Test, Deploy).
  • echo: Prints a message to the console.

Practical Exercise

Exercise: Create a Declarative Pipeline

  1. Objective: Create a simple declarative pipeline with three stages: Build, Test, and Deploy.
  2. Steps:
    • Open Jenkins and create a new pipeline job.
    • Use the following pipeline script:
pipeline {
    agent any

    stages {
        stage('Build') {
            steps {
                echo 'Building...'
            }
        }
        stage('Test') {
            steps {
                echo 'Testing...'
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying...'
            }
        }
    }
}
  1. Run the Pipeline: Save the job and run the pipeline. Observe the output in the console.

Solution

The provided script should work as expected, printing messages for each stage.

Common Mistakes and Tips

  • Declarative Pipelines:

    • Ensure all stages and steps are correctly nested within the pipeline block.
    • Use the agent directive to specify where the pipeline should run.

  • Scripted Pipelines:

    • Properly handle exceptions using try-catch blocks.
    • Use the node block to define the execution environment.

Conclusion

Understanding the differences between declarative and scripted pipelines is essential for choosing the right approach for your Jenkins workflows. Declarative pipelines offer simplicity and structure, making them ideal for most use cases, while scripted pipelines provide the flexibility needed for more complex scenarios. By mastering both, you can create efficient and maintainable CI/CD pipelines in Jenkins.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved