Jenkins-Pipeline基本使用

Jenkins-Pipeline

使用Groovy语法

Pipeline 是Jenkins 2.X核心特性，帮助Jenkins实现从CI到CD与DevOps的转变

Pipeline 简而言之，就是一套运行于Jenkins上的工作流框架，将原本独立
运行于单个或者多个节点的任务连接起来，实现单个任务难以完成的复杂流
程编排与可视化

支持语法：

1、声明式（仅在2.5版本后支持）

特点：

1.最外层必须由pipline{ //do something }来进行包裹

2.不需要分号作为分隔符，每个语句必须在一行内

3.不能直接使用groovy语句（例如循环判断等），需要被script {}包裹

2、脚本式

特点：

1.最外层使用node{}进行包裹

2.可直接使用groovy语句

声明式核心概念

基本流程：

1.pipeline :声明其内容为一个声明式的pipeline脚本，位于整个pipeline最外层，包裹整个pipeline

2.agent:执行节点（job运行的slave或者master节点），any表示任意节点

3.stages:阶段集合，包裹所有的阶段（例如：打包，部署等各个阶段）

4.stage:阶段，被stages包裹，一个stages可以有多个stage，每个stage表示pipeline中的一个流程

5.steps:步骤,为每个阶段的最小执行单元,被stage包裹**（必须项，即stage下必须存在steps）**

6.post:执行构建后的操作，根据构建结果来执行对应的操作

步骤拆分：

1、pipeline （声明式头头，最高）

作用域：应用于全局最外层，表明该脚本为声明式pipeline

是否必须：必须

参数：无

2、agent（规定谁来执行，以什么方式执行）

作用域：可用在全局与stage内

是否必须：是，

参数：any,none, label, node,docker,dockerfile

any

​ 代表任意节点均可执行，pipeline下的agent参数为必须项

pipeline{
    agent any  
    stages {
        stage('First'){
            steps {
                echo "test"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10

none

​ 当参数为none时，每个stage必须表明执行该步骤的agent

pipeline{
    agent none  
    stages {
        stage('First'){
            agent any
            steps {
                echo "test"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

label

​ 当参数为label时，label后的标签表示运行在指定机器上，label值由Jenkins配置进行控制（节点列表–管理节点）

pipeline{
    agent {
        label 'test01'
    }  
    // agent {
    //     node {
    //         label 'test01'
    //         customWorkspace 'xxx'   // 工作路径
    //     }
    // }  // 该写法与上面完全一致，多了更多的参数选项
    stages {
        stage('First'){
            steps {
                echo "test"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

docker

​ 当agent为docker时，当Pipeline执行时，Jenkins将自动启动指定的容器并在中

执行预定义的步骤，步骤执行完成后pipeline会自动删除对应的容器。

​ 并且docker参数可使用args来为容器启动传入变量等

pipeline {
    agent none
    stages {
        stage('Back-end') { // 该步骤将使用maven:3.8.1-adoptopenjdk-11容器执行下方steps
            agent {
                docker { image 'maven:3.8.1-adoptopenjdk-11' }
            }
            steps {
                sh 'mvn --version'
            }
        }
        stage('Front-end') {
            agent {
                docker { 
                    image 'node:16.13.1-alpine' 
                    args  '-e TEST=123'  // 等同于docker run -e TEST=123
                    reuseNode true  // 可能为不会删除临时容器，并在同一节点启动该容器。
                }
            }
            steps {
                sh 'node --version'
            }
        }
    }
}
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

dockerfile

​ 使用一个Dockerfile创建一个docker容器用于运行流水线，默认为：

agent { 
  dockerfile true 
}
1
2
3

如果项目的Dockerfile存放在子目录下需通过dir参数声明，如果Dockerfile名字

是其他自定义名则需通过filename参数声明，除此之外还可以通过

additionalBuildArgs来设置docker build参数，使用registryUrl来设置docker仓库，

使用registryCredentialsId从jenkins获取docker仓库的账号密码。

agent {
    // Equivalent to "docker build -f Dockerfile.build --build-arg version=1.0.2 ./build/
    dockerfile {
        filename 'Dockerfile.build'
        dir 'build'
        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

kubernetes

在kubernetes集群中的一个pod内执行pipeline流水线，pod模版将定义在

kubernetes{}模块中。如果需要在pod中安装kaniko则可在yaml参数中声明。

3、stages（声明接下来要正式开始pipeline了！）

pipeline中作为集合声明存在，告诉你下面要按照stage的配置执行步骤了。内含一个或多个stage

4、stage（步骤）

构建阶段模块。定义构建阶段要做的事情，每个pipeline流水线至少包含一个stage。一个stage里有且只有一个step

5、steps（具体要干啥）

一个steps中可包含一个或多个命令

通常情况下，直接使用命令即可：

stages {
	stage('Test') {
		steps {
			echo "test"
		}
	}
}
1
2
3
4
5
6
7

若要使用Groovy语法进行脚本式pipeline的编写，则必须使用script进行包裹：

stages {
    stage('Test') {
        steps {
            script {
                sh "echo 'test'"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9

6、environment （设置能够被调用的环境变量）

​ 指定一个 键-值对序列，该序列将被定义为所有步骤的环境变量，或者是特定于阶段的步骤， 这取决于environment 指令在流水线内的位置

顶层流水线块中使用的 environment 指令将适用于流水线中的所有步骤

pipeline {
    agent any
    environment {  // 该变量在整个流水线中均可使用
        key1 = 'Test1'
    }
    stages {
        agent any
        stage('Test') {
            steps {
                echo key1
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

一个 具体的stage 中定义的 environment 指令只会将给定的环境变量应用于 stage 中的步骤

pipeline {
    agent any
    stages {
        agent any
        stage('Test') {
        	environment {
                key2 = 'Test2'
            }
            steps {
                echo key2
            }
        }
    }
}          
1
2
3
4
5
6
7
8
9
10
11
12
13
14

还支持通过credentials()获取预设的账号密码

支持的credential类型包括：

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

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

Username and password 该环境变量的值将会被设置为username:password, 并且还会自动创建两个环境变量：MYVARNAME_USR和MYVARNAME_PSW。

SSH with Private Key 该环境变量的值将会被设置为临时创建的ssh key文件路径，并且还会自动创建两个环境变量：MYVARNAME_USR和MYVARNAME_PSW。

7、options（配置参数）

分为两种：全局options（声明在最外层，作用于整个流水线）、局部options（声明在具体的stage里，只在该stage里生效）

局部options参数

skipDefaultCheckout 跳过从源代码控制中检出代码的默认情况

**timeout ** 设定pipeline执行超时时间，time表示具体值，unit表示时间单位

**retry ** 指定失败重试次数

**timestamps ** 日志里都会打印执行时间（需配合Timestamper插件）

stage('test') {
    options {
        skipDefaultCheckout()
    }
}
-------------------------------------------------------
stage('test') {
    options {
        timeout(time:'1',unit:'HOURS')  //超时时间一小时
    }
}
-------------------------------------------------------
stage('test') {
    options {
        retry(5)
    }
}
-------------------------------------------------------
stage('test') {
    options {
        timestamps()
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

全局options参数

buildDiscarder pipeline 保持构建的最大个数

disableConcurrentBuilds 不允许并行构建

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

quietPeriod pipeline延时启动时间

pipeline {
	agent any
    options {
        buildDiscarder(logRotator(numToKeepStr: '5'))
        // 保留最大构建数
    }
}
1
2
3
4
5
6
7

8、parameters（触发构建时的参数）

parameters声明当构建触发时用户要输入的所有参数，steps指令将通过params对象获取这些参数

// git仓库拉取，需要配合Git Parameter插件使用
parameters {
    gitParameter(branch: '', branchFilter: 'origin/(.*)', 
                 defaultValue: 'feature/4.1.1',                            description: '发布选项: 请选择GIT分支', 
                 name: 'git_branch', 
                 quickFilterEnabled: false, 
                 selectedValue: 'NONE', 
                 sortMode: 'NONE', 
                 tagFilter: '*', 
                 type: 'PT_BRANCH')
}
--------------------------------------------------------
// 复选框，需要搭配Extended Choice Parameter插件使用    
parameters {
    extendedChoice(name: 'project_names', 
                   type: 'PT_CHECKBOX', 
                   description: '请勾选所要发布的子模块', 
                   quoteValue: false, 
                   saveJSONParameterToFile: false,
                   value: 'backend-job',
                   visibleItemCount: 1,
                   multiSelectDelimiter: ',',  // 分隔符
                   defaultValue: 'backend-job')
}
-------------------------------------------------------
// 下拉框，默认即可使用    
parameters {
    choice(choices:['192.168.0.184'],
           description: '必选项: 选择发布节点',
           name:'SSH_IP')
}
--------------------------------------------------------
// 输入字符串类型参数，默认即可使用    
parameters {
    string(name:'SSH_USER',
           defaultValue: 'root', 
           description: '必选项: 输入远程用户')
}
--------------------------------------------------------
// 密码形式输入，不安全，默认即可使用    
parameters {
    password(name:'PASSWORD', 
             defaultValue:'Rx@12345678', 
             description: '必选项: 输入远程密码')
}
--------------------------------------------------------
// 以文本形式输入参数，默认即可使用 
parameters {
    text(name: 'TEXT', 
         defaultValue: 'TEXT TXT', 
         description: '请输入默认文本')
}
--------------------------------------------------------
// 以布尔值形式输入参数，默认即可使用 
parameters {
    booleanParam(name: 'TOGGLE', 
                 defaultValue: true, 
                 description: 'Toggle this value')
}
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

9、when & IF & for （流程控制）

when

when仅能在stage端配置，用于判断当前stage是否执行。when可包含一条或多条条件判断，多条判断时需全部为true才可继续（默认情况下）。正常情况下when判断时在agent，input，options命令之后才执行的，但是可以通过beforeAgent，beforeInput，beforeOptions参数来设置提前执行。

常用条件：

branch ： 当正在构建的分支与给出的分支模式匹配时执行阶段

**environment ：**当指定的环境变量设置为给定值时执行阶段

**allOf：**当所有嵌套条件都为真时，执行stage，必须至少包含一个条件

**anyOf：**当至少一个嵌套条件为真时执行舞台，必须至少包含一个条件

表达式 expression ，当表达式为true时继续执行

equals expected：字符串判断，当实际值等于期望值时为true。

// branch
stages {
    stage('Test') {
        when {
            branch pattern: "release-\\d+", comparator: "REGEXP"  // 当分支为release-***时，执行steps，REGEXP表示使用正则匹配
        }
        steps {
            echo "123"
        }
    }
}
---------------------------------------------------------
// environment
pipeline {
    agent any
    environment {
        TXT = 'Test'
    }
    stage {
        stages('测试') {
            when {
                environment name: 'TXT'
                value: 'Test'  // 当环境变量TXT等于Test时执行接下来的steps
            }
            steps {
                echo "测试。。。"
            } 
        }
    }
}
---------------------------------------------------------
// allOf
stage{
    stages('测试') {
        when {
            allOf {
                branch 'master'
            	environment name: 'TXT'
            	value: 'Test'    
                // 只有当分支为master且变量TXT=Test都满足时才执行
            } 
        }
        steps {
            echo '测试......'
        }
    }
}
---------------------------------------------------------
// anyOf
stage{
    stages('测试') {
        when {
            anyOf {
                branch 'master'
            	environment name: 'TXT'
            	value: 'Test'    // 当分支为master或变量TXT=Test满足其中之一时就会执行
            }
        }
        steps {
            echo '测试......'
        }
    }
}
---------------------------------------------------------
// equals expected
pipeline {
    agent any
    stages {
        stage('初始化') {
            steps {
              script {
                //定义变量
                PASSWORD = 'ada'
              }
            }
        }
        stage('部署') {
            when {
              //当密码匹配的时候执行, 顺序不能反
              equals expected: 'ada',
              actual: PASSWORD
            }
            steps {
                sh 'echo 部署 stage ...'
            }
        }
    }
}
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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

if

在steps的script（声明式pipeline里使用groovy语法必备）里使用

pipeline {
    agent any 
    environment {
      OFF_FLAG = 'YES'
    }
    stages {
        stage('Init') { 
            steps { 
              script {
                BUILD_FLAG = true
              }
            }
        }
        stage('Build') { 
            steps { 
              script {
                if ( BUILD_FLAG ) {   // 当表达式为true时执行
                    sh 'echo Build stage ...' 
                }
              }
            }
        }
        
        stage('Test'){
            steps {
              script {
                if ( OFF_FLAG == 'YES' ) {  // 当环境变量匹配时执行
                  sh 'echo Test stage ...' 
                }
              }
            }
        }
    }
}
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

for

通常用于循环读取parameters参数中的值

pipeline {
	agent any
    parameters {
        extendedChoice(name: 'SSH_IP', 
                       type: 'PT_CHECKBOX', 
                       description: '选择发布节点', 
                       quoteValue: false, 
                       saveJSONParameterToFile: false, 
                       value: '172.16.0.242, 172.16.0.243', 
                       visibleItemCount: 2, 
                       multiSelectDelimiter: ',',
                       defaultValue: '172.16.0.242, 172.16.0.243')
    }
    stages {
        stage('测试'){
            steps {
                script {
                    for (value in SSH_IP.tokenize(',')) {  // 循环遍历SSH_IP参数，分隔符为,
                        echo value
                        sh "echo $value" // 等同echo value，上面为普通写法，下面为groovy语法写法
                    }
                }
            }
        }
    }
}
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

10、post（结束后要干啥）

定义在整个pipeline流水线或某个stage执行完之后运行，分为两种情况：

定义在最外层（pipeline下一级），表示整个pipeline执行完之后运行；

定义在具体stage中，表示在该stage结束后执行

常用post执行参数：

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

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

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

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

aborted 当前pipeline或stage执行结果是aborted（人工停止pipeline）时执行

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

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

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

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

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