Pipeline 声明式和脚本式的主要区别

什么是 Pipeline

在进一步讨论 Pipeline 两种语法模型的区别前先来了解下什么是 pipeline，为什么要到它。

Pipeline 是 Jenkins 中的一套自动化流程框架，代表一系列工作流或活动流，作用是允许将单个Jenkins节点或者多个节点的任务组合连接起来，从而实现单个任务难以完成的复杂构建工作。

它有以下优点：

• Code(代码): Pipeline 的任务是通过代码来实现的，可以通过git来进行版本化控制，团队成员可以编辑迭代Pipeline 代码
• Durable(持久化): 无论 Jenkins master 是在计划内或者非计划内重启，pipeline 任务都不会收到影响
• Pausable(可暂定性) pipeline基于groovy可以实现job的暂停和等待用户的输入或批准然后继续执行。
• Versatile(多功能) 支持fork/join、循环执行，并行执行任务
• Extensible(可扩展性) 支持其DSL的自定义扩展 ，以及与其他插件集成的多个选项

Pipeline 语法

Pipeline 包括声明式语法和脚本式语法

声明式

pipeline {
    agent any // 
    stages {
        stage('Build') { 
            steps {
                // 
            }
        }
        stage('Test') { 
            steps {
                // 
            }
        }
        stage('Deploy') { 
            steps {
                // 
            }
        }
    }
}

• agent any: 任意可用的agent都可以执行
• stages：代表整个流水线的所有执行阶段。通常stages只有1个，里面包含多个stage
• stage：代表流水线中的某个阶段，可能出现n个。一般分为拉取代码，编译构建，部署等阶段。
• steps：代表一个阶段内需要执行的逻辑。steps里面是shell脚本，git拉取代码，ssh远程发布等任意内容。

脚本式

node {  
    stage('Build') { 
        // 
    }
    stage('Test') { 
        // 
    }
    stage('Deploy') { 
        // 
    }
}

• node：节点，一个 Node 就是一个 Jenkins 节点，Master 或者 Agent，是执行 Step 的具体运行环境
• Stage：阶段，一个 Pipeline 可以划分为若干个 Stage，每个 Stage 代表一组操作，比如：Build、Test、Deploy，Stage 是一个逻辑分组的概念。

声明式和脚本式的主要区别

1. Pipeline 代码校验

声明式 Pipeline 会在执行前就会校验 Pipeline 语法是否正确，而脚本式不会。

观察下面声明式例子，stage Test 里面的 ‘echo 1’ 有语法错误，echo 只可以接受字符串，尝试执行该 pipeline时，会立即报错

pipeline {
    agent any

    stages {
        stage("Build") {
            steps {
                echo "Some code compilation here..."
            }
        }

        stage("Test") {
            steps {
                echo "Some tests execution here..."
                echo 1
            }
        }
    }
}

同样脚本式的例子如下，会直到执行到 stage Test 才会报错

node {
    stage("Build") {
        echo "Some code compilation here..."
    }

    stage("Test") {
        echo "Some tests execution here..."
        echo 1
    }
}

想象一下如果有多个 stage，前面的stage 执行都没有问题而最后一个stage 出问题，这将会浪费一定的时间

2. 重启 stage

如果某个 stage 执行失败，修复后声明式 Pipeline 可以直接跳到该 stage 重新执行，而脚本式要从头来过。

观察下面两个图，声明式可以 restart stage，脚本式不能

3. Option 指令

option指令用于配置整个jenkins pipeline本身的选项，根据具体的选项不同，可以将其放在pipeline块或者stage块中。

虽然声明式pipeline 和脚本式 pipeline 都支持 options 选项，但声明式 options 和 pipeline 代码逻辑是分开的，而脚本式 options 和代码逻辑是嵌套在一起的，如果有多个options需要设置代码可读性差。观察下面例子：

声明式

pipeline {
    agent any

    options {
        timestamps()
        ansiColor("xterm")
    }

    stages {
        stage("Build") {
            options {
                timeout(time: 1, unit: "MINUTES")
            }
            steps {
                sh 'printf "\\e[31mSome code compilation here...\\e[0m\\n"'
            }
        }

        stage("Test") {
            options {
                timeout(time: 2, unit: "MINUTES")
            }
            steps {
                sh 'printf "\\e[31mSome tests execution here...\\e[0m\\n"'
            }
        }
    }
}

脚本式

node {
    timestamps {
        ansiColor("xterm") {
            stage("Build") {
                timeout(time: 1, unit: "MINUTES") {
                    sh 'printf "\\e[31mSome code compilation here...\\e[0m\\n"'
                }
            }
            stage("Test") {
                timeout(time: 2, unit: "MINUTES") {
                    sh 'printf "\\e[31mSome tests execution here...\\e[0m\\n"'
                }
            }
        }
    }
}

4. 条件执行 stage 的处理方式

观察下面声明式例子，添加条件当 env.FOO 等于 bar 时才执行 test stage

声明式

pipeline {
    agent any

    options {
        timestamps()
        ansiColor("xterm")
    }

    stages {
        stage("Build") {
            options {
                timeout(time: 1, unit: "MINUTES")
            }
            steps {
                sh 'printf "\\e[31mSome code compilation here...\\e[0m\\n"'
            }
        }

        stage("Test") {
            when {
                environment name: "FOO", value: "bar"
            }
            options {
                timeout(time: 2, unit: "MINUTES")
            }
            steps {
                sh 'printf "\\e[31mSome tests execution here...\\e[0m\\n"'
            }
        }
    }
}

脚本式

node {
    timestamps {
        ansiColor("xterm") {
            stage("Build") {
                timeout(time: 1, unit: "MINUTES") {
                    sh 'printf "\\e[31mSome code compilation here...\\e[0m\\n"'
                }
            }
            if (env.FOO == "bar") {
                stage("Test") {
                    timeout(time: 2, unit: "MINUTES") {
                        sh 'printf "\\e[31mSome tests execution here...\\e[0m\\n"'
                    }
                }
            }
        }
    }
}

从结果来看，声明式会正常跳过 Test stage，而脚本式需要if 判断才会添加 test stage，所以 test stage 根本没有被渲染出来，这会一定程序上造成困扰。

5. 语法逻辑

声明式支持 stages，steps 更细致的阶段性任务划分，脚本式只支持 stage, 编写逻辑时，声明式要在 script{} 标记里面写，脚本式不用，观察下面例子

声明式

 pipeline {  
   agent {    
     // executes on an executor with the label 'some-label' or 'docker'
     label "some-label || docker"    
   }   

   stages {   
     stage("foo") {     
       steps {       
         // variable assignment (other than environment variables) can only be done in a script block
         // complex global variables (with properties or methods) can only be run in a script block
         // env variables can also be set within a script block
         script {          
           foo = docker.image('ubuntu')
           env.bar = "${foo.imageName()}"
           echo "foo: ${foo.imageName()}"          
         }        
       }      
     }
     stage("bar") {
       steps{  
         echo "bar: ${env.bar}"
         echo "foo: ${foo.imageName()}" 
       }      
     }
   } 
 }

脚本式

 node {

   git url: 'https://github.com/jfrogdev/project-examples.git'

   // Get Artifactory server instance, defined in the Artifactory Plugin administration page.
   def server = Artifactory.server "SERVER_ID"

   // Read the upload spec and upload files to Artifactory.
   def downloadSpec =
           '''{
       "files": [     
         {
            "pattern": "libs-snapshot-local/*.zip",
            "target": "dependencies/",
            "props": "p1=v1;p2=v2"
         }      
       ]    
   }'''

   def buildInfo1 = server.download spec: downloadSpec

   // Read the upload spec which was downloaded from github.
   def uploadSpec =
           '''{
     "files": [
       {
          "pattern": "resources/Kermit.*",
          "target": "libs-snapshot-local",
          "props": "p1=v1;p2=v2"
       },
       {
          "pattern": "resources/Frogger.*",
          "target": "libs-snapshot-local"
       }
      ]
   }'''


   // Upload to Artifactory.
   def buildInfo2 = server.upload spec: uploadSpec

   // Merge the upload and download build-info objects.
   buildInfo1.append buildInfo2

   // Publish the build to Artifactory
   server.publishBuildInfo buildInfo1
}

总结

• 声明式语法是 Jenkins 官方推荐的写法，它的特点是语法简单，无需专业的编程知识也能快速上手，同时语法也更为严谨，有许多限制，失去了一定的灵活性。
• 脚本式语法可以让你灵活的运用代码，就像一张白纸，你可以更灵活地对任务逻辑进行编排，适合有大量特定要求、逻辑复杂的任务。同样灵活的背后是没有形成统一的逻辑结构或流程，可能造成代码的不稳定，难以维护以及可读性差。

参考链接

• Pipeline
• Jenkins Scripted Pipeline vs. Declarative Pipeline - the 4 practical differences
• Declarative vs Scripted Pipeline – Key differences
• Pipeline简介