jenkins高级篇 pipeline系列之-—04语法

官网说明

Declarative Pipeline中有效的基本语句和表达式遵循与Groovy语法相同的规则 ,但有以下例外:

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

Declarative Pipeline语法-agent

作用:告知Jenkins选择那台节点机器去执行Pipeline代码。这个指令是必要的

any---任何
none---管道不指定,模块,步骤中指定
label---指定标签
node
docker
dockerfile
kubernetes

Declarative Pipeline语法-post

作用:一般用来发送消息,或者邮件通知。
在post代码块区域,支持多种条件指令,这些指令有always,changed,failure,success,unstable,和aborted。

Declarative Pipeline语法-stages,steps

在一个Declarative Pipeline脚本中,允许出现至少一次stages。一个stages下可以包含多个stage,一个stage 下至少有一个steps。
在Declarative 模式中,只支持steps,不支持在steps {…} 里面嵌套写step{…}。

pipeline {
    agent any 
    stages {
        stage('Build') { 
            steps {
                println "Build" 
            }
        }
        stage('Test') { 
            steps {
                println "Test" 
            }
        }
        stage('Deploy') { 
            steps {
                println "Deploy" 
            }
        }
    }
}

Declarative Pipeline指令-environment/options/parameters/triggers/tool

environment设置环境变量
options内置的选项
parameters参数,可通过页面配置
triggers触发器,可通过页面配置
tool定义自动安装和放置工具的部分PATH。如果agent none指定,这将被忽略。
特点:只支持定义maven jdk gradle三种工具的环境变量。

Declarative Pipeline指令-input/when

input---等待用户输入,根据输入值继续后续的流程
when----符合条件,则执行

多个stage的关系:顺序和并行

顺序stage

    agent none
    stages {
        stage('Non-Sequential Stage') {
            agent {
                label 'for-non-sequential'
            }
            steps {
                echo "On Non-Sequential Stage"
            }
        }
        stage('Sequential') {
            agent {
                label 'for-sequential'
            }
            environment {
                FOR_SEQUENTIAL = "some-value"
            }
            stages {
                stage('In Sequential 1') {
                    steps {
                        echo "In Sequential 1"
                    }
                }
                stage('In Sequential 2') {
                    steps {
                        echo "In Sequential 2"
                    }
                }
                stage('Parallel In Sequential') {
                    parallel {
                        stage('In Parallel 1') {
                            steps {
                                echo "In Parallel 1"
                            }
                        }
                        stage('In Parallel 2') {
                            steps {
                                echo "In Parallel 2"
                            }
                        }
                    }
                }
            }
        }
    }
}

并行stage

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"
                    }
                }
                stage('Branch C') {
                    agent {
                        label "for-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"
                            }
                        }
                    }
                }
            }
        }
    }
}
上一篇:sql需求:关于一个字段类型里面包含逗号切分和用逗号合并的需求


下一篇:Oracle expdp/impdp 使用示例