zoukankan      html  css  js  c++  java

  • Jenkins Pipeline 语法

    Pipeline语法

    先讲Declarative Pipeline，所有声明式管道都必须包含在pipeline块中：

    1
    2
    3
    		 
    pipeline {
        /* insert Declarative Pipeline here */
    }

    块里面的语句和表达式都是Groovy语法，遵循以下规则：

    1. 最顶层规定就是pipeline { }
    2. 语句结束不需要分好，一行一条语句
    3. 块中只能包含Sections, Directives, Steps或者赋值语句
    4. 属性引用语句被当成是无参方法调用，比如input实际上就是方法input()调用

    接下来我详细讲解下Sections, Directives, Steps这三个东西

    Sections

    Sections在声明式管道中包含一个或多个Directives, Steps

    post

    post section 定义了管道执行结束后要进行的操作。支持在里面定义很多Conditions块： always,changed, failure, success 和 unstable。 这些条件块会根据不同的返回结果来执行不同的逻辑。

    • always：不管返回什么状态都会执行
    • changed：如果当前管道返回值和上一次已经完成的管道返回值不同时候执行
    • failure：当前管道返回状态值为”failed”时候执行，在Web UI界面上面是红色的标志
    • success：当前管道返回状态值为”success”时候执行，在Web UI界面上面是绿色的标志
    • unstable：当前管道返回状态值为”unstable”时候执行，通常因为测试失败，代码不合法引起的。在Web UI界面上面是黄色的标志
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    		 
    // Declarative //
    pipeline {
        agent any
        stages {
            stage('Example') {
                steps {
                    echo 'Hello World'
                }
            }
        }
        post { ①
            always { ②
                echo 'I will always say Hello again!'
            }
        }
    }

    stages

    由一个或多个stage指令组成，stages块也是核心逻辑的部分。 我们建议对于每个独立的交付部分（比如Build,Test,Deploy）都应该至少定义一个stage指令。比如：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    		 
    // Declarative //
    pipeline {
        agent any
        stages { ①
            stage('Example') {
            steps {
                echo 'Hello World'
            }
            }
        }
    }

    steps

    在stage中定义一系列的step来执行命令。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    		 
    // Declarative //
    pipeline {
        agent any
        stages {
            stage('Example') {
                steps { ①
                    echo 'Hello World'
                }
            }
        }
    }

    Directives

    jenkins中的各种指令

    agent

    agent指令指定整个管道或某个特定的stage的执行环境。它的参数可用使用：

    1. any - 任意一个可用的agent
    2. none - 如果放在pipeline顶层，那么每一个stage都需要定义自己的agent指令
    3. label - 在jenkins环境中指定标签的agent上面执行，比如agent { label 'my-defined-label' }
    4. node - agent { node { label 'labelName' } } 和 label一样，但是可用定义更多可选项
    5. docker - 指定在docker容器中运行
    6. dockerfile - 使用源码根目录下面的Dockerfile构建容器来运行

    environment

    environment定义键值对的环境变量

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    		 
    // Declarative //
    pipeline {
        agent any
        environment { ①
            CC = 'clang'
        }
        stages {
            stage('Example') {
                environment { ②
                    AN_ACCESS_KEY = credentials('my-prefined-secret-text') ③
                }
                steps {
                    sh 'printenv'
                }
            }
        }
    }

    options

    还能定义一些管道特定的选项，介绍几个常用的：

    • skipDefaultCheckout - 在agent指令中忽略源码checkout这一步骤。
    • timeout - 超时设置options { timeout(time: 1, unit: 'HOURS') }
    • retry - 直到成功的重试次数options { retry(3) }
    • timestamps - 控制台输出前面加时间戳options { timestamps() }

    parameters

    参数指令，触发这个管道需要用户指定的参数，然后在step中通过params对象访问这些参数。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    		 
    // Declarative //
    pipeline {
        agent any
        parameters {
            string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')
        }
        stages {
            stage('Example') {
                steps {
                    echo "Hello ${params.PERSON}"
                }
            }
        }
    }

    triggers

    触发器指令定义了这个管道何时该执行，一般我们会将管道和GitHub、GitLab、BitBucket关联， 然后使用它们的webhooks来触发，就不需要这个指令了。如果不适用webhooks，就可以定义两种cron和pollSCM

    • cron - linux的cron格式triggers { cron('H 4/* 0 0 1-5') }
    • pollSCM - jenkins的poll scm语法，比如triggers { pollSCM('H 4/* 0 0 1-5') }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    		 
    // Declarative //
    pipeline {
        agent any
        triggers {
            cron('H 4/* 0 0 1-5')
        }
        stages {
            stage('Example') {
                steps {
                    echo 'Hello World'
                }
            }
        }
    }

    stage

    stage指令定义在stages块中，里面必须至少包含一个steps指令，一个可选的agent指令，以及其他stage相关指令。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    		 
    // Declarative //
    pipeline {
        agent any
        stages {
            stage('Example') {
                steps {
                    echo 'Hello World'
                }
            }
        }
    }

    tools

    定义自动安装并自动放入PATH里面的工具集合

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    		 
    // Declarative //
    pipeline {
        agent any
        tools {
            maven 'apache-maven-3.0.1' ①
        }
        stages {
            stage('Example') {
                steps {
                    sh 'mvn --version'
                }
            }
        }
    }

    注：① 工具名称必须预先在Jenkins中配置好了 → Global Tool Configuration.

    内置条件

    • branch - 分支匹配才执行 when { branch 'master' }
    • environment - 环境变量匹配才执行 when { environment name: 'DEPLOY_TO', value: 'production' }
    • expression - groovy表达式为真才执行 expression { return params.DEBUG_BUILD } }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    		 
    // Declarative //
    pipeline {
        agent any
        stages {
            stage('Example Build') {
                steps {
                    echo 'Hello World'
                }
            }
            stage('Example Deploy') {
                when {
                    branch 'production'
                }
                echo 'Deploying'
            }
        }
    }

    Steps

    这里就是实实在在的执行步骤了，每个步骤step都具体干些什么东西， 前面的Sections、Directives算控制逻辑和环境准备，这里的就是真实执行步骤。

    这部分内容最多不可能全部讲完，官方Step指南 包含所有的东西。

    Declared Pipeline和Scripted Pipeline都能使用这些step，除了下面这个特殊的script。

    一个特殊的step就是script，它可以让你在声明管道中执行脚本，使用groovy语法，这个非常有用：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    		 
    // Declarative //
    pipeline {
        agent any
        stages {
            stage('Example') {
                steps {
                    echo 'Hello World'
                    script {
                        def browsers = ['chrome', 'firefox']
                        for (int i = 0; i < browsers.size(); ++i) {
                            echo "Testing the ${browsers[i]} browser"
                        }
                    }
                    script {
                        // 一个优雅的退出pipeline的方法，这里可执行任意逻辑
                        if( $VALUE1 == $VALUE2 ) {
                           currentBuild.result = 'SUCCESS'
                           return
                        }
                    }
                }
            }
        }
    }

    最后列出来一个典型的Scripted Pipeline：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    		 
    node('master') {
        checkout scm

        stage('Build') {
            docker.image('maven:3.3.3').inside {
                sh 'mvn --version'
            }
        }

        stage('Deploy') {
            if (env.BRANCH_NAME == 'master') {
                echo 'I only execute on the master branch'
            } else {
                echo 'I execute elsewhere'
            }
        }
    }

    可以看到，Scripted Pipeline没那么多东西，就是定义一个node， 里面多个stage，里面就是使用Groovy语法执行各个step了，非常简单和清晰，也非常灵活。

    两种Pipeline比较

    Declarative Pipeline相对简单，而且不需要学习groovy语法，对于日常的一般任务完全够用， 而Scripted Pipeline可通过Groovy语言的强大特性做任何你想做的事情。

    转自：https://www.xncoding.com/2017/03/22/fullstack/jenkins02.html
  • 相关阅读:
    Linux 磁盘与文件系统管理
    mysql join
    iostat
    解决TIME_WAIT过多问题
    mysql 数据库性能追踪与分析
    CHECKPOINT
    DTRACE -MYSQL
    ORCLE INNODB 博客与 innodb_lru_scan_depth
    innodb 变量
    mysql博客
  • 原文地址：https://www.cnblogs.com/fuhai0815/p/8244038.html
Copyright © 2011-2022 走看看