• Jenkins--基础--6.2--Pipeline--语法--声明式

    Jenkins–基础–6.2–Pipeline–语法–声明式

    1、介绍

    1.1、特点

    1. 所有有效的声明式流水线必须包含在一个pipeline块中
    pipeline {
    /* insert Declarative Pipeline here */
}
作用域：应用于全局最外层，表明该脚本为声明式pipeline
是否必须：必须
参数：无

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    1. Pipeline 的顶层必须是一个块
      pipeline { }。
    2. 没有分号作为语句分隔符。 每个语句都必须在它自己的行上。
    3. 块只能由章节(Sections)、指令(Directives)、步骤(Steps)或赋值语(assignment statements)句组成。
    4. 属性引用语句被视为无参数方法调用。 例如，input被视为input()。
    5. Jenkins还提供了声明式指令片段生成器来帮助生成声明式流水线指令。

    1.2、Jenkinsfile一般结构如下

    pipeline {
  agent {
    //define agent
  }
  stages {
    stage('阶段名称') {
      steps {
        //some scripts
      }
    }
    ...
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    2、agent(require)

    1. agent声明整个pipeline脚本或某个stage脚本在jenkins中的运行环境
      1. 写在pipeline最外层：声明整个pipeline的运行环境
      2. 写在stage里：声明stage的运行环境。
      3. pipeline的最外层必须声明agent， 而在stage里则是可选项。
    2. 作用域：可用在全局与stage内
    3. 是否必须：是
    4. 参数
      1. any
      2. none
      3. label
      4. node
      5. docker
      6. dockerfile
      7. kubernetes

    2.1、any

    运行在任意的可用节点上。

    pipeline {
	//运行在任意的可用节点上
	agent any
	stages {
		stage('阶段名称：拉取代码') {
			steps("步骤名称：拉取代码"){ 
				echo '打印：拉取代码' 
			}
		}
		stage('阶段名称：编译构建') {
			steps { 
				echo '打印：编译构建' 
			}
		}
		stage('阶段名称：项目部署') {
			steps { 
				echo '打印：项目部署' 
			}
		}
	}
    post{
        always{
            echo "阶段完成后动作"
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    2.2、none

    当在全局声明agent为none时，那么每一个stage都需声明自己的agent。

    2.3、label

    运行在 指定标签名称节点上

    agent {
  //运行在 标签名称为my-node1的节点上
  label 'my-node1'
}


    • 1
    • 2
    • 3
    • 4
    • 5

    除此之外label还可以与逻辑符号一同使用

    agent {
  label 'my-node1' && 'my-node2'
}
agent {
  //运行在 标签名称为 my-node1或者my-node2 的节点上
  label 'my-node1' || 'my-node2'
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    2.4、node

    node声明运行节点，与label功能类似，但是node可以附加选项参数， 如customWorkspace

    agent {
  node {
      label 'my-node1'
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5

    等同于

    agent {
  label 'my-node1'
}

    • 1
    • 2
    • 3

    2.4.1、node附加选项参数

    agent {
  node {
      label 'my-node1'
	  // 附加选项参数
      customWorkspace '/some/other/path'
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    2.5、docker

    1. 用于基于docker的pipeline流水线
    2. 在预配置的节点上或指定label的节点上创建docker容器。
    3. 可以接收docker run的参数，以及docker registry等参数。
    agent {
  docker 'maven:3.8.1-adoptopenjdk-11'
}


    • 1
    • 2
    • 3
    • 4
    agent {
  docker {
      image 'maven:3.8.1-adoptopenjdk-11'
      label 'my-defined-label'
      args  '-v /tmp:/tmp'
      registryUrl 'https://myregistry.com/'
      registryCredentialsId 'myPredefinedCredentialsInJenkins'
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    2.6、dockerfile

    1. 从一个Dockerfile创建docker容器来运行pipeline流水线。
    2. 默认会从构建的根目录寻找Dockerfile

    2.6.1、案例

    agent { 
  dockerfile true 
}

    • 1
    • 2
    • 3

    2.6.2、案例

    agent {
    // Equivalent to "docker build -f my_dockerfile --build-arg version=1.0.2 ./build_dir/
    dockerfile {
        filename 'my_dockerfile'
        dir 'build_dir'
        label 'my-defined-label'
        additionalBuildArgs  '--build-arg version=1.0.2'
        args '-v /tmp:/tmp'
        registryUrl 'https://myregistry.com/'
        registryCredentialsId 'myPredefinedCredentialsInJenkins'
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    1. 通过dir参数：声明 Dockerfile存放的子目录
    2. 通过filename参数：声明 Dockerfile名字
    3. 通过additionalBuildArgs参数：设置docker build参数
    4. 通过registryUrl参数：设置docker仓库
    5. 通过registryCredentialsId参数：从jenkins获取docker仓库的账号密码。

    2.7、kubernetes

    1. 在kubernetes集群中的一个pod内执行pipeline流水线
    2. pod模版将定义在kubernetes{}模块中。
    agent {
    kubernetes {
        label podlabel
        yaml """
			kind: Pod
			metadata:
			  name: jenkins-agent
			spec:
			  containers:
			  - name: nginx
				image: nginx
		"""
   }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    2.8、agent的选项参数

    2.8.1、label

    1. 字符串类型。
    2. 此参数适用于
      1. node：在ndoe中是必输参数。
      2. docker
      3. dockerfile

    2.8.2、customWorkspace

    1. 字符串类型。
    2. 在自定义工作空间目录中运行此pipeline流水线而不是使用默认的。
    3. 可以是相对路径(相对于运行节点工作空间的根目录)
    4. 可以是绝对路径。
    5. 此参数适用于
      1. node
      2. docker
      3. dockerfile。

    ####示例

    agent {
    node {
        label 'my-node1'
        customWorkspace '/some/other/path'
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    2.8.3、reuseNode

    1. 布尔值类型
    2. 值
      1. false(默认)
      2. true
        1. 在pipeline的全局agent节点中运行容器，并且是在同一个工作空间中运行而不是在一个全新的节点中运行。
    3. 此参数适用于
      1. docker
      2. dockerfile
    4. 只在stage代理中有效。

    2.8.4、args

    1. 字符串类型。
    2. 用于设置docker run参数
    3. 适用于
      1. docker
      2. dockerfile

    ####示例

    agent {
    // Equivalent to "docker build -f my_dockerfile --build-arg version=1.0.2 ./build_dir/
    dockerfile {
        filename 'my_dockerfile'
        dir 'build_dir'
        label 'my-defined-label'
        additionalBuildArgs  '--build-arg version=1.0.2'
        args '-v /tmp:/tmp'
        registryUrl 'https://myregistry.com/'
        registryCredentialsId 'myPredefinedCredentialsInJenkins'
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    3、post

    1. 定义附加steps在整个pipeline流水线或某个stage执行完之后运行。
    2. post可以定义在pipeline的最外层，表示这个pipeline执行完之后运行
    3. post可以定义在某个stage里，表示该stage执行完后运行。

    3.1、post的执行条件场景

    3.1.1、always

    不管pipeline或stage的执行结果状态，总会执行的steps。

    3.1.2、changed

    只有在pipeline或stage的执行结果状态与前一次执行相比发生改变时执行。

    3.1.3、fixed

    当前pipeline或stage执行成功且它的前一次执行结果是failure或unstable时执行。

    3.1.4、regression

    当前pipeline或stage执行结果是failure，unstable或aborted且它的前一次执行成功时执行。

    3.1.5、aborted

    当前pipeline或stage执行结果是aborted(人工停止pipeline)时执行。

    3.1.6、failure

    当前pipeline或stage执行结果是失败时执行。

    3.1.7、success

    当前pipeline或stage执行结果是成功时执行。

    3.1.8、unstable

    当前pipeline或stage执行结果是unstable时执行。

    3.1.9、unsuccessful

    当前pipeline或stage执行结果不是成功时执行。

    3.1.10、cleanup

    在其他所有的post场景脚本都处理完之后执行，不管当前pipeline或stage执行结果是什么。

    3.2、案例

    pipeline {
	agent any
	stages {
		stage('阶段名称：拉取代码') {
			steps("步骤名称：拉取代码"){ 
				echo '打印：拉取代码' 
			}
		}
		stage('阶段名称：编译构建') {
			steps { 
				echo '打印：编译构建' 
			}
		}
		stage('阶段名称：项目部署') {
			steps { 
				echo '打印：项目部署' 
			}
		}
	}
    post{
        always{
            echo "阶段完成后动作"
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    在这里插入图片描述

    在这里插入图片描述

    4、stages(require)

    1. 表示：阶段集合
    2. 包裹所有的阶段(例如：打包，部署等各个阶段)
    3. 一个stages可以有多个stage
    4. 作用域：全局或者stage阶段内，每个作用域内只能使用一次
    5. 是否必须：全局必须
    6. 参数：无

    4.1、案例

    pipeline{
    agent any
    stages{
        stage("阶段1"){
            stages{  //嵌套在stage里
                stage("阶段1的内部阶段"){
                    steps{
                        echo "阶段1的内部阶段"
                    }
                }
            }
        }
        stage("阶段2"){
            steps{
                echo "阶段2"
            }
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    在这里插入图片描述
    在这里插入图片描述

    看下运行结果，发现嵌套的stage也是能够展现在视图里面的

    5、stage(atlest one)

    1. 表示：阶段
    2. 定义构建阶段要做的事情
    3. 每个pipeline流水线至少包含一个stage。
    4. 一个stage里有且只有一个steps,stages,parallel, 或matrix。
    5. 当一个stage内嵌在parallel或matrix中的时候，那么该stage就不能再包含parallel或matrix。
    6. 作用域：被stages包裹，作用在自己的stage包裹范围内
    7. 是否必须：必须
    8. 参数：需要一个string参数，表示此阶段的工作内容
    9. 备注：stage内部可以嵌套stages，内部可单独制定运行的agent

    5.1、案例

    pipeline{
    agent any
    stages{
        stage("阶段1"){
            stages{  //嵌套在stage里
                stage("阶段1的内部阶段"){
                    steps{
                        echo "阶段1的内部阶段"
                    }
                }
            }
        }
        stage("阶段2"){
            steps{
                echo "阶段2"
            }
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    在这里插入图片描述

    在这里插入图片描述

    看下运行结果，发现嵌套的stage也是能够展现在视图里面的

    6、steps(require)

    1. steps包含一个或多个可执行指令。
    2. 表示：步骤
    3. 是阶段的最小执行单元
    4. 作用域：被stage包裹，作用在stage内部
    5. 是否必须：必须
    6. 参数：无

    7、environment

    1. 声明一个全局变量(pipeline)或者步骤内部stage()的局部变量
    2. 该指令还支持通过credentials()获取预设的账号密码。

    7.1、支持的credential类型

    7.1.1、Secret Text

    该环境变量的值将会被设置为Secret Text的内容。

    7.1.2、Secret File

    该环境变量的值将会被设置为临时创建的文件路径。

    7.1.3、Username and password

    该环境变量的值将会被设置为username:password，并且还会自动创建两个环境变量

    1. MYVARNAME_USR
    2. MYVARNAME_PSW

    7.1.4、SSH with Private Key

    该环境变量的值将会被设置为临时创建的ssh key文件路径，并且还会自动创建两个环境变量

    1. MYVARNAME_USR
    2. MYVARNAME_PSW。

    7.2、案例

    7.2.1、案例1

    pipeline{
    agent any
	//声明一个全局变量或者步骤内部的局部变量
    environment {
        P1="参数1"
    }
    stages{
        stage("阶段1"){
            environment {
                P2="参数2"
            }
            steps{ 
                echo "打印P1变量：$P1"
                echo "打印P2变量：$P2"
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    在这里插入图片描述

    7.2.2、案例2

    pipeline {
    agent any
    environment { 
        CC = 'clang'
    }
    stages {
        stage('Example') {
            environment { 
                AN_ACCESS_KEY = credentials('my-predefined-secret-text') 
            }
            steps {
                sh 'printenv'
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    pipeline {
    agent any
    stages {
        stage('Example Username/Password') {
            environment {
                SERVICE_CREDS = credentials('my-predefined-username-password')
            }
            steps {
                sh 'echo "Service user is $SERVICE_CREDS_USR"'
                sh 'echo "Service password is $SERVICE_CREDS_PSW"'
                sh 'curl -u $SERVICE_CREDS https://myservice.example.com'
            }
        }
        stage('Example SSH Username with private key') {
            environment {
                SSH_CREDS = credentials('my-predefined-ssh-creds')
            }
            steps {
                sh 'echo "SSH private key is located at $SSH_CREDS"'
                sh 'echo "SSH user is $SSH_CREDS_USR"'
                sh 'echo "SSH passphrase is $SSH_CREDS_PSW"'
            }
        }
    }
}
 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    8、options

    1. pipeline的选项参数，能够提供给脚本更多的选项。
    2. 全局options声明在最外层
    3. 当options作用在stage内部的时候，只在该stage有效，且只支持以下选项
      1. skipDefaultCheckout
      2. timeout
      3. retry
      4. timestamps

    8.1、buildDiscarder

    指定build history与console的保存数量。

    //只保存最近一次构建日志
options { 
  buildDiscarder(logRotator(numToKeepStr: '1')) 
}

    • 1
    • 2
    • 3
    • 4

    8.2、checkoutToSubdirectory

    将源码拉取到工作空间指定的子目录下。

    options { 
  checkoutToSubdirectory('foo') 
}

    • 1
    • 2
    • 3

    8.3、disableConcurrentBuilds

    不允许同时构建。

    
options { 
  disableConcurrentBuilds() 
}

    • 1
    • 2
    • 3
    • 4

    8.4、disableResume

    不允许控制器重新开始。

    options { 
  disableResume() 
}

    • 1
    • 2
    • 3

    8.5、newContainerPerStage

    与docker或dockerfile代理一起使用，表示每个stage都将在同一个节点里启动新容器运行而不是在同一个容器中运行。

    
options {
  newContainerPerStage()
}

    • 1
    • 2
    • 3
    • 4

    8.6、overrideIndexTriggers

    1. 重写分支索引触发器的处理方式。
    2. 如果设置为true：当分支索引触发器在多分支或机构标签中禁止时，他们将为当前构建开启
    3. 如果设置为false：当分支索引触发器在多分支或机构标签中开启时，他们将为当前构建禁止。
    options { 
  overrideIndexTriggers(true) 
} 

    • 1
    • 2
    • 3

    8.7、preserveStashes

    当stage重新开始时，保存最近构建。

    //保存最近一次完成的构建
options { 
  preserveStashes() 
}

    • 1
    • 2
    • 3
    • 4
    //保存最近5次完成的构建
options { 
  preserveStashes(buildCount: 5) 
}

    • 1
    • 2
    • 3
    • 4

    8.8、quietPeriod

    1. 延迟启动时间
    2. 单位：秒。
    
options { 
  quietPeriod(30) 
}

    • 1
    • 2
    • 3
    • 4

    8.9、retry(stageable)

    失败重试次数。

    
options { 
  retry(3) 
}

    • 1
    • 2
    • 3
    • 4

    8.10、skipDefaultCheckout(stageable)

    跳过默认代码拉取。

    options { 
  skipDefaultCheckout() 
}

    • 1
    • 2
    • 3

    8.11、skipStagesAfterUnstable

    当构建状态出现unstable时跳过其他stages。

    
options { 
  skipStagesAfterUnstable() 
}

    • 1
    • 2
    • 3
    • 4

    8.12、timeout(stageable)

    设置构建超时时间，超时后自动终止执行。

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    8.13、timestamps(stageable)

    设置日志输出时间戳。

    options { 
  timestamps() 
}

    • 1
    • 2
    • 3

    8.14、parallelsAlwaysFailFast

    将所有并行stage的failfast设置为true。

    
options { 
  parallelsAlwaysFailFast() 
}

    • 1
    • 2
    • 3
    • 4

    8.15、案例

    

pipeline{
    agent any
    options {
	   //设置日志输出时间戳
       timestamps() 
	   //不允许同时构建
       disableConcurrentBuilds()
        
    }
    stages{
        
        stage("stage1"){
            options { 
				//设置构建超时时间，超过1分钟后自动终止执行
				timeout(time:1,unit:'MINUTES') 
				//设置retry作用域范围的重试次数为3次
                retry(2)
            }
            steps{
                echo "====================options测试===================="
            }
        }   
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    在这里插入图片描述

    9、parameters

    1. parameters声明当构建触发时用户要输入的所有参数，steps指令将通过params对象获取这些参数。
    2. 提供pipeline运行的参数
    3. 作用域：被最外层pipeline所包裹，并且只能出现一次，参数可被全局使用

    9.1、参数类型包括

    string
text
booleanParam
choice
password

    • 1
    • 2
    • 3
    • 4
    • 5

    9.2、案例

    9.2.1、案例1

    pipeline{
    agent any
	//提供pipeline运行的参数
    parameters {
		//定义字符串参数，名称：P1，默认值：hello world，参数说明：打个招呼
        string(name: 'P1', defaultValue: 'hello world', description: '打个招呼')
        booleanParam(name: 'P2', defaultValue: true, description: 'P2')
    }
    stages{
        stage("stage1"){
            steps{
                echo "打印参数P1：$P1"
                echo "打印参数P2：$P2"
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    ####自动生成的构建参数

    在这里插入图片描述

    在这里插入图片描述

    9.2.2、案例2

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


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    在这里插入图片描述

    10、triggers

    1. 构建触发器，在符合条件下自动触发pipeline
    2. 不常用，一般使用webhooks居多。
    3. 作用域：被pipeline包裹
    4. 自动触发的方式有3种
      1. cron
      2. pollSCM
      3. upstream

    10.1、cron

    定时器触发。

    
//每隔4小时构建一次
triggers { 
  cron('H */4 * * 1-5') 
}

    • 1
    • 2
    • 3
    • 4
    • 5

    10.2、pollSCM

    定时检查源码变更触发。jenkins定时检查源码是否变更，如果发生变更则触发构建。

    //每隔4小时检查一次
triggers { 
  pollSCM('H */4 * * 1-5') 
}

    • 1
    • 2
    • 3
    • 4

    10.3、upstream

    1. 上游构建触发。
    2. 当上游构建完成状态匹配时触发构建。
    
triggers { 
  upstream(upstreamProjects: 'job1,job2', threshold: hudson.model.Result.SUCCESS) 
}

    • 1
    • 2
    • 3
    • 4
    pipeline{
    agent any
    //说明：当上游Job，test_8或者test_7 运行成功的时候，自动触发
    triggers { upstream(upstreamProjects: 'test_8,test_7', threshold: hudson.model.Result.SUCCESS) }
    stages{
        stage("stage1"){
            steps{
                echo "hello"
            }
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    11、tools

    1. 声明需要自动安装构建所需的工具，并设置到PATH环境变量里。
    2. 当agent none时，tools声明将会被忽略。
    3. 支持自动安装的工具有
      1. jdk
      2. maven
      3. gradle

    11.1、引用的工具需要配置过，比如我的maven

    系统管理–>全局工具配置
    在这里插入图片描述

    11.2、案例

    pipeline {
    agent any
    tools {
		//引用的工具,通过名称引用
        maven 'maven-3.3.9' 
    }
    stages {
        stage('阶段1') {
            steps {
                sh 'mvn --version'
            }
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    结果
    在这里插入图片描述

    12、input (stage only)

    1. stage参数输入指令。
    2. 在进入agent模块和when条件判断之前，stage将会被暂停并弹出输入对话框，直到用户输入可用参数后stage才会继续执行。
    3. 所有输入的参数在余下的stage指令中都可以通过环境变量获取。

    12.1、input配置选项

    12.1.1、messgae(必输)

    提示信息

    12.1.2、id

    1. 唯一标识
    2. 默认使用该stage名称。

    12.1.3、ok

    按钮名称。

    12.1.4、submitter

    1. 以","分割的用户或外部组的列表，定义谁可以提交这个输入项
    2. 默认所有人。

    12.1.5、submitterParameter

    设置submitter的环境变量名称。

    12.1.6、parameters

    配置需要输入的参数。

    12.2、案例

    pipeline {
    agent any
    stages {
        stage('阶段1') {
		    //暂时中断pipeline执行，等待用户登录，完成打卡
            input {
                message "你好，请输入登录用户"
                ok "确认"
                submitter "alice,bob"
				//提供pipeline运行的参数
                parameters {
                    string(name: 'PERSON', defaultValue: '张三', description: '请输入公司账号')
                }
            }
            steps {
                echo "你好, ${PERSON}, 打卡成功"
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    效果

    在这里插入图片描述

    在这里插入图片描述

    13、when (stage only)

    1. 通过设定的条件判断决定pipeline流水线的当前stage是否执行
    2. when命令至少包含一个条件判断。
    3. 如果when包含多个条件判断，那么当且仅当所有条件判断都为true时，当前stage才会被执行。
    4. 正常情况下when判断时在agent，input，options命令之后才执行的，但是可以通过beforeAgent，beforeInput，beforeOptions参数来设置提前执行。
    5. 注意：如果我们想要在进入agent之前进行判断，需要将beforeAgent设置为true

    案例

    pipeline {
    agent none
    stages {
        stage('阶段1') {
            steps {
                echo 'Hello World'
            }
        }
        stage('阶段2') {
            agent {
				//定义标签
                label "la-app"
            }
            when {
				//设置先对条件进行判断，符合预期才进入steps
                beforeAgent true
                branch 'prod'
            }
            steps {
                echo '部署'
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    13.1、branch

    1. 只使用于多分支结构流水线。
    2. 当构建分支匹配给定的分支或正则表达式时为true，当前stage就执行下去。

    13.1.1、匹配规则

    1. EQUALS：字符串比较。
    2. GLOB：ANT通配符
    3. REGEXP：正则表达式

    13.1.2、案例

    when { 
	branch 'master' 
}

    • 1
    • 2
    • 3
    when { 
	branch pattern: "release-\\d+", comparator: "REGEXP"
}

    • 1
    • 2
    • 3

    13.2、buildingTag

    当构建一个版本标签时为true。

    when { 
	buildingTag() 
}

    • 1
    • 2
    • 3

    13.3、changelog

    当SCM的变更日志匹配给定的正则表达式时为true。

    when { 
	changelog '.*^\\[DEPENDENCY\\] .+$' 
}

    • 1
    • 2
    • 3

    13.4、changeset

    当SCM变更集包含一个或以上文件匹配给定的文件路径表达式时为true。

    13.4.1、匹配规则

    1. EQUALS：字符串比较。
    2. GLOB：ANT通配符
    3. REGEXP：正则表达式

    13.4.2、案例

    when { 
  	changeset "**/*.js" 
}

    • 1
    • 2
    • 3
    when { 
  	changeset pattern: ".TEST\\.java", comparator: "REGEXP" 
} 

    • 1
    • 2
    • 3

    通过caseSensitive参数设置是否区分大小写。

    when { 
  	changeset pattern: "*/*TEST.java", caseSensitive: true 
}

    • 1
    • 2
    • 3

    13.5、changeRequest

    1. 当因SCM发生变更请求(aka，GitHub and Bitbucket：Pull Request，GitLab：Merge Request， Gerrit： Change Request)而构建时为true。
    2. 可添加过滤属性，来筛选符合条件的变更请求
      id
      target
      branch
      fork
      url
      title
      author
      authorDisplayName
      authorEmail

    13.5.1、过滤属性匹配规则

    1. EQUALS：字符串比较。
    2. GLOB：ANT通配符
    3. REGEXP：正则表达式

    13.5.2、案例

     when { 
   	changeRequest() 
 }

    • 1
    • 2
    • 3
    when { 
  	changeRequest target: 'master' 
}

    • 1
    • 2
    • 3
    when { 
  	changeRequest authorEmail: "[\\w_-.]+@example.com", comparator: 'REGEXP' 
}

    • 1
    • 2
    • 3

    13.6、environment

    当某个环境变量值等于给定值时为true。

    13.6.1、案例

    hen { 
  	environment name: 'DEPLOY_TO', value: 'production' 
}

    • 1
    • 2
    • 3

    13.7、equals

    当实际值等于期望值时为true。

    13.7.1、案例

    when { 
  	equals expected: 2, actual: currentBuild.number 
}

    • 1
    • 2
    • 3

    13.8、expression

    1. 当给定的groovy表达式返回值为true。
    2. 如果返回值是字符串，那么当返回为null时为false，其他字符串都表示为true。

    13.8.1、案例

    when { 
  expression { 
    return params.DEBUG_BUILD 
  } 
}

    • 1
    • 2
    • 3
    • 4
    • 5

    13.9、tag

    1. 当TAG_NAME环境变量匹配给定正则表达式时为true。
    2. 如果表达式为空则只要TAG_NAME环境变量存在则为true。

    13.9.1、匹配规则

    1. EQUALS：字符串比较。
    2. GLOB：ANT通配符
    3. REGEXP：正则表达式

    13.9.2、案例

    when { 
  tag "release-*" 
}

    • 1
    • 2
    • 3
    when { 
  tag pattern: "release-\\d+", comparator: "REGEXP"
}

    • 1
    • 2
    • 3

    13.10、not

    当条件为false时。

    13.10.1、案例

    when { 
  not { 
    branch 'master' 
  } 
}

    • 1
    • 2
    • 3
    • 4
    • 5

    13.11、allOf

    当所有条件都为true时。

    13.11.1、案例

    when { 
  allOf { 
    branch 'master'; 
    environment name: 'DEPLOY_TO', value: 'production' 
  } 
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    13.12、anyOf

    判断是否有一个条件为真。

    13.12.1、案例

    when { 
  anyOf { 
    branch 'master'; branch 'staging' 
  } 
}

    • 1
    • 2
    • 3
    • 4
    • 5

    13.13、triggeredBy

    当构建由给定触发时为true。

    13.1.1、案例

    when { triggeredBy 'SCMTrigger' }
when { triggeredBy 'TimerTrigger' }
when { triggeredBy 'UpstreamCause' }
when { triggeredBy cause: "UserIdCause", detail: "vlinde" }

    • 1
    • 2
    • 3
    • 4

    14、parallel

    1. 通过将阶段设置为parallel来表明该stage为并行运行。
    2. 通过在包含parallel的stage里设置failFast true，当其中一个并行stage执行失败时强制终止其他并行stage。
    3. 可以在options里做全局设置parallelsAlwaysFailFast()。
    4. 1个stage只能有1个steps或者parallel
    5. 嵌套的stages里不能使用parallel
    6. parallel不能包含agent或者tools

    14.1、案例1

    pipeline {
    agent any
    stages {
        stage('非并行阶段') {
            steps {
                echo '非并行阶段'
            }
        }
        stage('并行阶段') {
            failFast true
            parallel {
                stage('并行阶段1') {
                    steps {
                        echo "并行阶段1"
                    }
                }
                stage('并行阶段2') {
                    steps {
                        echo "并行阶段2"
                    }
                }
            }
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    在这里插入图片描述

    在这里插入图片描述

    15、matrix

    1. 按name-value定义的命名空间矩阵，可在stage里使用定义并行任务。
    2. matrix必需包含一个axes和一个stages。
    3. failFast和parallelsAlwaysFailFast()也使用于matrix。

    15.1、axes

    每一个axes必需包含一个或以上axis

    15.2、axis

    1. 每个axis包含一个name和一个values列表
    2. 所有axies中的values列表彼此组合产生命名空间cell。
    3. stages将按循序在各个cell中被执行。
    4. 每个命名空间的name-value键值对将自动创建对应的环境变量。

    15.3、excludes

    1. 按命name-value名空间移除不需要执行的cell。
    2. 当移除的命名空间cell列表很长时可以使用notValues替代values。

    15.4、每个cell中仍然可以使用以下这些命令, 在matrix最外层声明：

    agent
environment
input
options
post
tools
when


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    15.4、案例

    pipeline {
    parameters {
        choice(name: '操作系统', choices: ['all', 'linux', 'windows'], description: '请选择操作系统')
    }
    agent any
    stages {
        stage('构建和测试') {
            matrix {
                when { 
					anyOf {
						expression { params.操作系统 == 'all' }
						expression { params.操作系统 == env.PLATFORM }
					} 
				}
                axes {
                    axis {
                        name 'PLATFORM'
                        values 'linux', 'windows'
                    }
                    axis {
                        name 'BROWSER'
                        values '火狐浏览器', '谷歌浏览器', '苹果浏览器', '微软浏览器'
                    }
                }
                excludes {
                    exclude {
                        axis {
                            name 'PLATFORM'
                            values 'linux'
                        }
                        axis {
                            name 'BROWSER'
                            values '苹果浏览器'
                        }
                    }
                    exclude {
                        axis {
                            name 'PLATFORM'
                            notValues 'windows'
                        }
                        axis {
                            name 'BROWSER'
                            values '微软浏览器'
                        }
                    }
                }
                stages {
                    stage('构建') {
                        steps {
                            echo "Do Build for ${PLATFORM} - ${BROWSER}"
                        }
                    }
                    stage('测试') {
                        steps {
                            echo "Do Test for ${PLATFORM} - ${BROWSER}"
                        }
                    }
                }
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    16、脚本

    pipeline提供了一个脚本环境入口：script{},通过使用script来包裹脚本语句，即可使用脚本语法

    16.1、条件判断

    pipeline {
    agent any
    stages {
        stage('阶段1') {
            steps {
				//使用脚本
                script{
                    if ( "1" =="1" ) {
                        echo "1 ==1"
                    }else {
                        echo "1 !=1"
                    }
                }
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    在这里插入图片描述

    16.2、异常处理

    pipeline {
    agent any
    stages {
        stage('阶段1') {
            steps {
                script{
                    try {
                        sh 'exit 1'
                    }
                    catch (exc) {
                        echo '执行失败'
                        
                    }
                }
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    在这里插入图片描述

  • 相关阅读:
    MyBatisPlus-AUTO策略及INPUT策略
    从模型到部署，教你如何用Python构建机器学习API服务
    sstream及按格式字符分割字符串
    区块链技术的应用场景和优势
    微信小程序云开发 微信支付功能 逻辑+踩坑
    Java模板方法模式源码剖析及使用场景
    深兰科技荣获2024年度金势奖“AI出海先锋品牌”金奖
    【Python】学习导论：Python 简介
    史上最全的Redis基础+进阶项目实战总结笔记
    R-Car H3系列SOC芯片与R-Car M3 R8A77961JBP0BA区别
  • 原文地址：https://blog.csdn.net/zhou920786312/article/details/125955651