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

Posted liuyitan

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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"
                            }
                        }
                    }
                }
            }
        }
    }
}

Pipeline Basic Steps-1-方法deleteDir和dir、echo、error、fileExists、isUnix、pwd、mail、retry、leep、timeout、waitUntil、withEnv
Pipeline Basic Steps-6-readFile,写文件writeFile和git SCM











以上是关于jenkins高级篇 pipeline系列之-—04语法的主要内容,如果未能解决你的问题,请参考以下文章

持续集成高级篇之Jenkins Pipeline 集成sonarqube

让Jenkins执行GitHub上的pipeline脚本

Jenkins流水线(pipeline)实战之:从部署到体验

Jenkins pipeline:pipeline 使用之语法详解

持续集成高级篇之基于win32-openssh搭建jenkins混合集群

[持续交付实践] pipeline:pipeline 使用之快速入门