摘星
ztq
2023-09-26
目录

流水线语法(二)

# 流水线语法(二)

# 集成工具

  • 通过流水线的方式，在jenkisn里配置全局变量（npm, ant, maven, gradle）,通过项目里配置参数buildShell来控制实际的构建工具，实现用户可以选择构建工具来打包的功能

  • 项目准备：

    1. 安装 npm ant maven gradle
    2. 配置项目参数
    3. 配置系统管理----> 全局变量配置

# 简单解析

  • 一条流水线通过Jenkinsfile描述

  • 安装声明式插件pipeline： Declarative

  • Jenkinsfile组成：

    1. 指定node节点/workspace

    2. 指定指定运行选项

      • image-20230926103602452

    3. 指定stages阶段

      • 在这里我添加了三个阶段

        • Getcode

        • Build

        • codescan

        • image-20230926103745324

    4. 指定构建后操作

      • always{} ：总是执行脚本片段

      • success{}： 成功后执行

      • failure{}： 失败后执行

      • aborted{}： 取消后执行

      • currendBuild 是一个全局变量

        • description： 构建描述

      • image-20230926103945025

# 声明式流水线语法

# agent/options

  1. 指定node节点/workspace
  2. 指定指定运行选项
    • image-20230926103602452

  • agent指定了流水线的执行节点。参数：

    • any在任何可用的节点上执行pipeline。
    • none没有指定agent的时候默认。
    • label在指定标签上的节点上运行Pipeline。
    • node允许额外的选项。

  • 这两种是一样的

    • agent { node { label'labelname'}}
aget { label' labelname'}
      1
      2

# stages

  • 指定stages阶段

    • 在这里我添加了三个阶段
      • Getcode
      • Build
      • codescan
    • image-20230926103745324

  • 包含一系列一个或多个stage指令，建议stages至少包含一个stage指令用于连续交付过程的每个离散部分，比如构建，测试，和部署。

    • pipeline{
	agent any
	stages {
		stage('Example'){
			steps {
				echo'Hello World'
			}
		}
    }
}
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10

# step

  • step是每个阶段中要执行的具体步骤

    • pipeline{
	agent any
	stages {
		stage('Example'){
			steps {
				echo'Hello World' # step
			}
		}
    }
}
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10

# post

  • 指定构建后操作

    • always{} ：总是执行脚本片段

    • success{}： 成功后执行

    • failure{}： 失败后执行

    • aborted{}： 取消后执行

    • currendBuild 是一个全局变量

      • description： 构建描述

    • image-20230926103945025

  • 定义一个或多个steps,这些阶段根据流水线或阶段的完成情况而运行(取决于流水线中post部分的位置).post支持以下post-condition块中的其中之一：always, changed, failure, success, unstable,和aborted。这些条件块允许在post部分的步骤的执行取决于流水线或阶段的完成状态。

    • always无论流水线或者阶段的完成状态。
    • changed只有当流水线或者阶段完成状态与之前不同时。
    • failure只有当流水线或者阶段状态为"failure"运行。
    • success只有当流水线或者阶段状态为“success”运行。
    • unstable只有当流水线或者阶段状态为"unstable"运行。例如：测试失败。
  • pipeline {

	agent any

	stages {

		stage('Example'){

			steps {

				echo 'Hello World'
			}		
		}	
	}

·aborted只有当流水线或者阶段状态为”aborted“运行。例如：手动取消。

post{

	always {

		echo 'I will always say Hello again!'
	}
}
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24

# environment

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

  • 该指令支持一个特殊的方法 credentials() ，该方法可用于在Jenkins环境中通过标识符访问预定义的凭证。对于类型为 "Secret Text"的凭证, credentials() 将确保指定的环境变量包含秘密文本内容。对于类型为 "SStandard username and password"的凭证, 指定的环境变量指定为 username:password ，并且两个额外的环境变量将被自动定义 :分别为 MYVARNAME_USR 和 MYVARNAME_PSW 。

  • pipeline {
    agent any
    environment { 
        CC = 'clang'
    }
    stages {
        stage('Example') {
            environment { 
                AN_ACCESS_KEY = credentials('my-prefined-secret-text') 
            }
            steps {
                sh 'printenv'
            }
        }
    }
}
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17

# options

options 指令允许从流水线内部配置特定于流水线的选项。 流水线提供了许多这样的选项, 比如buildDiscarder,但也可以由插件提供, 比如 timestamps。

  • buildDiscarder: 为最近的流水线运行的特定数量保存组件和控制台输出。

  • disableConcurrentBuilds: 不允许同时执行流水线。 可被用来防止同时访问共享资源等。

  • overrideIndexTriggers: 允许覆盖分支索引触发器的默认处理。

  • skipDefaultCheckout: 在agent 指令中，跳过从源代码控制中检出代码的默认情况。

  • skipStagesAfterUnstable: 一旦构建状态变得UNSTABLE，跳过该阶段。

  • checkoutToSubdirectory: 在工作空间的子目录中自动地执行源代码控制检出。

  • timeout: 设置流水线运行的超时时间, 在此之后，Jenkins将中止流水线。

  • retry: 在失败时, 重新尝试整个流水线的指定次数。

  • timestamps 预测所有由流水线生成的控制台输出，与该流水线发出的时间一致。

  • //指定一个小时的全局执行超时, 在此之后，Jenkins将中止流水线运行。
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

# 参数

为流水线运行时设置项目相关的参数

  • string 字符串类型的参数, 例如:
parameters { string(name: 'DEPLOY_ENV', defaultValue: 'staging', description: '') }
1
  • booleanParam 布尔参数, 例如:
parameters { booleanParam(name: 'DEBUG_BUILD', defaultValue: true, description: '') }
1
2
  • 示例
pipeline {
    agent any
    parameters {
        string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')
    }
    stages {
        stage('Example') {
            steps {
                echo "Hello ${params.PERSON}"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 触发器

构建触发器

  • cron 计划任务定期执行构建。
triggers { cron('H */4 * * 1-5') }
1
  • pollSCM 与cron定义类似，但是由jenkins定期检测源码变化。
triggers { pollSCM('H */4 * * 1-5') }
1
  • upstream 接受逗号分隔的工作字符串和阈值。 当字符串中的任何作业以最小阈值结束时，流水线被重新触发。
triggers { upstream(upstreamProjects: 'job1,job2', threshold: hudson.model.Result.SUCCESS) }
1
  • 示例
pipeline {
    agent any
    triggers {
        cron('H */4 * * 1-5')
    }
    stages {
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# tool

获取通过自动安装或手动放置工具的环境变量。支持maven/jdk/gradle。工具的名称必须在系统设置->全局工具配置中定义。

示例:

pipeline {
    agent any
    tools {
        maven 'apache-maven-3.0.1' 
    }
    stages {
        stage('Example') {
            steps {
                sh 'mvn --version'
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

# input

input用户在执行各个阶段的时候，由人工确认是否继续进行。

  • message 呈现给用户的提示信息。
  • id 可选，默认为stage名称。
  • ok 默认表单上的ok文本。
  • submitter 可选的,以逗号分隔的用户列表或允许提交的外部组名。默认允许任何用户。
  • submitterParameter 环境变量的可选名称。如果存在，用submitter 名称设置。
  • parameters 提示提交者提供的一个可选的参数列表。

示例：

pipeline {
    agent any
    stages {
        stage('Example') {
            input {
                message "Should we continue?"
                ok "Yes, we should."
                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."
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# when

when 指令允许流水线根据给定的条件决定是否应该执行阶段。 when 指令必须包含至少一个条件。 如果when 指令包含多个条件, 所有的子条件必须返回True，阶段才能执行。 这与子条件在 allOf 条件下嵌套的情况相同。

内置条件

  • branch: 当正在构建的分支与模式给定的分支匹配时，执行这个阶段,这只适用于多分支流水线例如:
when { branch 'master' }
1
  • environment: 当指定的环境变量是给定的值时，执行这个步骤,例如:
when { environment name: 'DEPLOY_TO', value: 'production' }
1
  • expression 当指定的Groovy表达式评估为true时，执行这个阶段, 例如:
when { expression { return params.DEBUG_BUILD } }
1
  • not 当嵌套条件是错误时，执行这个阶段,必须包含一个条件，例如:
when { not { branch 'master' } }
1
  • allOf 当所有的嵌套条件都正确时，执行这个阶段,必须包含至少一个条件，例如:
when { allOf { branch 'master'; environment name: 'DEPLOY_TO', value: 'production' } }
1
  • anyOf 当至少有一个嵌套条件为真时，执行这个阶段,必须包含至少一个条件，例如:
when { anyOf { branch 'master'; branch 'staging' } }
1

示例：

pipeline {
    agent any
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            when {
                branch 'production'
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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'
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
pipeline {
    agent any
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            when {
                allOf {
                    branch 'production'
                    environment name: 'DEPLOY_TO', value: 'production'
                }
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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'
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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'
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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'
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 并行

声明式流水线的阶段可以在他们内部声明多隔嵌套阶段, 它们将并行执行。 注意，一个阶段必须只有一个 steps 或 parallel的阶段。 嵌套阶段本身不能包含 进一步的 parallel 阶段, 但是其他的阶段的行为与任何其他 stageparallel的阶段不能包含 agent 或 tools阶段, 因为他们没有相关 steps。

另外, 通过添加 failFast true 到包含parallel的 stage中， 当其中一个进程失败时，你可以强制所有的 parallel 阶段都被终止。

示例:

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

# script

script 步骤需要 [scripted-pipeline]块并在声明式流水线中执行。对于大多数用例来说,应该声明式流水线中的“脚本”步骤是不必要的，但是它可以提供一个有用的"逃生出口"。非平凡的规模和/或复杂性的script块应该被转移到 共享库 。

示例：

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

                script {
                    def browsers = ['chrome', 'firefox']
                    for (int i = 0; i < browsers.size(); ++i) {
                        echo "Testing the ${browsers[i]} browser"
                    }
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 脚本式Pipeline

脚本化流水线, 与声明式一样的是, 是建立在底层流水线的子系统上的。与声明式不同的是, 脚本化流水线实际上是由 Groovy构建的通用 DSL 。 Groovy 语言提供的大部分功能都可以用于脚本化流水线的用户。这意味着它是一个非常有表现力和灵活的工具，可以通过它编写持续交付流水线。

# 2.1 流程控制

脚本化流水线从Jenkinsfile的顶部开始向下串行执行, 就像 Groovy 或其他语言中的大多数传统脚本一样。 因此，提供流控制取决于 Groovy 表达式, 比如 if/else 条件, 例如:

node {
    stage('Example') {
        if (env.BRANCH_NAME == 'master') {
            echo 'I only execute on the master branch'
        } else {
            echo 'I execute elsewhere'
        }
    }
}
1
2
3
4
5
6
7
8
9
10

另一种方法是使用Groovy的异常处理支持来管理脚本化流水线流控制。当 步骤 失败 ，无论什么原因，它们都会抛出一个异常。处理错误的行为必须使用Groovy中的 try/catch/finally 块 , 例如:

node {
    stage('Example') {
        try {
            sh 'exit 1'
        }
        catch (exc) {
            echo 'Something failed, I should sound the klaxons!'
            throw
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

# 编写jenkinsfile

#!groovy
String buildShell = "${env.buildShell}" //jenkins项目中配置的参数名称
pipeline{
    agent any
    stages{
        stage("build"){
            steps{
                script{
                    mvnHome = tool "M2"
                    sh "${mvnHome}/bin/mvn -v"
                    // sh "${mvnHome}/bin/mvn ${buildShell}" //使用参数的方式进行构建
                }
            }
        }
        stage("ant"){
          steps{
                script{
                    try{
                        antHome = tool "ANT"
                        //sh "${antHome}/bin/ant -v"
                        sh "${antHome}/bin/ant ${buildShell}" //使用参数的方式进行构建
                    }catch(e){
                        println(e)
                    }
                }
            }
        }
        stage("gradlebuild"){
          steps{
                script{
                    gradleHome = tool "GRADLE"
                    println("${gradleHome}")
                    sh "${gradleHome}/bin/gradle -v"
                    //sh "${gradleHome}/bin/gradle ${buildShell}" //使用参数的方式进行构建
                }
            }
        } 
        stage("npmbuild"){
          steps{
                script{
                    npmHome = tool "NPM"
                    //sh "${npmHome}/bin/npm -v"
                    sh "${npmHome}/bin/npm ${buildShell}" //使用参数的方式进行构建
                }
            }
        }
    }
}
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
编辑 (opens new window)
上次更新: 2024/12/31 14:23:38
流水线实践(一)
配置共享库

← 配置共享库→

最近更新
01
ceshi
11-27
02
hexo-matery魔改
11-05
03
落地方案
11-05
更多文章>
Theme by Vdoing | Copyright © 2019-2024 张学友 | MIT License
京ICP备2024070721号