YES

any / none / label / node / docker / dockerfile / kubernetes

指定整个Pipeline或特定stage将在Jenkins环境中执行的位置，具体取决于该agent 部分的放置位置

pipeline {
  agent any

  agent none

  agent { 
    label 'my-label1 && my-label2' 
  }

  agent { node { label 'labelName' } }  // 等同于 agent { label 'labelName' }

  // docker 还可以接受一个args直接传递给`docker run`调用以及一个 alwaysPull 选项
  // registryUrl和registryCredentialsId参数 有助于指定要使用的Docker注册表及其凭据
  agent {
    docker {
      image 'maven:3-alpine'
      label 'my-defined-label'
      args  '-v /tmp:/tmp'
      registryUrl 'https://myregistry.com/'
      registryCredentialsId 'myPredefinedCredentialsInJenkins'
    }
  }

  // dockerfile
  agent {
    // 等同于 to "docker build -f Dockerfile.build --build-arg version=1.0.2 ./build/
    dockerfile {
        filename 'Dockerfile.build'
        // 如果要Dockerfile在另一个目录中构建，请使用以下dir选项
        dir 'build'
        label 'my-defined-label'
        additionalBuildArgs  '--build-arg version=1.0.2'
        args '-v /tmp:/tmp'
        // 同样也接受registryUrl和registryCredentialsId参数
        registryUrl 'https://myregistry.com/'
        registryCredentialsId 'myPredefinedCredentialsInJenkins'
    }
  }

  // kubernetes: 例如如果要在其中装有Kaniko容器的容器
  agent {
    kubernetes {
      label podlabel
      yaml """
  kind: Pod
  metadata:
    name: jenkins-agent
  spec:
    containers:
    - name: kaniko
      image: gcr.io/kaniko-project/executor:debug
      imagePullPolicy: Always
      command:
      - /busybox/cat
      tty: true
      volumeMounts:
        - name: aws-secret
          mountPath: /root/.aws/
        - name: docker-registry-config
          mountPath: /kaniko/.docker
    restartPolicy: Never
    volumes:
      - name: aws-secret
        secret:
          secretName: aws-secret
      - name: docker-registry-config
        configMap:
          name: docker-registry-config
  """
  }
}

YES

None

stages 是 Pipeline描述的大部分“工作”所在的位置, 该部分包含一个或多个阶段指令的序列。对于连续交付过程的每个离散部分，建议stages至少包含一个阶段指令，例如Build，Test，Deploy等

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

YES

None

stage中的一个或多个具体步骤（step）的容器，steps部分至少包含一个步骤。

pipeline{
    agent any
    stages{
        stage('stash'){
            parallel('测试') {
              stage('轮询') {
                steps{
                  timeout(time:10, unit:"SECONDS"){
                    waitUntil{
                      script{
                        def rs = sh script: 'docker version', returnStatus: true     
                        return (rs == 0)
                      }
                    }
                  }
                }
              }
              stage('重试') {
                steps{
                retry(3){
                  script{
                      sh script: 'curl https://www.baidu.com', returnStatus: true
                    }
                  sleep(3)
                }
              }
            }

            stage('错误') {
                steps{
                  retry(3){
                    error("执行失败")
                  }
              }
            }
          }
        }
    }
}

NO

always / changed / fixed / regression / aborted / failure / success / unstable / unsuccessful / cleanup

定义Pipeline或stage运行结束时的操作, 比如消息通知、执行其他job等

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

NO

None

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

pipeline {
  agent any
  //定义在pipeline块中，定义的环境变量可应用于Pipeline中的所有步骤。
  environment { 
    CC = 'clang'
  }
  stages {
    stage('Example') {
      //在 stage 中定义的 environment指令只会将给定的环境变量应用于Example内的步骤。
        environment { 
          // 在environment块中credentials('凭据名称')定义的帮助程序方法通过其在Jenkins环境中的标识符来访问预定义的凭据
          AN_ACCESS_KEY = credentials('wuzz') 
        }
        steps {
          sh 'printenv'
          echo "${env.AN_ACCESS_KEY}"
          echo "${env.CC}"
        }
    }
  }
}

pipeline {
  agent any
  environment {
    APP_NAME = 'clang'
  }
  stages {
    stage('Example Username/Password') {
      environment {
        // 变量 = 将用户密码凭证赋予变量
        SERVICE_CREDS = credentials('wuzz')
      }
      steps {
        // 注意点: defined: MYVARNAME_USR and MYVARNAME_PSW respectively.
        sh 'echo "Service user is $SERVICE_CREDS_USR"'
        sh 'echo "Service password is $SERVICE_CREDS_PSW"'
        sh 'curl -u $SERVICE_CREDS http://192.168.49.22:8040'
      }
    }
    stage('Example SSH Username with private key') {
      environment {
        // 变量 = 将 `ssh private` 公密钥进行赋予变量
        SSH_CREDS = credentials('wuzz')
      }
      steps {
        // 注意点: defined: MYVARNAME_USR and MYVARNAME_PSW (holding the passphrase).
        sh 'echo "SSH private key is located at $SSH_CREDS"'
        sh 'echo "SSH user is $SSH_CREDS_USR"'
        sh 'echo "SSH passphrase is $SSH_CREDS_PSW"'
 
        // 调用内置变量 (如果变量不存在则输出null) - 值得学习注意。
        echo "${JOB_NAME}"
        echo env.'JOB_NAME'
        println(env.'JOB_NAME') 
 
        // 自定义全局变量方式(写入文件中再读取)
        script {
          sh 'touch ${APP_NAME}'
          def projectProduct = sh returnStdout: true, script: "find ${APP_NAME}"
          if ( projectProduct != '' ){
            echo "${projectProduct}"
            writeFile file: 'abc.sh', text: "${projectProduct}"
            change_id = readFile 'abc.sh'
            print(change_id)
          } else {
            error "[-Error] : projectProduct 不能为空!"
          }
        }
         
      }
    }
  }
}

NO

None

定义流水线运行时的配置选项，常用的有 timeout()、retry()

# Global Timeout, Declarative Pipeline
pipeline {
    agent any
    options {
      // 将全局执行超时指定为一小时，然后Jenkins将中止 Pipeline运行。
      timeout(time: 1, unit: 'HOURS') 
    }
    stages {
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
}
Tips: 在 stage 块中支持的 options 要少于 pipeline 块中，只能使用skipDefaultCheckout，timeout，retry，timestamps 等选项

NO

None

参数，为流水线运行时设置相关的参数，不需要在UI界面上额外定义。

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')
    }
    stages {
        stage('Example') {
            steps {
                echo "Hello ${params.PERSON}"
                echo "Biography: ${params.BIOGRAPHY}"
                echo "Toggle: ${params.TOGGLE}"
                echo "Choice: ${params.CHOICE}"
                echo "Password: ${params.PASSWORD}"
            }
        }
    }
}

NO

None

定义Pipeline自动触发的方式

一小时内的分钟数 (0–59)

一天中的小时 (0–23)

月份中的某天 (1–31)

月份 (1–12)

星期几 (0–7)，其中 0 和 7 是星期日。

#每十五分钟一次（可能在 :07, :22, :37, :52）
triggers{ cron('H/15 * * * *') }

#每小时前半段每十分钟一次（三次，可能在 :04, :14, :24）
triggers{ cron('H(0-29)/10 * * * *') }

#每两小时一次，时间为每个工作日上午 9 点 45 分至下午 3 点 45 分，整点后 45 分钟。
triggers{ cron('45 9-16/2 * * 1-5') }

#每个工作日上午 9 点到下午 5 点之间每两小时一次（可能在上午 10 点 38 分、下午 12 点 38 分、下午 2 点 38 分、下午 4 点 38 分）
triggers{ cron('H H(9-16)/2 * * 1-5') }

#除 12 月外，每月 1 日和 15 日每天一次
triggers{ cron('H H 1,15 1-11 *') }

YES

steps，必填

stage 指令位于stages中并且应包含Step，可选 agent或其他特定指令, 实际上pipeline所有实际工作都将包含在一个或多个stage中。

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

NO

None

定义工具，获取通过自动安装或手动安装工具的环境变量，支持maven、jdk、gradle，工具的名称必须预先在Jenkins的系统设置->全局工具配置中定义，才可在pipeline中引用。

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

NO

None

交互输入，pipeline运行到input时会暂停，等待输入后，如果input 批准，stage将继续。作为input输入提供的任何参数在后续其他stage中均可用。

pipeline {
  agent any
  stages {
    stage('Example') {
      // 方式1.此种方式只能该块有效
      input {
        message "Title : 个人信息输入"
        ok "完成提交"
        submitter "alice,bob"
        parameters {
          string(name: 'INPUT_PERSON', defaultValue: 'WeiyiGeek', description: 'Message: 请输入您的姓名?')
          string(name: 'INPUT_AGE', defaultValue: 'WeiyiGeek', description: 'Message: 请输入您的年龄?')
          choice(name: 'INPUT_SEX', choices: ['Male','Female'], description: 'Message: 请选择你的性别?')
          booleanParam(name: 'INPUT_AGREE', defaultValue: true, description: 'Message: 是否确定协议?')
        }
      }

      steps {
        // 方式2: 注意script必须包含在 steps 块之中(此种方式可以全局传递参数)
        script {
          env.git_version=input message: 'Titel: 版本', ok: '通过',parameters: [string ( name: 'git_version', trim: true, description: 'Message : 请选择要操作的应用版本?')];

          env.deploy_option = input message: 'Titel: 操作', ok: 'deploy', parameters: [choice(name: 'deploy_option', choices: ['deploy', 'rollback', 'redeploy'], description: 'Message : 请选择操作流程?')];
        }

        // 12.input 输出示例
        echo "局部可用 输出示例1: 姓名：${INPUT_PERSON}, 年龄：${INPUT_AGE}, 性别：${INPUT_SEX}, 是否同意协议: ${INPUT_AGREE}"

        echo "全局可用 输出示例(script) -> 版本 : ${env.git_version}"
        echo "全局可用 输出示例(script) -> 版本 : ${env.deploy_option}"
    }
  }

  // 采用script块中定义input可以调用不同stage中得参数值
  stage ('调用') {
    steps {
      echo "调用1 : ${env.git_version}"
      echo "调用2 : ${env.deploy_option}"
    }
  }
}
}

NO

条件判断，允许流水线根据给定的条件决定是否应该执行阶段，when 指令必须包含至少一个条件，如果when指令包含多个条件，则所有子条件必须返回true才能执行该阶段。

pipeline { 
    agent none 
    stages { 
        stage('Example Build') {
            steps {
                echo 'Hello World' 
            } 
        } 
        stage('beforeinput') {
            when { 
					beforeInput true // 关键点
            		branch 'production' 
			} 
            input {
                message "Deploy to production?" 
                id "simple-input" 
            } 
            steps {
                echo 'Deploying' 
            } 
        }
        stage('beforeagent') {
            agent {label "wuzz"}
            when {
                beforeAgent true // 关键点
                branch 'production'
                }
            steps {
                echo 'Deploying'
            }
        }
        stage('beforeoption') {
            when {
                beforeOptions true // 关键点
                branch 'testing'
            }
            options {
                lock label: 'testing-deploy-envs', quantity: 1, variable: 'deployEnv'
            }
            steps {
                echo "Deploying to ${deployEnv}"
            }
        }
    }
}

pipeline {
    agent none  // beforeAgent
    stages {
      stage('Example Build') {
        steps {
          echo 'Hello World'
        }
      }
      stage('Example Deploy') {
        // Single Condition - 单一条件
        when {
          branch 'production'
        }

        // Multiple Condition - 多重条件
        when {
          branch 'production'
          environment name: 'DEPLOY_TO', value: 'production'
        }

        // Nested condition - 嵌套条件
        when {
          allOf {
            branch 'production'
            environment name: 'DEPLOY_TO', value: 'production'
          }
        }

        // Multiple condition and nested condition - 注意点
        when {
            branch 'production'
            anyOf {
                environment name: 'DEPLOY_TO', value: 'production'
                environment name: 'DEPLOY_TO', value: 'staging'
            }
         }
        
        // Expression condition and nested condition  - 表达式条件和嵌套条件
        when {
          expression { BRANCH_NAME ==~ /(production|staging)/ }
          anyOf {
              environment name: 'DEPLOY_TO', value: 'production'
              environment name: 'DEPLOY_TO', value: 'staging'
          }
        }

        // triggeredBy
        when {
          triggeredBy "TimerTrigger"  // 当前Job设置的触发器名称进行监控
        }

        // 当前面的when都满足时采用执行该阶段步骤，否则丢弃
        steps {
            echo 'Deploying'
        }
      }
    }
}

pipeline {
    agent none
    options {
        parallelsAlwaysFailFast()
    } 
    stages {
        // 非时序的阶段
        stage('Non-Sequential Stage') {
            agent {
                label 'wuzz'
            }
            steps {
                echo "On Non-Sequential Stage"
            }
        }
        // 顺序阶段
        stage('Sequential Stage') {
            agent {
                label 'wuzz'
            }
            environment {
                FOR_SEQUENTIAL = "some-value"
            }
            // 注意点1:
            stages {
                stage('In Sequential 1') {
                    steps {
                        echo "In Sequential 1"
                    }
                }
                stage('In Sequential 2') {
                    steps {
                        echo "In Sequential 2"
                    }
                }
                // 注意点2:可以使用stage的所有其他功能，包括代理、工具、when等
				stage('Parallel Stage') {
					//在任何一个阶段失败时强制终止所有并行阶段
					failFast true
					parallel {
						stage('Branch A') {
							steps {
								echo "On Branch A"
							}
						}
						stage('Branch B') {
							steps {
								echo "On Branch B"
							}
						}
						stage('Branch C') {
							stages {
								stage('Nested 1') {
									steps {
										echo "In stage Nested 1 within Branch C"
									}
								}
								stage('Nested 2') {
									steps {
										echo "In stage Nested 2 within Branch C"
									}
								}
							}
						}
					}
				}
            }
        }
    }
}

pipeline {
    // 参数选择
    parameters {
        choice(name: 'PLATFORM_FILTER', choices: ['all', 'linux', 'windows', 'mac'], description: 'Run on specific platform')
    }
    agent none
    stages {
        stage('BuildAndTest') {
            matrix {
                agent {
                    label "wuzz"
                }
                when { anyOf {
                    // 参数选择不为空时继续执行
                    expression { params.PLATFORM_FILTER == 'all' }
                    expression { params.PLATFORM_FILTER == env.PLATFORM }
                } }
                // 2 轴 (3 x 4) 十二格组合方式
                axes {
                    axis {
                        name 'PLATFORM'
                        values 'linux', 'windows', 'mac'
                    }
                    axis {
                        name 'BROWSER'
                        values 'firefox', 'chrome', 'safari', 'edge'
                    }
                }
                // 排除指定Matrix矩阵中的值 (排除linux和safari组合，并排除使用edge浏览器的任何非windows平台。) 
                // 即 排除 (linux,safari) , (linux,edge) , (mac,edge) 三种情况
                excludes {
                    exclude {
                        axis {
                            name 'PLATFORM'
                            values 'linux'
                        }
                        axis {
                            name 'BROWSER'
                            values 'safari'
                        }
                    }
                    exclude {
                        axis {
                            name 'PLATFORM'
                            notValues 'windows'
                        }
                        axis {
                            name 'BROWSER'
                            values 'edge'
                        }
                    }
                }
                stages {
                    stage('Build') {
                        steps {
                            echo "Do Build for ${PLATFORM} - ${BROWSER}"
                        }
                    }
                    stage('Test') {
                        steps {
                            echo "Do Test for ${PLATFORM} - ${BROWSER}"
                        }
                    }
                }
            }
        }
    }
}

NO

None

在Declarative Pipeline中，可采用script指令来执行Scripted Pipeline中的一些脚本

pipeline {
    agent any
    stages {
        stage('Example') {
          steps { 
              script {
                def browsers = ['chrome', 'firefox']
                for (int i = 0; i < browsers.size(); ++i) {
                    echo "Testing the ${browsers[i]} browser"
                }
              }
          }
        }
    }
}

echo "Hello"

println "World!"

node {
    if(isUnix()){
     echo "is unix" 
    }
 }

node {
    dir('123') {
        sh """ mkdir 333;cd 333;pwd """ 
    }
 }

node {
    dir('123') {
        sh 'touch 1.txt;ls'
        deleteDir()
        sh 'ls'
    }
 }

node {
        if(fileExists('123/1.txt') == true){
            echo "file exists"
        }
 }

node {
        if(fileExists('123/1.txt') == true){
            

        }
    }

node {
    if(fileExists('123/1.txt') == true){
		def data = readFile(file: '123/1.txt')
		println(data)
		//按行打印，打印一行之后暂停2秒
		Thread.sleep(2000)
		//按行读取
		def lines = data.readLines()
		//使用for循环遍历每行
		for (line in lines) {
			println(line)
		//假如是一个csv文件，每行都是以逗号分隔的参数，可以使用split取每一列
			String[] str;
			str = line.split(',');
			println('projectkey:' + str[0])
			println('reponame:' + str[1])
			println('giturl:' + str[2])
		}
    }
}

node {
    stash excludes: '2.txt', includes: '
', name: 'txtstash'
}
node {
    unstash 'txtstash'
}

node {
    archiveArtifacts allowEmptyArchive: true, artifacts: '123/*.txt', excludes: '2.txt', fingerprint: true, onlyIfSuccessful: true
}

node {
    unarchive mapping: ['123/*.txt': '222/']
}

node {
    wrap([$class: 'TimestamperBuildWrapper']) {
    echo "hello world"
    }
}

node {
  withEnv(['MYTOOL_HOME=/usr/local/mytool']) {
    sh '$MYTOOL_HOME/bin/start'
  }
  withEnv(['name=tester']) {
          echo "$name"
        }
}

node {
    withCredentials([usernamePassword(credentialsId: 'wuzz', passwordVariable: 'password', usernameVariable: 'username')]) {
        sh 'echo $username'
    }
}

node {
//获取标准输出
	//方式1
	result = sh returnStdout: true ,script: "pwd" 
	result = result.trim()
	echo "$result"
	//方式2
	result = sh(script: "pwd", returnStdout: true).trim()
	echo "$result"
	//方式3
	sh "pwd > commandResult" 
	result = readFile('commandResult').trim()
	echo "$result"


//获取执行状态.net
	//方式1
	result = sh returnStatus: true ,script: "pwd" 
	echo "$result"
	//方式2
	result = sh(script: "pwd", returnStatus: true)
	echo "$result"
	//方式3
	sh 'pwd; echo $? > status' 
	def r = readFile('status')
	echo "$r"

//无需返回值，仅执行shell命令ci
	sh 'pwd'
}

node {
    timeout(time:10, unit:"SECONDS"){
        waitUntil{
          script{
            def rs = sh script: 'pwd', returnStatus: true     
            return (rs == 0)
          }
        }
    }
}

node {
timeout(time: 1, unit: 'MINUTES') {
  script {
    env.deploy_option = input message: '选择操作', ok: 'deploy',
    parameters: [choice(name: 'deploy_option', choices: ['deploy', 'rollback', 'redeploy'], description: '选择部署环境')]
    switch("${env.deploy_option}"){
        case 'deploy':
            println('1.deploy prd env')
            break;
        case 'rollback':
            println('2.rollback env')
            break;
        case 'redeploy':
            println('3.redeploy env')
            break;
        default:
            println('error env')
    }
  }
}
}

pipeline {
    agent any
    stages {
        stage('Example') {
          steps {
              script {
                def browsers = ['chrome', 'firefox', 'ie']
                for (int i = 0; i < browsers.size(); ++i) {
                    if (i==1)
					continue
					echo "Testing the ${browsers[i]} browser"
					
                }
              }
          }
        }
    }
}

node {
    catchError {
        sh 'might fail'
    }
    step([$class: 'Mailer', recipients: '
zhenzhen.wu@163.com'])
}

node {
try {
  sh 'might fail && whoami'
  echo 'Succeeded!'
} catch (err) {
  echo "Failed: ${err} - " + err.toString() 
  error "[-Error] : 项目部署失败 \n[-Msg] : ${err.getMessage()} "
} 
}

pipeline {
    agent any
    stages {
        stage('Hello') {
            steps {
                echo 'Hello World'
            }
        }
    }
	post {
			success {	
				step([$class: 'Mailer',
					notifyEveryUnstableBuild: true,
					recipients: 'zhenzhen.wu@163.com',
					sendToIndividuals: true])
		   }
			failure {
				step([$class: 'Mailer', recipients: 'zhenzhen.wu@163.com'])	
			  }
	}
}

retry(count: 5)  # 重试5次

sleep time: 60, unit: 'MINUTES'

node {
    def aaa = getContext hudson.FilePath
    echo "$aaa"
}