目 录CONTENT

文章目录

Jenkins Pipeline入门

简中仙
2023-05-25 / 0 评论 / 0 点赞 / 118 阅读 / 0 字 / 正在检测是否收录...
温馨提示:
本文最后更新于2023-10-08,若内容或图片失效,请留言反馈。 本文如有错误或者侵权的地方,欢迎您批评指正!

一、Jenkins Pipeline 介绍

要实现在 Jenkins 中的构建工作,可以有多种方式,我们这里采用比较常用的 Pipeline 这种方式。Pipeline,简单来说,就是一套运行在 Jenkins 上的工作流框架,将原来独立运行于单个或者多个节点的任务连接起来,实现单个任务难以完成的复杂流程编排可视化的工作。

Jenkins Pipeline 有几个核心概念:

  • Node:节点,一个 Node 就是一个 Jenkins 节点,Master 或者 Agent,是执行 Step 的具体运行环境,比如我们之前动态运行的 Jenkins Slave 就是一个 Node 节点
  • Stage:阶段,一个 Pipeline 可以划分为若干个 Stage,每个 Stage 代表一组操作,比如:Build、Test、Deploy,Stage 是一个逻辑分组的概念,可以跨多个 Node
  • Step:步骤,Step 是最基本的操作单元,可以是打印一句话,也可以是构建一个 Docker 镜像,由各类 Jenkins 插件提供,比如命令:sh 'make',就相当于我们平时 shell 终端中执行 make 命令一样。

那么我们如何创建 Jenkins Pipline 呢?

  • Pipeline 脚本是由 Groovy 语言实现的,但是我们没必要单独去学习 Groovy,当然你会的话最好
  • Pipeline 支持两种语法:Declarative(声明式)和 Scripted Pipeline(脚本式)语法
  • Pipeline 也有两种创建方法:可以直接在 Jenkins 的 Web UI 界面中输入脚本;也可以通过创建一个 Jenkinsfile 脚本文件放入项目源码库中
  • 一般我们都推荐在 Jenkins 中直接从源代码控制(SCMD)中直接载入 Jenkinsfile Pipeline 这种方法

二、什么是流水线

1、声明式流水线

在声明式流水线语法中,流水线过程定义在 Pipeline{}中,Pipeline 块定义了整个流水线中完成的所有工作,比如:

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

参数说明

  • agent any:在任何可用的代理上执行流水线或它的任何阶段,也就是执行流水线过程的位置,也可以指定到具体的节点;
  • stage:定义流水线的执行过程(相当于一个阶段),比如上文所示的 Build、Test、Deploy,但是这个名字是根据实际情况进行定义的,并非固定的名字;
  • steps:执行某阶段具体的步骤。

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

Jenkinsfile (Declarative Pipeline) 
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:用于聚合测试报告。

2、脚本化流水线

在脚本化流水线语法中,会有一个或多个 Node(节点)块在整个流水线中执行核心工作,比如:

Jenkinsfile (Scripted Pipeline) 
node {   
    stage('Build') {  
        //  
    } 
    stage('Test') {  
        //  
    } 
    stage('Deploy') {  
        //  
    } 
}

参数说明:

  • node:在任何可用的代理上执行流水线或它的任何阶段,也可以指定到具体的节点;
  • stage:和声明式的含义一致,定义流水线的阶段。Stage 块在脚本化流水线语法中是可选的,然而在脚本化流水线中实现 stage 块,可以清楚地在 Jenkins UI 界面中显示每个stage 的任务子集。

上一小节的声明式流水线也可以用以下脚本式流水线替代:

Jenkinsfile (Scripted Pipeline) 
node {  
    stage('Build') {  
        sh 'make'  
    } 
    stage('Test') { 
        sh 'make check' 
        junit 'reports/**/*.xml'  
    } 
    stage('Deploy') { 
        sh 'make publish' 
    } 
}

三、声明式 Pipeline 语法

声明式流水线必须包含在一个 Pipeline 块中,比如以下是一个 Pipeline 块的格式:

pipeline { 
    /* insert Declarative Pipeline here */ 
}

在声明式流水线中有效的基本语句和表达式遵循与 Groovy 的语法同样的规则,但有以下例外:

  • 流水线顶层必须是一个 block,即 pipeline{};
  • 分隔符可以不需要分号,但是每条语句都必须在自己的行上;
  • 块只能由 Sections、Directives、Steps 或 assignment statements 组成;
  • 属性引用语句被当做是无参数的方法调用,比如 input 会被当做 input()。

1、Sections

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

1、Agent

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

any:在任何可用的代理上执行流水线,配置语法:

pipeline { 
    agent any 
}

none:表示该 Pipeline 脚本没有全局的 agent 配置。当顶层的 agent 配置为 none 时,每个 stage 部分都需要包含它自己的 agent。配置语法:

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 写法如下:

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

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

agent{ 
    docker{ 
        image '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 
""" 
   }

2、配置示例

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

Jenkinsfile (Declarative Pipeline) // 可以不要此行 
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 如下:

Jenkinsfile (Declarative 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 
 		 """ 
        } 
      } 
    } 
  } 
}

3、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 部分放在流水线的底部,比如本实例,无论 stage 的完成状态如何,都会输出一条 I will always say Hello again!信息:

Jenkinsfile (Declarative Pipeline) // 可以不写该行 
pipeline { 
    agent any 
    stages { 
        stage('Example') { 
            steps { 
                echo 'Hello World' 
            } 
        } 
    } 
    post {  
        always {  
            echo 'I will always say Hello again!' 
        } 
    } 
}

也可以将 post 写在 stage:

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

4、Stages

Steps 部分在给定的 stage 指令中执行的一个或多个步骤,比如在 steps 定义执行一条 shell 命令:

Jenkinsfile (Declarative Pipeline) 
pipeline { 
    agent any 
    stages { 
        stage('Example') { 
            steps {  
                echo 'Hello World' 
            } 
        } 
    } 
}

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

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

2、Directives

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

1、Environment

Environment 主要用于在流水线中配置的一些环境变量,根据配置的位置决定环境变量的作用域。可以定义在 pipeline 中作为全局变量,也可以配置在 stage 中作为该 stage 的环境变量。 该指令支持一个特殊的方法 credentials(),该方法可用于在 Jenkins 环境中通过标识符访问预定义的凭证。对于类型为 Secret Text 的凭证,credentials()可以将该 Secret 中的文本内容赋值给环境变量。对于类型为标准的账号密码型的凭证,指定的环境变量为 username 和 password,并且也会定义两个额外的环境变量,分别为 MYVARNAME_USR 和 MYVARNAME_PSW。 假如需要定义个变量名为 CC 的全局变量和一个名为 AN_ACCESS_KEY 的局部变量,并且用 credentials 读取一个 Secret 文本,可以通过以下方式定义:

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

2、Options

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

buildDiscarder : 保 留 多 少 个 流 水 线 的 构 建 记 录 。 比 如 : options { buildDiscarder(logRotator(numToKeepStr: '1')) };

disableConcurrentBuilds:禁止流水线并行执行,防止并行流水线同时访问共享资源导致流水线失败。比如:options { disableConcurrentBuilds() };

disableResume : 如 果 控 制 器 重 启 , 禁 止 流 水 线 自 动 恢 复 。 比 如 : options { disableResume() };

newContainerPerStage:agent 为 docker 或 dockerfile 时,每个阶段将在同一个节点的新 容 器 中 运 行 , 而 不 是 所 有 的 阶 段 都 在 同 一 个 容 器 中 运 行 。 比 如 : options { newContainerPerStage () };

quietPeriod:流水线静默期,也就是触发流水线后等待一会在执行。比如:options { quietPeriod(30) };

retry:流水线失败后重试次数。比如:options { retry(3) };

timeout:设置流水线的超时时间,超过流水线时间,job 会自动终止。比如:options { timeout(time: 1, unit: 'HOURS') };

timestamps:为控制台输出时间戳。比如:options { timestamps() }。

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

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

Option 除了写在 Pipeline 顶层,还可以写在 stage 中,但是写在 stage 中的 option 仅支持 retry、timeout、timestamps,或者是和 stage 相关的声明式选项,比如 skipDefaultCheckout。处于 stage级别的 options 写法如下:

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

3、Parameters

Parameters 提供了一个用户在触发流水线时应该提供的参数列表,这些用户指定参数的值可以通过 params 对象提供给流水线的 step(步骤)。 目前支持的参数类型如下:

string:字符串类型的参数,例如:parameters { string(name: 'DEPLOY_ENV', defaultValue: 'staging', description: '') },表示定义一个名为 DEPLOY_ENV 的字符型变量,默认值为staging;

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

booleanParam:布尔型参数,例如: parameters { booleanParam(name: 'DEBUG_BUILD', defaultValue: true, description: '') };

choice:选择型参数,一般用于给定几个可选的值,然后选择其中一个进行赋值,例如:parameters { choice(name: 'CHOICES', choices: ['one', 'two', 'three'], description: '') },表示定义一个名为 CHOICES 的变量,可选的值为 one、two、three;

password:密码型变量,一般用于定义敏感型变量,在 Jenkins 控制台会输出为*。例如:parameters { password(name: 'PASSWORD', defaultValue: 'SECRET', description: 'A secret password') },表示定义一个名为 PASSWORD 的变量,其默认值为 SECRET。

Parameters 用法如下:

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}" 
            } 
        }
    } 
}

4、Triggers

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

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

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

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

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

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

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 等。

5、Input

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

配置 Input 支持以下选项:

message:必选,需要用户进行 input 的提示信息,比如:“是否发布到生产环境?”;

id:可选,input 的标识符,默认为 stage 的名称;

ok:可选,确认按钮的显示信息,比如:“确定”、“允许”;

submitter:可选,允许提交 input 操作的用户或组的名称,如果为空,任何登录用户均可提交 input;

parameters:提供一个参数列表供 input 使用。

假如需要配置一个提示消息为“还继续么”、确认按钮为“继续”、提供一个 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." 
            } 
        } 
    } 
}

6、When

When 指令允许流水线根据给定的条件决定是否应该执行该 stage,when 指令必须包含至少一个条件。如果 when 包含多个条件,所有的子条件必须都返回 True,stage 才能执行。

When 也可以结合 not、allOf、anyOf 语法达到更灵活的条件匹配。

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

branch:当正在构建的分支与给定的分支匹配时,执行这个 stage,例如:when { branch 'master' }。注意,branch 只适用于多分支流水线;

changelog : 匹 配 提 交 的 changeLog 决 定 是 否 构 建 , 例 如 : when { changelog '.*^\[DEPENDENCY\] .+$' };

environment:当指定的环境变量和给定的变量匹配时,执行这个 stage,例如:when { environment name: 'DEPLOY_TO', value: 'production' };

equals:当期望值和实际值相同时,执行这个 stage,例如:when { equals expected: 2, actual: currentBuild.number };

expression:当指定的 Groovy 表达式评估为 True,执行这个 stage,例如:when { expression { return params.DEBUG_BUILD } };

tag:如果 TAG_NAME 的值和给定的条件匹配,执行这个 stage,例如:when { tag "release-*" };

not:当嵌套条件出现错误时,执行这个 stage,必须包含一个条件,例如:when { not { branch 'master' } };

allOf:当所有的嵌套条件都正确时,执行这个 stage,必须包含至少一个条件,例如:when { allOf { branch 'master'; environment name: 'DEPLOY_TO', value: 'production' } };

anyOf:当至少有一个嵌套条件为 True 时,执行这个 stage,例如:when { anyOf { branch 'master'; branch 'staging' } }。

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

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

也可以同时配置多个条件,比如分支是 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' 
            } 
        } 
    } 
}

也可以使用 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' 
            } 
        } 
    } 
}

也可以使用 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}" 
            } 
        } 
    } 
}

3、Parallel

在声明式流水线中可以使用 Parallel 字段,即可很方便的实现并发构建,比如对分支 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('Nested 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('Nested 2') { 
                            steps { 
                                echo "In stage Nested 2 within Branch C" 
                            } 
                        } 
                    } 
                } 
            } 
        } 
    } 
}
0

评论区