Jenkins Pipeline语法

如“ 入门指南 ”所述，Pipeline最基本的部分是“步骤”。基本上，步骤告诉Jenkins 要做什么，并且作为Declarative和Scripted Pipeline语法的基本构建块。

声明性Pipeline

声明性Pipeline是Jenkins Pipeline 的一个相对较新的补充， 它在Pipeline子系统之上提出了一种更为简化和有意义的语法。

所有有效的声明性Pipeline必须包含在一个pipeline块内，例如：

pipeline {
    /* insert Declarative Pipeline here */
}

声明性Pipeline中有效的基本语句和表达式遵循与Groovy语法相同的规则 ，但有以下例外：

• Pipeline的顶层必须是块，具体来说是：pipeline { }
• 没有分号作为语句分隔符。每个声明必须在自己的一行
• 块只能包含章节， 指令，步骤或赋值语句。
• 属性引用语句被视为无参数方法调用。所以例如，输入被视为input()

您可以使用 声明性指令生成器 来帮助您配置声明性Pipeline中的指令和部分。

Sections

声明性Pipeline中的Sections通常包含一个或多个指令或步骤。

代理 agent

agent指定整个Pipeline或特定stage将在Jenkins环境中执行的位置，具体取决于该agent 部分的位置。该部分必须在pipeline块内的顶层定义，stage块内的agent是可选的 。

参数

为了支持Pipeline作者可能拥有的各种使用场景，agent部分支持几种不同类型的参数。这些参数可以应用于pipeline块的顶层，也可以应用在每个stage指令内。

• any

在任何可用的代理上执行Pipeline或stage。例如：agent any

• none

当在pipeline块的顶层应用时，将不会为整个Pipeline运行分配全局代理，并且每个stage部分将需要包含其自己的agent部分。例如：agent none

• label

使用提供的标签在Jenkins环境中可用的代理上执行Pipeline或stage性执行。例如：agent { label 'my-defined-label' }

• node

agent { node { label 'labelName' } }行为和 agent { label 'labelName' }相同，但node允许其他选项（如customWorkspace）。

• docker

用给定的容器执行Pipeline，或stage，将被动态地提供一个预先配置成基于Docker-based Pipelines的节点，或和label参数匹配的任选节点。 docker还可以接受一个args参数，可以直接将参数传递给docker run命令。例如：agent { docker 'maven:3-alpine' }或

agent {
    docker {
        image 'maven:3-alpine'
        label 'my-defined-label'
        args  '-v /tmp:/tmp'
    }
}

• dockerfile
  使用从Dockerfile源存储库中包含的容器构建容器来执行Pipeline或stage 。为了使用此选项，Jenkinsfile必须从Multibranch Pipeline或Pipeline from SCM加载。通常Dockerfile在源码库的根路径：agent { dockerfile true }。如果Dockerfile在其他目录中建立，请使用以下dir选项：agent { dockerfile { dir 'someSubDir' } }。您可以使用additionalBuildArgs选项将其他参数传递给docker build ...命令，如agent { dockerfile { additionalBuildArgs '--build-arg foo=bar' } }。

常用选项

下面是可以用于两个或多个agent的常用选项。在没有明确说明的情况下选项是可选的。

• label
  一个字符串。在这些标签上运行Pipeline或每个stage。此选项可用于node，docker和dockerfile，并且 对于node是必需的。
• customWorkspace
  一个字符串。运行Pipeline或每个stage， 在这个agent的自定义的工作空间内，而不是默认的。它可以是相对路径，在这种情况下，自定义工作区将位于节点上的工作空间根目录下，也可以是绝对路径。例如：

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

• reuseNode
  一个布尔值，默认为false。如果为true，则在同一工作空间中，而不是完全在新节点上运行Pipeline顶层指定的节点上的容器。此选项适用于docker和dockerfile，并且仅在agent的每个stage内才有效果。

例如：

Jenkinsfile (Declarative Pipeline)
pipeline {
    agent { docker 'maven:3-alpine' } 
    stages {
        stage('Example Build') {
            steps {
                sh 'mvn -B clean verify'
            }
        }
    }
}

在给定名称和tag（maven:3-alpine）的新创建的容器中执行此Pipeline中定义的所有步骤。

Stage-level agent 部分

Jenkinsfile (Declarative Pipeline)
pipeline {
    agent none 
    stages {
        stage('Example Build') {
            agent { docker 'maven:3-alpine' } 
            steps {
                echo 'Hello, Maven'
                sh 'mvn --version'
            }
        }
        stage('Example Test') {
            agent { docker 'openjdk:8-jre' } 
            steps {
                echo 'Hello, JDK'
                sh 'java -version'
            }
        }
    }
}

1. agent none在Pipeline顶层定义确保执行者不会被不必要地分配。使用agent none也强制每个stage部分包含自己的agent部分
2. 使用此镜像在新创建的容器中执行此stage中的步骤
3. 在新创建的容器中使用与前一个stage的不同镜像执行此stage中的步骤

发布 post

post定义将在Pipeline运行或stage结束时运行的操作。一些条件后 的块的内支持post： always，changed，failure，success，unstable，和aborted。这些块允许在Pipeline运行或stage结束时执行步骤，具体取决于Pipeline的状态。

条件

• always
  无论Pipeline运行的完成状态如何都会运行。
• changed
  只有当前Pipeline运行的状态与先前完成的Pipeline的状态不同时，才能运行。
• failure
  仅当当前Pipeline处于“失败”状态时才运行，通常在Web UI中用红色指示表示。
• success
  仅当当前Pipeline具有“成功”状态时才运行，通常在具有蓝色或绿色指示的Web UI中表示。
• unstable
  只有当前Pipeline具有“不稳定”状态，通常由测试失败，代码违例等引起，才能运行。通常在具有黄色指示的Web UI中表示。
• aborted
  只有当前Pipeline处于“中止”状态时，才会运行，通常是由于Pipeline被手动中止。通常在具有灰色指示的Web UI中表示。
• cleanup
  无论管道或stage的状态如何，在跑完所有其他的post条件后运行此条件下 的post步骤。

例如：

Jenkinsfile (Declarative Pipeline)
pipeline {
    agent any
    stages {
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
    post { 
        always { 
            echo 'I will always say Hello again!'
        }
    }
}

1. 通常，该post部分应放在Pipeline末端
2. post条件块包含的步骤和steps中的步骤用法相同

stage stages

包含一个或多个stage指令的序列，该stages部分是Pipeline 描述的大部分“工作”所在的位置。建议stages至少为持续交付流程的每个独立部分包含至少一个stage指令，例如构建，测试和部署。

例如

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

stages部分一般跟在agent， options等后面。

步骤 steps

steps部分定义了在给定stage指令中执行的一系列一个或多个步骤。

例如

Jenkinsfile (Declarative Pipeline)
pipeline {
    agent any
    stages {
        stage('Example') {
            steps { 
                echo 'Hello World'
            }
        }
    }
}

steps部分必须包含一个或多个步骤

来源

作者：程序员文集

链接：https://www.jianshu.com/p/18327865a38a

指令 Directives

环境 environment

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

该指令支持一种特殊的助手方法credentials()，可以通过Jenkins环境中的标识符来访问预定义的凭据。对于类型为“Secret Text”的凭据，该 credentials()方法将确保环境变量中包含该Secret Text内容。对于“标准用户名和密码”类型的凭证，指定的环境变量将被设置为username:password并且将自动定义两个附加的环境变量：MYVARNAME_USR和MYVARNAME_PSW。

例如：

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

1. environment顶级pipeline块中使用的指令将适用于Pipeline中的所有步骤
2. 在一个stage中定义的environment指令只将给定的环境变量应用于该stage中的步骤
3. environment具有一个帮助方法credentials()，可用于在Jenkins环境中通过其标识符访问预定义的凭据

批处理使用环境变量

pipeline {
    agent any
    environment {
        VERSION = 'crm_2.5.7'
        ProjectStartDate='11-26-2020'
        LANG = 'zh.CH.UTF-8'
    }
    stage('KM_Catering') {
        steps {
            echo "copy KM_Catering files"
            echo "ProjectStartDate: ${ProjectStartDate}"
            bat ''' chcp 65001
                    set /p LANG=${LANG}
                    set /p VERSION=${VERSION}
                    set /p projectStartDate= ${ProjectStartDate}
                 '''
        }
    }
}

PowerShell使用环境变量及参数

        stage('PSDeploy') {
            environment {
                VERSION = 'crm_2.5.9'
            }
             parallel {
                stage('DelpoyProjects') {
                    when { expression { params.PSDeploy==true } }
                    steps {
                        echo "Deploy ${VERSION}  files for ${DeployProjects} "
                        script{
                          powershell ('''  ."F:\\WWWRoot\\KeMai\\Projects\\O2O_KMMicro-Platform\\PublishTools\\PSDeploy\\Kemai\\Deploy\\DeploySync.ps1"
                                $tmpProjects="$env:DeployProjects"
                                $Host.UI.WriteLine("DelpoyProjects:$tmpProjects ")
                                #应用(WebApi:接口,CateringWeb:H5页面,MPWeb:后台,Information:微信消息与事件处理程序,MqReceiverServeices:MQ出列服务,RocketMqServeices:RocketMq出列服务,SummaryServices:数据汇总服务,WinServices:Job服务)
                                #$projects=@('KaWebApi','WebApi')
                                $projects=$tmpProjects.split(',')
                                $actionType='Backup' #操作类型(Upgrade:升级,Rollback:回滚,Backup:备份).
                                $nowTime= [datetime]::now
                                $dateFmt='%G%m%d'
                                #$configFormat='[%{upgradeversion}] [%{timestamp:+%Y-%m-%d}]'
                                $configuration = [hashtable] @{
                                    UpgradeVersion    = "$env:VERSION"  #升级版本
                                    UpgradeDate = (Get-Date @nowTime -UFormat $dateFmt) #升级日期
                                    BackupVersion    = "$env:VERSION"
                                    BackupDate = (Get-Date @nowTime -UFormat $dateFmt) #备份日期
                                    Timestamp=$nowTime #当前时间
                                }
                                DelpoyProjects -Projects $projects -ActionType $actionType -Configuration $configuration  
                            ''')
                        }
                    }
                }
             }
        }

选项 options

options指令允许在Pipeline内配置Pipeline专用选项。Pipeline提供了许多这些选项，例如buildDiscarder，但它们也可能由插件提供，例如 timestamps。

可用选项

• buildDiscarder
  持久化工件和控制台输出，用于保存Pipeline最近几次运行的数据。例如：options { buildDiscarder(logRotator(numToKeepStr: '1')) }
• checkoutToSubdirectory
  在工作区的子目录中执行源代码检出。例如：options { checkoutToSubdirectory('foo') }
• disableConcurrentBuilds
  不允许并行执行Pipeline。可用于防止同时访问共享资源等。例如：options { disableConcurrentBuilds() }
• preserveStashes
  保留已完成构建的存储，用于stage重新启动。例如：options { preserveStashes() }保存最近完成的构建中的stash，或者options { preserveStashes(5) }保留最近五个完成的构建中的stash。
• quietPeriod
  设置管道的静默期（以秒为单位），覆盖全局默认值。例如：options { quietPeriod(30) }
• retry
  如果失败，请按指定的次数重试整个管道。例如：options { retry(3) }
• skipDefaultCheckout
  在agent指令中默认跳过源代码检出。例如：options { skipDefaultCheckout() }
• skipStagesAfterUnstable
  一旦构建状态进入了“不稳定”状态，就跳过stage。例如：options { skipStagesAfterUnstable() }
• timeout
  设置Pipeline运行的超时时间，之后Jenkins应该中止Pipeline。例如：options { timeout(time: 1, unit: 'HOURS') }
• timestamps
  当执行时，预处理由Pipeline生成的所有控制台输出运行时间。例如：options { timestamps() }

例如：

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

指定一个小时的全局执行超时，之后Jenkins将中止Pipeline运行。

stage选项

stage的options指令类似于Pipeline根目录中的options指令。但是，stage的 options只能包含与stage相关的步骤，如retry，timeout或timestamps，或声明性选项，如skipDefaultCheckout。

在stage内，options在进入agent或检查任何when条件之前调用指令中的步骤。

可用的stage选项

• skipDefaultCheckout
  默认情况下，在agent指令中跳过检查源代码管理中的代码。例如：options { skipDefaultCheckout() }
• timeout
  设置此stage的超时时间，之后Jenkins应该中止该stage。例如：options { timeout(time: 1, unit: 'HOURS') }
• retry
  如果失败，请重试此stage指定次数。例如：options { retry(3) }
• timestamps
  当执行时，预处理由Pipeline生成的所有控制台输出运行时间。例如：options { timestamps() }

例

Jenkinsfile（声明性管道）

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

为stageExample指定一小时的执行超时，之后Jenkins将中止Pipeline运行。

参数 parameters

parameters指令提供用户在触发Pipeline时应提供的参数列表。这些用户指定的参数的值通过该params对象可用于Pipeline步骤，具体用法见示例。

可用参数

• string
  字符串类型的参数，例如： parameters { string(name: 'DEPLOY_ENV', defaultValue: 'staging', description: '') }
• 文本
  一个text参数，可以包含多行，例如： parameters { text(name: 'DEPLOY_TEXT', defaultValue: 'One\nTwo\nThree\n', description: '') }
• booleanParam
  一个布尔参数，例如： parameters { booleanParam(name: 'DEBUG_BUILD', defaultValue: true, description: '') }
• choice
  选择参数，例如： parameters { choice(name: 'CHOICES', choices: ['one', 'two', 'three'], description: '') }
• file
  一个文件参数，指定用户在计划构建时要提交的文件，例如： parameters { file(name: 'FILE', description: 'Some file to upload') }
• password
  密码参数，例如： parameters { password(name: 'PASSWORD', defaultValue: 'SECRET', description: 'A secret password') }

例如：

Jenkinsfile (Declarative Pipeline)
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')
        file(name: "FILE", description: "Choose a file to upload")
    }
    stages {
        stage('Example') {
            steps {
                echo "Hello ${params.PERSON}"
                echo "Biography: ${params.BIOGRAPHY}"
                echo "Toggle: ${params.TOGGLE}"
                echo "Choice: ${params.CHOICE}"
                echo "Password: ${params.PASSWORD}"
            }
        }
    }
}

    parameters {
        booleanParam(name: 'BUILD', defaultValue:  false, description: ' 是否拉取最新代码且生成')
        //choice(name: 'BuildProjects', choices: ['KmmpBuild', 'O2OBuild'], description: '请选择要生成的项目')
         extendedChoice(
            name: 'BuildMultipleProjects',
            defaultValue: 'KmmpBuild,O2OBuild',
            description: '请选择要生成的项目',
            multiSelectDelimiter: ',',
            quoteValue: false,
            saveJSONParameterToFile: false,
            type: 'PT_CHECKBOX', //PT_SINGLE_SELECT
            value:'KmmpBuild,O2OBuild',
            visibleItemCount: 10)
    }

触发器 triggers

triggers指令定义了Pipeline应重新触发的自动化方式。对于与源代码集成的Pipeline，如GitHub或BitBucket，triggers可能不需要基于webhook的集成可能已经存在。目前只有两个可用的触发器是cron和pollSCM。

• cron
  接受一个cron风格的字符串来定义Pipeline应重新触发的常规间隔，例如： triggers { cron('H 4/* 0 0 1-5') }
• pollSCM
  接受一个cron风格的字符串来定义Jenkins应该检查新的源更改的常规间隔。如果存在新的更改，则Pipeline将被重新触发。例如：triggers { pollSCM('H 4/* 0 0 1-5') }

该pollSCM触发器仅在Jenkins 2.22或更高版本可用

例如：

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

Jenkins cron 语法

Jenkins cron语法遵循cron实用程序的语法 （略有不同）。具体来说，每行包含由TAB或空格分隔的5个字段：

要为一个字段指定多个值，可以使用以下运算符。按优先顺序排列，

• * 指定所有有效值
• M-N 指定一系列值
• M-N/X或者按照指定范围或整个有效范围的*/X间隔步长X
• A,B,…,Z 枚举多个值

为了允许定期计划的任务在系统上产生均匀负载，应尽可能使用符号H（“哈希”）。例如，使用0 0 * * *十几个日常工作将导致午夜大量飙升。相比之下，使用H H * * *仍然会每天执行一次，但不能同时执行，更好地使用有限的资源。

所述H符号可以与范围内使用。例如，H H(0-7) * * * 表示从凌晨12:00（午夜）到早上7:59之间的某个时间段。您也可以使用H带有或不带范围的步长间隔。

H符号可以被认为是在一定范围内的随机值，但它实际上是作业名称的hash值，而不是随机函数的哈希值，所以对于给定的项目该值仍然是稳定的。

请注意，对于月份日期字段，由于月份长度可变，短期周期（例如/3或 H/3）将不会在大多数月份结束时始终如一地工作）。例如，/3 将在第1st, 4th, …31st 天运行, 然后在下个月的第一天运行。 哈希总是在1-28的范围内运行, 所以 H/3在一个月末将产生3到6天的空隙。（更长的周期也会有不一致的长度，但效果可能相对不太明显。）

以#开头的行和空行将被当做注释忽略。

此外，还有如下方便的别名：@yearly，@annually，@monthly， @weekly，@daily，@midnight，和@hourly。这些使用哈希系统进行自动平衡。例如，@hourly和H * * * *都意味着在一小时内的任何时间。 @midnight实际上意味着在凌晨12:00到凌晨2:59之间的某个时间。

每十五分钟（也许在：07，：22，：37，：52）

triggers{ cron('H/15 * * * *') }

每小时上半场每十分钟一次（三次，也许在：04，：14，：24）

triggers{ H(0-29)/10 * * * *) }

从上午9:45开始每小时45分钟一次，每个工作日下午3:45结束。

triggers{ 45 9-16/2 * * 1-5) }

每个工作日上午9点到下午5点之间每两小时一次（可能在上午10:38，下午12点38分，下午2点38分，下午4点38分）

triggers{ H H(9-16)/2 * * 1-5) }

除了12月之外，每个月的1日和15日每天一次

triggers{ H H 1,15 1-11 *) }

阶段 stage

stage指令在stages部分中，应包含步骤部分，可选agent部分或其他特定于stage的指令。实际上，Pipeline完成的所有实际工作都将包含在一个或多个stage指令中。

例如：

Jenkinsfile (Declarative Pipeline)
pipeline {
    agent any
    stages {
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
}

工具 tools

定义自动安装和放置工具的部分PATH。如果指定agent none，这将被忽略。

支持的工具

• maven
• jdk
• gradle

例如：

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

工具名称必须在Jenkins 管理Jenkins → 全局工具配置中预置。

输入 input

stage的input指令允许您使用[input](https://links.jianshu.com/go?to=https%3A%2F%2Fjenkins.io%2Fdoc%2Fpipeline%2Fsteps%2Fpipeline-input-step%2F%23input-wait-for-interactive-input)步骤提示输入 。在进入stage的agent或评估其when状态之前，stage将处于暂停状态。如果input 获得批准，stage则将继续。作为input提供的任何参数将在stage的剩下部分的环境中可用 。

配置选项

• message
  必填。这将在用户提交input时呈现给用户。
• id
  这是一个可选的标识符input。默认为stage名称。
• ok
  input表单上“ok”按钮的可选文本。
• submitter
  允许提交此input选项的用户或外部组名列表，用逗号分隔。默认允许任何用户。
• submitterParameter
  要使用submitter名称设置的环境变量的名称，可选（如果存在）。
• parameters
  用于提示提供的可选参数列表。有关更多信息，请参阅参数

例

Jenkinsfile (Declarative Pipeline)
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指令允许Pipeline根据给定的条件确定是否执行该stage。when指令必须至少包含一个条件。如果when指令包含多个条件，则所有子条件必须都返回true，stage将会执行。这与子条件嵌套在一个allOf条件中相同（见下面的例子）。

更复杂的条件结构可使用嵌套条件建：not，allOf或anyOf。嵌套条件可以嵌套到任意深度。

内置条件

• branch
  当正在构建的分支与给出的分支模式匹配时执行stage，例如：when { branch 'master' }。请注意，这仅适用于多分支Pipeline。
• environment
  当指定的环境变量设置为给定值时执行stage，例如： when { environment name: 'DEPLOY_TO', value: 'production' }
• expression
  当指定的Groovy表达式求值为true时执行stage，例如： when { expression { return params.DEBUG_BUILD } }
• not
  当嵌套条件为false时执行stage。必须包含一个条件。例如：when { not { branch 'master' } }
• allOf
  当所有嵌套条件都为真时，执行舞台。必须至少包含一个条件。例如：when { allOf { branch 'master'; environment name: 'DEPLOY_TO', value: 'production' } }
• anyOf
  当至少一个嵌套条件为真时执行舞台。必须至少包含一个条件。例如：when { anyOf { branch 'master'; branch 'staging' } }

例如：

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

中文乱码

node {
    def msbuild
    stage('Preparation') { 
        // for display purposes
        //在指定目录执行
        dir("E:\\Tools\\Java\\Jenkins\\workspace\\Test"){
            // Get some code from a svn repository
            git branch: 'v1.0.0', credentialsId: 'carl', url: 'http://github.com/test.git'
        }
        // 节点名称
        msbuild = tool 'VS2017'
    }
    stage('Build') {
        dir("E:\\Tools\\Java\\Jenkins\\workspace\\Test"){
            //解决中文乱码问题
            bat encoding: 'UTF-8', script: "CHCP 65001 \n \"${msbuild}\\MSBuild.exe\" /t:Rebuild /p:Configuration=Release;TargetFrameworkVersion=v4.0 Test/Test.csproj  "
        }
    }
    stage('Publish'){
        //copy 
        bat '''
        chcp 65001 
        xcopy E:\\Tools\\Java\\Jenkins\\workspace\\Test\\bin\\Release\\*.*    F:\\Application\\Test\\ /exclude:F:\\Application\\Test\\uncopy.txt /s/e/y
        ''' 
    }
    stage('Test') {
        // Run the  Unit
    }
}

原文

作者：程序员文集

链接：https://www.jianshu.com/p/7a852d58d9a9

来源：简书

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。