声明式 Pipeline 语法

2023-10-18

字数统计: 5.7k字 | 阅读时长≈ 26分

资料来源: Kubernetes全栈架构师：基于世界500强的k8s实战课程

声明式流水线

在声明式流水线语法中，流水线过程定义在 Pipeline{} 中，Pipeline 块定义了整个流水线中完成的所有工作。
在声明式流水线中有效的基本语句和表达式遵循与 Groovy 的语法同样的规则，但有以下例外:

流水线顶层必须是一个 block，即 pipeline{};
分隔符可以不需要分号，但是每条语句都必须在自己的行上;

块只能由 Sections、Directives、Steps 或 assignmentstatements 组成;
属性引用语句被当做是无参数的方法调用，比如 input 会被当做 input()。

示例: 一个以声明式流水线的语法编写的 Jenkinsfile 文件如下:

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'make'
            }
        }
        stage('Test'){
            steps {
                sh 'make check'
                junit 'reports/**/*.xml'
            }
        }
        stage('Deploy') {
            steps {
                sh 'make publish'
            }
        }
    }
}

参数解释:

pipeline: 声明式流水线的一种特定语法，定义了包含执行整个流水线的所有内容和指令，也是声明式流水线的开始;
agent: 声明式流水线的一种特定语法，指示 Jenkins 为整个流水线分配一个执行器和工作区，也就是在流水线中的步骤在哪个 Agent 上执行，该参数同样可以在 stage 中配置;
stage: 描述流水线阶段的语法块，在脚本式流水线语法中，stage(阶段)块是可选的;
steps: 声明式流水线的一种特定语法，它描述了在这个 stage 中要运行的步骤;
sh: 执行一个 shell 命令;
junit: 用于聚合测试报告。

Sections

声明式流水线中的 Sections 不是一个关键字或指令，而是包含一个或多个 Agent, Stages, post, Directives 和 Steps 的代码区域块。

Agent

Agent 表示整个流水线或特定阶段中的步骤和命令执行的位置，该部分必须在 pipeline 块的顶层被定义，也可以在 stage 中再次定义，但是 stage 级别是可选的。

any: 在任何可用的代理上执行流水线，配置语法:
1
2
3
pipeline {
agent any
}
none: 表示该 Pipeline 脚本没有全局的agent配置。当顶层的 agent 配置为 none 时，每个 stage 部分都需要包含它自己的 agent。配置语法:
1
2
3
4
5
6
7
8
pipeline {
agent none
stages {
stage('Stage For Build') {
agent any
}
}
}

label: 选择某个具体的节点执行 Pipeline 命令，例如: agent{label'my-defined-label'}。配置语法:

pipeline {
    agent none
    stages {
        stage('Stage For Build') {
            agent { label 'my-slave-label' }
        }
    }
}

node: 和 label 配置类似，只不过是可以添加一些额外的配置，比如customWorkspace;

dockerfile: 使用从源码中包含的 Dockerfile 所构建的容器执行流水线或 stage。此时对应的 agent 写法如下:

pipeline {
    agent {
        dockerfile {
            filename 'Dockerfile.build'
            dir 'build'
            label 'my-define-label'
            additionalBuildArgs '--build-arg version=1.0.2'
        }
    }
}

docker: 相当于 dockerfile，可以直接使用 docker 字段指定外部镜像即可，可以省去构建的时间。比如使用 maven 镜像进行打包，同时可以指定 args:

pipeline {
    agent {
        docker {
            iamge 'maven:3-alpine'
            label 'my-defined-label'
            args '-v /tmp:/tmp'
        }
    }
}

kubernetes: Jenkins 也支持使用 Kubernetes 创建 Slave，也就是常说的动态 Slave。配置示例如下:

agent {
    kubernetes {
        label podlabel
        yaml """
kind: Pod
metadata:
  name: jenkins-agent
spec:
  containers:
  - name: kaniko
    image: gcr.io/kaniko-project/executor:debug
    imagePullPolicy: Always
    command:
    - /busybox/cat
    tty: true
    volumeMounts:
    - name: aws-secret
      mountPath: /root/.aws/
    - name: docker-registry-config
      mountPath: /kaniko/.docker
    restartPolicy: Never
  volumes:
  - name: aws-secret
    secret:
      secretName: aws-secret
  - name: docker-registry-config
    configMap:
      name: docker-registry-config
"""
}

Agent 配置示例

示例1: 假设有一个 Java 项目，需要用 mvn 命令进行编译，此时可以使用 maven 的镜像作为 agent。配置如下:

pipeline {
    agent { docker 'maven:3-alpine' }
    stages {
        stage('Example Build') {
            steps {
                sh 'mvn -B clean verify'
            }
        }
    }
}

示例2: 本示例在流水线顶层将 agent 定义为 none，那么此时 stage 部分就需要必须包含它自己的 agent 部分。在 stage(‘Example Build’) 部分使用 maven:3-alpine 执行该阶段步骤，在 stage(‘Example Test’) 部分使用 openjdk:8-jre 执行该阶段步骤。此时 Pipeline 如下:

pipeline {
    agent none
    stages {
        stage('Example Build') {
            agent { docker 'maven:3-alpine' }
            steps {
                echo 'Hello, Maven'
                sh 'mvn --version'
            }
        }
        stage('Example Test') {
            agent { docker 'openjdk:8-jre' }
            steps {
                echo 'Hello, JDK'
                sh 'java -version'
            }
        }
    }
}

示例3: 上述的示例也可以用基于 Kubernetes 的 agent 实现。比如定义具有三个容器的 Pod，分别为 jnlp(负责和 Jenkins Master 通信)、build(负责执行构建命令)、kubectl(负责执行 kubernetes 相关命令)，在 steps 中可以通过 containers 字段，选择在某个容器执行命令:

pipeline {
    agent {
        kubernetes {
            cloud 'kubernetes-default'
            slaveConnectTimeout 1200
            yaml '''
apiVersion: v1
kind: Pod
spec:
  containers:
  - args: [\'$(JENKINS_SECRET)\', \'$(JENKINS_NAME)\']
    image: 'registry.cn-beijing.aliyuncs.com/citools/jnlp:alpine'
    name: jnlp
    imagePullPolicy: IfNotPresent
  - command:
      - "cat"
    image: "registry.cn-beijing.aliyuncs.com/citools/maven:3.5.3"
    imagePullPolicy: "IfNotPresent"
    name: "build"
    tty: true
  - command:
      - "cat"
    image: "registry.cn-beijing.aliyuncs.com/citools/kubectl:self-1.17"
    imagePullPolicy: "IfNotPresent"
    name: "kubectl"
    tty: true
'''
        } 
    }
    stages {
        stage('Building') {
            steps {
                container(name: 'build') {
                sh """
                    mvm clean install
                """
                }
            }
        }
        stage('Deploy') {
            steps {
                container(name: 'kubectl') {
                sh """
                    kubectl get node
                """
                }
            }
        }
    }
}

Post

Post 一般用于流水线结束后的进一步处理，比如错误通知等。Post 可以针对流水线不同的结果做出不同的处理，就像开发程序的错误处理，比如 Python 语言的 try catch。Post 可以定义在 Pipeline 或 stage 中，目前支持以下条件:

always: 无论 Pipeline 或 stage 的完成状态如何，都允许运行该 post 中定义的指令;
changed: 只有当前 Pipeline 或 stage 的完成状态与它之前的运行不同时，才允许在该 post 部分运行该步骤;
fixed: 当本次 Pipeline 或 stage 成功，且上一次构建是失败或不稳定时，允许运行该 post 中定义的指令;
regression: 当本次 Pipeline 或 stage 的状态为失败、不稳定或终止，且上一次构建的状态为成功时，允许运行该 post 中定义的指令;
failure: 只有当前 Pipeline 或 stage 的完成状态为失败(failure)，才允许在 post 部分运行该步骤，通常这时在 Web 界面中显示为红色;
success: 当前状态为成功(success)，执行 post 步骤，通常在Web界面中显示为蓝色或绿色;
unstable: 当前状态为不稳定(unstable)，执行 post 步骤，通常由于测试失败或代码违规等造成，在 Web 界面中显示为黄色;
aborted: 当前状态为终止(aborted)，执行该 post 步骤，通常由于流水线被手动终止触发，这时在 Web 界面中显示为灰色;
unsuccessful: 当前状态不是 success 时，执行该 post 步骤;
cleanup: 无论 pipeline 或 stage 的完成状态如何，都允许运行该post中定义的指令。和 always 的区别在于，cleanup 会在其它执行之后执行。

Post 配置示例

示例1: 一般情况下 post 部分放在流水线的底部，比如本实例，无论 stage 的完成状态如何，都会输出一条 I will always say Hello again! 信息:

pipeline {
    agent any
    stages {
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
    post {
        always {
            echo 'I will always say Hello again!'
        }
    }
}

示例2: 也可以将 post 写在 stage:

pipeline {
    agent any
    stages {
        stage('Test') {
            steps {
                sh 'EXECUTE_TEST_COMMAND'
            }
            post {
                failure {
                    echo "Pipeline Testing failure ..."
                }
            }
        }
    }
}

Stages

Stages 包含一个或多个 stage 指令，同时可以在 stage 中的 steps 块中定义真正执行的指令。

Stages 配置示例

示例1: 比如创建一个流水线，stages 包含一个名为 Example 的 stage，该 stage 执行 echo ‘Hello World’ 命令输出 Hello World 字符串:

pipeline {
    agent any
    stages {
        stage('Example') {
            steps {
                echo 'Hello World ${env.BUILD_ID}'
            }
        }
    }
}

Steps

Steps 部分在给定的 stage 指令中执行的一个或多个步骤

Steps 配置示例

示例1: 比如在 steps 定义执行一条 echo 命令:

pipeline {
    agent any
    stages {
        stage('Example') {
            steps {
                sh "echo 'Hello World'"
            }
        }
    }
}

或者是使用 sh 字段执行多条指令

pipeline {
    agent any
    stages {
        stage('Example') {
            steps {
                sh """
                    echo 'Execute building...'
                    mvn clean install
                """
            }
        }
    }
}

Directives

Directives 可用于一些执行 stage 时的条件判断或预处理一些数据，和 Sections 一致，Directives 不是一个关键字或指令，而是包含了 environment、options、parameters、triggers、stage、tools、 input、when 等配置。

Environment

Environment 主要用于在流水线中配置的一些环境变量，根据配置的位置决定环境变量的作用域。可以定义在 pipeline 中作为全局变量，也可以配置在 stage 中作为该 stage 的环境变量。

该指令支持一个特殊的方法 credentials()，该方法可用于在 Jenkins 环境中通过标识符访问预定义的凭证。对于类型为 Secret Text 的凭证，credentials() 可以将该 Secret 中的文本内容赋值给环境变量。对于类型为标准的账号密码型的凭证，指定的环境变量为 username 和 password，并且也会定义两个额外的环境变量，分别为 MYVARNAME_USR 和 MYVARNAME_PSW。

Environment 配置示例

示例1: 假如需要定义个变量名为 CC 的全局变量和一个名为 AN_ACCESS_KEY 的局部变量，并且用 credentials 读取一个 Secret 文本，可以通过以下方式定义:

pipeline {
    agent any
    environment { // Pipeline中定义，属于全局变量
        CC = 'clang'
    }
    stages {
        stage('Example') {
            environment { // 定义在 stage 中，属于局部变量
                AN_ACCESS_KEY = credentials('my-prefined-secret-text')
            }
            steps {
                sh 'printenv'
            }
        }
    }
}

Options

Jenkins 流水线支持很多内置指令，比如 retry 可以对失败的步骤进行重复执行 n 次，可以根据不同的指令实现不同的效果。比较常用的指令如下:

buildDiscarder: 保留多少个流水线的构建记录。比如:

1
2
3

options {
    buildDiscarder (logRotator(numTokeepStr: '1'))
}

disableConcurrentBuilds: 禁止流水线并行执行，防止并行流水线同时访问共享资源导致流水线失败。比如:
1
2
3
options {
disableConcurrentBuilds()
}
disableResume: 如果控制器重启，禁止流水线自动恢复。比如:
1
2
3
options {
disableResume()
}
newContainerPerStage: agent 为 docker 或 dockerfile 时，每个阶段将在同一个节点的新容器中运行，而不是所有的阶段都在同一个容器中中运行。
1
2
3
options {
newContainerPerStage()
}
quietPeriod: 流水线静默期，也就是触发流水线后等待一会再执行。比如:
1
2
3
options {
quietPeriod(30)
}
retry: 流水线失败后重试次数。比如:
1
2
3
options {
retry(3)
}
timeout: 设置流水线的超时时间，超过流水线时间，job 会自动终止。比如:
1
2
3
options {
timeout(time: 1, unit: 'HOURS')
}
timestamps: 为控制台输出时间戳。比如:
1
2
3
options {
timestamps()
}

Option 除了写在 Pipeline 顶层，还可以写在 stage 中，但是写在 stage 中的 option 仅支持 retry、 timeout、timestamps，或者是和 stage 相关的声明式选项，比如 skipDefaultCheckout。

Options 配置示例

示例1: 配置示例如下，只需要添加 options 字段即可

pipeline {
    agent any
    options {
        timeout(time: 1, unit: 'HOURS')
        timestamps()
    }
    stages {
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
}

示例2: 处于 stage 级别的 options 写法如下:

pipeline {
    agent any
    stages {
        stage('Example') {
            options {
                timeout(time: 1, unit: 'HOURS')
            } 
            steps {
                echo 'Hello World'
            }
        }
    }
}

Parameters

Parameters 提供了一个用户在触发流水线时应该提供的参数列表，这些用户指定参数的值可以通过 params 对象提供给流水线的 step(步骤)。

目前支持的参数类型如下:

string: 字符串类型的参数，例如:
1
parameters{string(name:'DEPLOY_ENV',defaultValue: 'staging', description: '') }
表示定义一个名为 DEPLOY_ENV 的字符型变量，默认值为 staging;
text: 文本型参数，一般用于定义多行文本内容的变量。例如:
1
parameters { text(name: 'DEPLOY_TEXT', defaultValue: 'One\nTwo\nThree\n', description: '') }
表示定义一个名为 DEPLOY_TEXT 的变量，默认值是 'One\nTwo\nThree\n';

booleanParam: 布尔型参数，例如:

1	parameters{booleanParam(name:'DEBUG_BUILD',defaultValue: true, description: '') }

choice: 选择型参数，一般用于给定几个可选的值，然后选择其中一个进行赋值，例如:
1
parameters { choice(name: 'CHOICES', choices: ['one', 'two', 'three'], description: '') }
表示定义一个名为 CHOICES 的变量，可选的值为 one、two、three;
password: 密码型变量，一般用于定义敏感型变量，在 Jenkins 控制台会输出为 * 。例如:
1
parameters { password(name: 'PASSWORD', defaultValue: 'SECRET', description: 'Asecret password') }
表示定义一个名为 PASSWORD 的变量，其默认值为 SECRET。

Parameters 配置示例

示例1:

pipeline {
    agent any
    parameters {
        string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')
        text(name: 'BIOGRAPHY', defaultValue: '', description: 'Enter some information about the person')
        booleanParam(name: 'TOGGLE', defaultValue: true, description: 'Toggle this value')
        choice(name: 'CHOICE', choices: ['One', 'Two', 'Three'], description: 'Pick something')
        password(name: 'PASSWORD', defaultValue: 'SECRET', description: 'Enter a password')
    } 
    stages {
        stage('Example') {
            steps {
                echo "Hello ${params.PERSON}"
                echo "Biography: ${params.BIOGRAPHY}"
                echo "Toggle: ${params.TOGGLE}"
                echo "Choice: ${params.CHOICE}"
                echo "Password: ${params.PASSWORD}"
            }
        }
    }
}

Triggers

在 Pipeline 中可以用 triggers 实现自动触发流水线执行任务，可以通过 Webhook、Cron、 pollSCM 和 upstream 等方式触发流水线。

Triggers 配置示例

示例1: 假如某个流水线构建的时间比较长，或者某个流水线需要定期在某个时间段执行构建，可以使用 cron 配置触发器，比如周一到周五每隔四个小时执行一次:

pipeline {
    agent any
    triggers {
        cron('H */4 * * 1-5')
    }
    stages {
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
}

注意: H 的意思不是 HOURS 的意思，而是 Hash 的缩写。主要为了解决多个流水线在同一时间同时运行带来的系统负载压力。

示例2: 使用 cron 字段可以定期执行流水线，如果代码更新想要重新触发流水线，可以使用 pollSCM 字段:

pipeline {
    agent any
    triggers {
        pollSCM('H */4 * * 1-5')    // 按这个计划任务时间检查代码是否更新
    }
    stages {
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
}

示例3: Upstream 可以根据上游 job 的执行结果决定是否触发该流水线。比如当 job1 或 job2 执行成功时触发该流水线

pipeline {
    agent any
    triggers {
        upstream(upstreamProjects: 'job1,job2', threshold: hudson.model.Result.SUCCESS)
    }
    stages {
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
}

目前支持的状态有 SUCCESS、UNSTABLE、FAILURE、NOT_BUILT、ABORTED 等。

Input

Input 字段可以实现在流水线中进行交互式操作，比如选择要部署的环境、是否继续执行某个阶段等。

配置 Input 支持以下选项:

message: 必选，需要用户进行 input 的提示信息，比如: “是否发布到生产环境?”;
id: 可选，input 的标识符，默认为 stage 的名称;
ok: 可选，确认按钮的显示信息，比如:“确定”、“允许”;
submitter: 可选，允许提交 input 操作的用户或组的名称，如果为空，任何登录用户均可提交 input;
parameters: 提供一个参数列表供input使用。

Input 配置示例

示例1: 假如需要配置一个提示消息为 “还继续么”、确认按钮为 “继续”、提供一个 PERSON 的变量参数，并且只能由登录用户为 alice 和 bob 提交的 input 流水线:

pipeline {
    agent any
    stages {
        stage('Example') {
            input {
                message "还继续么?"
                ok "继续"
                submitter "alice,bob"
                parameters {
                    string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')
                }
            }
            steps {
                echo "Hello, ${PERSON}, nice to meet you."
            }
        }
    }
}

When

When 指令允许流水线根据给定的条件决定是否应该执行该 stage，when 指令必须包含至少一个条件。如果 when 包含多个条件，所有的子条件必须都返回 True，stage 才能执行。When 也可以结合 not、allOf、anyOf 语法达到更灵活的条件匹配。

目前比较常用的内置条件如下:

branch: 当正在构建的分支与给定的分支匹配时，执行这个 stage，例如:
1
when {branch 'master' }
注意，branch 只适用于多分支流水线;
changelog: 匹配提交的 changeLog 决定是否构建，例如:
1
when { changelog '.*^\\[DEPENDENCY\\] .+$' }
environment: 当指定的环境变量和给定的变量匹配时，执行这个stage，例如:
1
when { environment name: 'DEPLOY_TO', value: 'production' }
equals: 当期望值和实际值相同时，执行这个stage，例如:
1
when {equals expected:2, actual: currentBuild.number }
expression: 当指定的 Groovy 表达式评估为 True，执行这个 stage，例如:
1
when { expression { return params.DEBUG_BUILD } }
tag: 如果 TAG_NAME 的值和给定的条件匹配，执行这个 stage，例如:
1
when { tag "release-*" }
not: 当嵌套条件出现错误时，执行这个 stage，必须包含一个条件，例如:
1
when {not { branch 'master' } }
allOf: 当所有的嵌套条件都正确时，执行这个 stage，必须包含至少一个条件，例如:
1
when { allOf { branch 'master'; environment name: 'DEPLOY_TO', value: 'production' } }
anyOf: 当至少有一个嵌套条件为 True 时，执行这个 stage，例如:
1
when { anyOf {branch 'master'; branch 'staging' } }

When 配置示例

示例1: 当分支为 production 时，执行 Example Deploy 步骤:

pipeline {
    agent any
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            when {
                branch 'production'
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}

示例2: 也可以同时配置多个条件，比如分支是 production，而且 DEPLOY_TO 变量的值为 production 时，才执行 Example Deploy:

pipeline {
    agent any
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            } 
        }
        stage('Example Deploy') {
            when {
                branch 'production'
                environment name: 'DEPLOY_TO', value: 'production'
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}

示例3: 也可以使用 anyOf 进行匹配其中一个条件即可，比如分支为 production，DEPLOY_TO 为 production 或 staging 时执行 Deploy:

pipeline {
    agent any
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            when {
                branch 'production'
                anyOf {
                    environment name: 'DEPLOY_TO', value: 'production'
                    environment name: 'DEPLOY_TO', value: 'staging'
                }
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}

示例4: 也可以使用 expression 进行正则匹配，比如当 BRANCH_NAME 为 production 或 staging，并且 DEPLOY_TO 为 production 或 staging 时才会执行 Example Deploy:

pipeline {
    agent any
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            when {
                expression { BRANCH_NAME ==~ /(production|staging)/ }
                anyOf {
                    environment name: 'DEPLOY_TO', value: 'production'
                    environment name: 'DEPLOY_TO', value: 'staging'
                }
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}

默认情况下，如果定义了某个 stage 的 agent，在进入该 stage 的 agent 后，该 stage 的 when 条件才会被评估，但是可以通过一些选项更改此选项。比如在进入 stage 的 agent 之前评估 when，可以使用 beforeAgent，当 when 为 true 时才进行该 stage。

目前支持的前置条件如下:

beforeAgent: 如果 beforeAgent 为 true，则会先评估 when 条件。在 when 条件为 true 时，才会进入该 stage;
beforeInput: 如果 beforeInput 为 true，则会先评估 when 条件。在 when 条件为 true 时，才会进入到 input 阶段;
beforeOptions: 如果 beforeInput 为 true，则会先评估 when 条件。在 when 条件为 true 时，才会进入到 options 阶段;

注意: beforeOptions 优先级大于 beforeInput 大于 beforeAgent

示例: 配置一个 beforeAgent 示例如下

pipeline {
    agent none
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            agent {
                label "some-label"
            }
            when {
                beforeAgent true
                branch 'production'

            }
            steps {
                echo 'Deploying'
            }
        }
    }
}

配置一个 beforeInput 示例如下:

pipeline {
    agent none
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            when {
                beforeInput true
                branch 'production'
            }
            input {
                message "Deploy to production?"
                id "simple-input"
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}

配置一个 beforeOptions 示例如下:

pipeline {
    agent none
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            when {
                beforeOptions true
                branch 'testing'
            }
            options {
                lock label: 'testing-deploy-envs', quantity: 1, variable: 'deployEnv'
            }
            steps {
                echo "Deploying to ${deployEnv}"
            }
        }
    }
}

Parallel

在声明式流水线中可以使用 Parallel 字段，即可很方便的实现并发构建

示例1: 比如对分支 A、B、C 进行并行处理:

pipeline {
    agent any
    stages {
        stage('Non-Parallel Stage') {
            steps {
                echo 'This stage will be executed first.'
            }
        }
        stage('Parallel Stage') {
            when {
                branch 'master'
            }
            failFast true
            parallel {
                stage('Branch A') {
                    agent {
                        label "for-branch-a"
                    }
                    steps {
                        echo "On Branch A"
                    }
                }
                stage('Branch B') {
                    agent {
                        label "for-branch-b"
                    }
                    steps {
                        echo "On Branch B"
                    }
                }
                stage('Branch C') {
                    agent {
                        label "for-branch-c"
                    }
                    stages {
                        stage('Nested 1') {
                            steps {
                                echo "In stage Nested 1 within Branch C."
                            }
                        }
                        stage('Bested 2') {
                            steps {
                                echo "In stage Nested 2 within Branch C."
                            }
                        }
                    }
                }
            }
        }
    }
}

设置 failFast 为 true 表示当并行流水线中任意一个 stage 出现错误，其他 stage 也会立即终止。也可以通过 options 配置在全局:

pipeline {
    agent any
    options {
        parallelsAlwaysFailFast()
    }
    stages {
        stage('Non-Parallel Stage') {
            steps {
                echo 'This stage will be executed first.'
            }
        }
        stage('Parallel Stage') {
            when {
                branch 'master'
            }
            parallel {
                stage('Branch A') {
                    agent {
                        label "for-branch-a"
                    }
                    steps {
                        echo "On Branch A"
                    }
                }
                stage('Branch B') {
                    agent {
                        label "for-branch-b"
                    }
                    steps {
                        echo "On Branch B"
                    }
                }
                stage('Branch C') {
                    agent {
                        label "for-branch-c"
                    }
                    stages {
                        stage('Nested 1') {
                            steps {
                                echo "In stage Nested 1 within Branch C."
                            }
                        }
                        stage('Bested 2') {
                            steps {
                                echo "In stage Nested 2 within Branch C."
                            }
                        }
                    }
                }
            }
        }
    }
}