pipeline语法

SoulChild 收录于 devops

2020-05-07 09:51 约 640 字预计阅读 4 分钟 135 次阅读

警告

本文最后更新于 2020-05-30 17:09，文中内容可能已过时。

agent

any：任意节点执行流水线

node：默认

label：在指定的 agent 上执行流水线

node：agent { node { label ’labelName’ } } 和 agent { label ’labelName’ }相同，但 node 允许其他选项（如 customWorkspace 指定工作空间目录）

options

buildDiscarder

持久化工件和控制台输出，用于最近 Pipeline 运行的具体数量。例如：options { buildDiscarder(logRotator(numToKeepStr: ‘1’)) }

disableConcurrentBuilds

不允许并行执行 Pipeline。可用于防止同时访问共享资源等。例如：options { disableConcurrentBuilds() }

skipDefaultCheckout

在 agent 指令中默认跳过来自源代码控制的代码。例如：options { skipDefaultCheckout() }

skipStagesAfterUnstable

一旦构建状态进入了 “不稳定” 状态，就跳过阶段。例如：options { skipStagesAfterUnstable() }

timeout

设置 Pipeline 运行的超时时间，之后 Jenkins 应该中止 Pipeline。例如：options { timeout(time: 1, unit: ‘HOURS’) }

retry

失败后，重试整个 Pipeline 指定的次数。例如：options { retry(3) }

timestamps

在控制台输出运行时间。例如：options { timestamps() }

post

always

运行，无论 Pipeline 运行的完成状态如何。

changed

只有当前 Pipeline 运行的状态与先前完成的 Pipeline 的状态不同时，才能运行。

failure

仅当当前 Pipeline 处于 “失败” 状态时才运行，通常在 Web UI 中用红色指示表示。

success

仅当当前 Pipeline 具有 “成功” 状态时才运行，通常在具有蓝色或绿色指示的 Web UI 中表示。

unstable

只有当前 Pipeline 具有 “不稳定” 状态，通常由测试失败，代码违例等引起，才能运行。通常在具有黄色指示的 Web UI 中表示。

aborted

只有当前 Pipeline 处于 “中止” 状态时，才会运行，通常是由于 Pipeline 被手动中止。通常在具有灰色指示的 Web UI 中表示。

environment

该 environment 指令指定一系列键值对，这些对值将被定义为所有步骤或阶段特定步骤的环境变量，具体取决于 environment 指令位于 Pipeline 中的位置。

该指令支持一种特殊的帮助方法 credentials ()，可以通过其在 Jenkins 环境中的标识符来访问预定义的凭据。对于类型为 “Secret Text” 的凭据，该 credentials () 方法将确保指定的环境变量包含 Secret Text 内容。对于 “标准用户名和密码” 类型的凭证，指定的环境变量将被设置为， 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'
            }
        }
    }
}

parameters

参数化构建

string 字符串类型的参数：

parameters { string(name: 'DEPLOY_ENV', defaultValue: 'staging', description: '') }

booleanParam 布尔参数：

parameters { booleanParam(name: 'DEBUG_BUILD', defaultValue: true, description: '') }

pipeline {
    parameters { 
        string(name: 'DEPLOY_ENV', defaultValue: 'staging', description: '') 
        booleanParam(name: 'DEBUG_BUILD', defaultValue: true, description: '') 
    }
    agent any
    stages {
        stage("Example") {
            steps {
                println("${DEPLOY_ENV}")
                println("$DEBUG_BUILD")
            }
        }
    }

tool

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

需要在 jenkins 配置 maven 环境，名称为 apache-maven-3.0.1

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 {
    parameters { 
        string(name: 'DEPLOY_ENV', defaultValue: 'staging', description: '') 
        booleanParam(name: 'DEBUG_BUILD', defaultValue: true, description: '') 
    }
    agent any
    stages {
        stage("Example") {
            steps {
                println("${DEPLOY_ENV}")
                println("$DEBUG_BUILD")
                input message: '继续执行', ok: '是的，执行', parameters: [text(defaultValue: 'None', description: '', name: 'content')], submitter: 'admin'
            }
        }
    }
}

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

示例：

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

// env
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'
            }
        }
    }
}

// allOf
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'
            }
        }
    }
}

// anyOf
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
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'
            }
        }
    }
}

paraller

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

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

示例：

pipeline {
    agent any
    stages {
        stage('普通stage') {
            steps {
                echo 'This stage will be executed first.'
            }
        }
        stage('并行Stage') {
            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"
                    }
                }
            }
        }
    }
}

请我喝杯水

赞赏

微信号

微信打赏

pipeline 语法