jenkins☞002Pipelines

阅读量: zyh 2021-01-16 20:07:13

Categories： > Tags：

前言

纯图形化的配置，并不能很有效的支撑自动化，也不灵活，一般jenkins的工程会通过Jenkinsfile来配置pipeline。

pipeline 有声明和脚本两种方式，声明式官方比较推荐。当然声明也可以嵌入脚本。

可以在http://groovy.jsrun.net/等站点上调试语法。

流水线语法

基本流程如下：
Jenkins工程 => scm git => Jenkinsfile => pipeline

脚本式语法

最后，脚本语言采用groovy语言编写。

关于groovy的语法，可以简单的看看https://www.w3cschool.cn/groovy/

字符串截断

"abscd adfa dasfds ghisgirs fsdfgf".take(10)  //"abscd adfa"
"It's groovy, man".take(4)      //"It's"
"It's groovy, man".take(10000)  //"It's groovy, man" (no exception thrown)

"It's groovy, man".drop(15)         //"n"
"It's groovy, man".drop(5).take(6)  //"groovy"

字符串分割

// https://abc.com/it/test.git 获取 it 字符串
registryNamespace = env.GIT_URL.split("/|\\.")[-3]

声明式语法

agent

用于指明运行程序的节点

可用参数：

label 指定标签
any 任意节点
None 默认节点
node 详细描述某个节点信息，可以包含label

pipeline {
    agent {
        node {
        	label "master" //指定【运行节点】的标签或者名称
        	customWorkspace "${workspace}"
        }
    }
    stages {
        stage {
            steps {
                pass
            }
        }
    }
    post {
        always {
            pass
        }
    }
}
agent {
    node {
        label "master" //指定【运行节点】的标签或者名称
        customWorkspace "${workspace}"
    }
}

stages

运行阶段，包含多个阶段，每个阶段包含步骤所需的代码

pipeline {
    agent any
    stages {
        stage(){
            steps {
                pass
            }
        }
    }
}

post

根据stages运行状态，执行后续处理的代码

可用状态:

always 总是执行
changed 任意状态对比上一次执行不一致的时候执行
failure 最终状态失败的时候执行
success 最终状态成功地时候执行
unstable 中间状态失败导致无法抵达最终阶段的时候执行
aborted 手动取消的时候执行

pipeline {
    agent any
    stages {
        stage {
            pass
        }
    }
    post {
        always {
            pass
        }
    }
}

除了上面的三大块，在agent后，你还可以添加一些额外的

environment

环境变量

pipeline {
    agent
    environment {
        key = "123456"
    }
}

options

配置特定于流水线的选项

buildDiscarder: 为最近的流水线运行的特定数量保存组件和控制台输出。
disableConcurrentBuilds: 不允许同时执行流水线。可被用来防止同时访问共享资源等。
overrideIndexTriggers: 允许覆盖分支索引触发器的默认处理。
skipDefaultCheckout: 在agent 指令中，跳过从源代码控制中检出代码的默认情况。
skipStagesAfterUnstable: 一旦构建状态变得UNSTABLE，跳过该阶段。
checkoutToSubdirectory: 在工作空间的子目录中自动地执行源代码控制检出。
timeout: 设置流水线运行的超时时间, 在此之后，Jenkins将中止流水线。
retry: 在失败时, 重新尝试整个流水线的指定次数。
timestamps 预测所有由流水线生成的控制台输出，与该流水线发出的时间一致。

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

parameters

添加一些参数

💥比较特殊的是，参数只有流水线运行一次后，才可以在web图形化里看到相关的配置

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

triggers

触发器

cron 计划任务
pollSCM 与 cron 类似
upstream 接受逗号分隔的工作字符串和阈值。当字符串中的任何作业以最小阈值结束时，流水线被重新触发。

triggers { upstream(upstreamProjects: 'job1,job2', threshold: hudson.model.Result.SUCCESS) }

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

tools

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

示例:

pipeline {
    agent any
    tools {
        maven 'apache-maven-3.0.1' 
    }
    stages {
        stage('Example') {
            steps {
                sh 'mvn --version'
            }
        }
    }
}

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

when

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

内置条件

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

示例：

pipeline {
    agent any
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            when {
                branch 'production'
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}
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'
            }
        }
    }
}
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'
            }
        }
    }
}
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'
            }
        }
    }
}
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'
            }
        }
    }
}
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'
            }
        }
    }
}

parallel

声明式流水线的阶段可以在他们内部声明多隔嵌套阶段, 它们将并行执行。注意，一个阶段必须只有一个 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  // 如果第一个stage失败，则后续stage不再执行
            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"
                    }
                }
            }
        }
    }
}

jenkins☞003共享库

jenkins☞基于k8s生成动态的Jenkins agent