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----符合条件，则执行

pipeline {
    agent any
    environment {
        quick_test = false
    }
    stages {
        stage('Example Build') {
            steps {
                script {
                    echo 'Hello World'
                }
            }
        }
        stage('Example Deploy') {
            when {
                expression { 
                   return  (quick_test == “true” )
                    
                }
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}

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

顺序stage

pipeline {
    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
failFast true，只要有一个不通过，就中止运行pipeline下面的代码

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