jenkins pipeline基础语法与示例

泰勒熊_Hot
342 阅读8分钟

一、Jenkins介绍

1.jenkins是什么？

jenkins是一款开源的CI&CD软件，是基于Java开发的一种持续集成、交付、部署的基于web界面的平台。用于自动化各种任务，包括构建、测试、和部署软件。

jenkins还支持各种运行方式，可通过系统包，Docker或通过一个独立的Java程序

二、Jenkins Pipeline

1.什么是jenkins pipeline？

jenkins pipeline是运行在jenknis 2.x版本的核心插件，简单来说pipeline就是一套运行于jenkins上的工作流框架，将原本独立运行于单个或者多个节点的任务连接起来，实现单个任务难以完成的复杂发布流程，从而实现单个任务很难实现的复杂流程编排和任务可视化，Pipeline的实现方式是一套Groovy DSL，任何发布流程都可以表述为一段Groovy脚本。

2.jenkins pipeline语法

2.1.怎样理解jenkins pipeline？

jenkins pipeline是一种软件开发过程中自动化构建、测试和部署代码的方法。在pipeline中，每个步骤通常由一个或多个自动化工具或脚本组成，它们相互协作以完成整个流程。

pipeline通常使用一种特定的语法来定义每个步骤，这种语法可以是文本形式、图形形式或其他形式。

2.2.pipeline的特性

  • 可持续性：jenkins的重启或中断后不影响已经执行的pipeline job
  • 支持暂停：pipeline可以选择停止并等待管理员输入“yes或执行”等字眼，批准后在继续执行。
  • 可扩展：通过groovy的编程更容易的扩展插件。
  • 并行执行：通过groovy脚本可以实现step，stage间的并行执行，和更复杂的相互依赖关系。

Jenkinsfile（jenkins流水线脚本文件的名称，用于定义jenkins pipeline的构建，测试、和部署过程） 能使用两种语法进行编写 - 声明式和脚本化；本文趋向于对声明式语法的基础使用

2.3.pipeline（声明式）核心概念

  • pipeline：声明其内容是一个声明式的pipeline脚本
  • agent：
  • 执行节点（job运行的slave或者master节点）
  • stages：阶段集合，由多个stage构成，包含所有的stage（例如打包，部署等各个阶段）
  • stage：阶段，被stages包含（用shell来说是嵌套）在里面，一个stages可以包含多个stage
  • steps：步骤，是stage的最小执行单元，被stage包含
  • post：可定义一个或多个steps执行构建后的操作，根据构建结果来执行对应的操作

下面是一个简单的pipeline示例

pipeline{
    agent any
    stages{
        stage("first stage"){
            steps("first steps"){
                echo "this is first step"
            }
        }
    }
    post{
        always{
            echo "this is ending..."
        }
    }
}

2.4.pipeline语法

1.pipeline

所处位置：应用于全局最外层，表明该脚本是一个声名式的pipeline

参数：无参数

是否为必写项：是

2.agent

所处位置：可以在全局定义（执行节点），也可以在stage内定义（执行节点）

参数：any，none，lable，node，docker，dockerfile

是否为必写项：是

示例：

pipeline{
    agent any  //全局必须带有agent表明此pipeline执行节点
    stages{
        stage("first stage"){
            agent { label 'master' }  //具体执行的步骤节点，非必须
            steps{
                echo "this is first step"
            }
        }
    }
}

参数示例：

//运行在任意的可用节点上
agent any

//全局不指定运行节点，由各自stage来决定
agent none

//运行在指定标签的机器上,具体标签名称由agent配置决定
agent { label 'master' }

//node参数可以扩展节点信息
agent { 
     node {
         label 'master'
         customWorkspace 'xxx'
    } 
}

//使用指定运行的容器
agent { docker 'python'  }

3.stages

所处位置：全局或者stage阶段内，每个作用域内只能使用一次

参数：无

是否为必写项：在全局配置里为必写项

示例：

pipeline{
    agent any
    stages{
        stage("first stage"){
            stages{  //嵌套在stage里
                stage("inside"){
                    steps{
                        echo "inside"
                    }
                }
            }
        }
        stage("stage2"){
            steps{
                echo "outside"
            }
        }
    }
}

看下运行结果,发现嵌套的stage也是能够展现在视图里面的:
images.png
4.stage

所处位置：被stages包含

参数：无

是否为必选项：是

注:stage内部可以嵌套stages

5.steps

所处位置：被stage包含，用于执行steps里的命令或操作

是否为必选项：是

参数：无

6.post 当jenkinsfile中stage的执行结果发生异常就可以使用post{}来处理； post{}可以根据执行结果的特定状态来作为触发的条件，然后在此条件之后声明steps操作即可

所处位置：作用在pipeline结束后；也就是构建后的操作，根据pipeline或stage的结果预先定义多个条件

是否为必选项：否

post{}支持的条件预置：

参考地址：（Jenkins pipeline 3 -- post 部分-腾讯云开发者社区-腾讯云 (tencent.com)）

示例：

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

2.4.pipeline（声明式）指令

1.environment

声明一个全局变量或者步骤内部的局部变量

pipeline{
    agent any
    environment {
        P1="parameters 1"
    }
    stages{
        stage("stage2"){
            environment {
                P2="parameters 2"
            }
            steps{
                echo "$P1"
                echo "$P2"
            }
        }
    }
}
2.options

能够提供给脚本更多的选项

  • buildDiscarder:指定build history与console的保存数量
    用法：options { buildDiscarder(logRotator(numToKeepStr: '1')) }

  • disableConcurrentBuilds：设置job不能够同时运行
    用法：options { disableConcurrentBuilds() }

  • skipDefaultCheckout：跳过默认设置的代码check out
    用法：options { skipDefaultCheckout() }

  • skipStagesAfterUnstable:一旦构建状态变得UNSTABLE，跳过该阶段
    用法：options { skipStagesAfterUnstable() }

  • checkoutToSubdirectory:在工作空间的子目录进行check out
    用法：options { checkoutToSubdirectory('children_path') }

  • timeout:设置jenkins运行的超时时间，超过超时时间，job会自动被终止
    用法：options { timeout(time: 1, unit: 'MINUTES') }

  • retry :设置retry作用域范围的重试次数
    用法：options { retry(3) }

  • timestamps:为控制台输出增加时间戳
    用法：options { timestamps() }

示例

pipeline{
    agent any
    options {
       timestamps() 
       disableConcurrentBuilds()
        
    }
    stages{
        
        stage("stage1"){
            options { timeout(time:1,unit:'MINUTES') 
                        retry(2)
            }
            steps{
                echo "beging===================="
                sh "xxx.sh"
            }
        }   
    }
}
3.partametes

提供pipeline运行的参数

所处位置：位于全局pipeline下方，只能出现一次，参数可被全局使用

作用：pipeline设置的参数会自动在job构建的时候生成，形成参数化构建

示例：

pipeline{
    agent any
    parameters {
        string(name: 'P1', defaultValue: 'it is p1', description: 'it is p1')
        booleanParam(name: 'P2', defaultValue: true, description: 'it is p2')
    }
    stages{
        stage("stage1"){
            steps{
                echo "$P1"
                echo "$P2"
            }
        }
    }
}

自动生成构建的参数:
自动生成构建的参数

4.trigges：触发器

是自动化运行pipeline的方法

所处位置：被pipeline包含，复合条件自动触发pipeline

三种自动触发方式：

  • cron：就是以指定的时间来运行pipeline
    用法：trigggers { cron ('*/1 * * * *')} #表示每分钟运行一次pipeline

  • pollSCM：以固定的时间检查代码仓库更新（或当代码仓库有更新时），自动触发pipeline构建
    用法：triggers { pollSCM('H */4 * * 1-5') }或者triggers { pollSCM() }（后者需要配置post-commit/post-receive钩子）

  • upstream：利用上游job的运行状态来进行触发
    用法：triggers { upstream(upstreamProjects: 'job1,job2', threshold: hudson.model.Result.SUCCESS) }

示例
pipeline{
   agent any
   //说明：当test_8或者test_7运行成功的时候，自动触发
   triggers { upstream(upstreamProjects: 'test_8,test_7', threshold: hudson.model.Result.SUCCESS) }
   stages{
       stage("stage1"){
           steps{
               echo "hello"
           }
       }
   }
}
5.tools

用于引用配置好的工具
注：引用的工具需要在管理页面的全局工具配置里配置过

示例：

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

input指令允许暂时中断pipeline执行，等待用户或管理员输入进行下一步动作

示例：

pipeline {
    agent any
    stages {
        stage('Example') {
            input {
                message "Should we continue?"
                ok "Yes, we should."
                submitter "alice,bob"
                parameters {
                    string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')
                }
            }
            steps {
                echo "Hello, ${PERSON}, nice to meet you."
            }
        }
    }
}

效果：

image.png

7.when

根据when指令的判断结果来决定是否执行后面的阶段（相当于shell脚本里的“if[]”判断）
可选条件：

  • branch：判断分支名称是否正确
    用法： when { branch 'master'} //判断pipeline运行的jib是否为'master'

  • environment：判断环境变量是否符合预期
    用法：when { environment name: 'DEPLOY_TO', value: 'production' }

  • expression：判断表达式是否符合预期
    用法：when { expression { return params.DEBUG_BUILD } }

  • not : 判断条件是否为假,,相当于shell脚本里的“if [ ! -eq 0 ] ”
    用法: when { not { branch 'master' } }

  • allOf：判断所有条件是不是都为真
    用法：when { anyOf { branch 'master'; branch 'staging' } }
    如果想要在进入agent之前进行判断，需要将beforeAgent设置为true 

示例：
pipeline {
    agent none
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            agent {
                label "some-label"
            }
            when {
                beforeAgent true //设置先对条件进行判断，符合预期才进入steps
                branch 'production'
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}
8.并行执行

:通过在stage阶段里设置'parallel{}'来表示该stage为并行运行
但是注意一下几点：

  • 一个stage只能有一个steps或者parallel

  • 嵌套的stages里不能使用parallel

  • parallel不能包含agent或者tools

  • 通过设置failFast 为true表示：并行的job中如果其中的一个失败，则终止其他并行的stage

pipeline {
    agent any
    stages {
        stage('Non-Parallel Stage') {
            steps {
                echo 'Non-parallel'
            }
        }
        stage('Parallel Stage') {
            agent any
            failFast true
            parallel {
                stage('parallel 1') {
                    agent any
                    steps {
                        echo "parallel 1"
                    }
                }
                stage('parallel 2') {
                    steps {
                        echo "parallel 2"
                    }
                }
            }
        }
    }
}
9.在pipeline运用shell脚本

在声明式的pipeline中默认无法使用脚本语法，但是pipeline提供了一个脚本环境入口：script{},通过使用script来包裹脚本语句，即可使用脚本语法

  • 条件判断：
pipeline {
    agent any
    stages {
        stage('stage 1') {
            steps {
                script{
                    if ( "1" =="1" ) {
                        echo "lalala"
                    }else {
                        echo "oooo"
                    }
                }
            }
        }
    }
}
  • 异常处理：
pipeline {
    agent any
    stages {
        stage('stage 1') {
            steps {
                script{
                    try {
                        sh 'exit 1'
                    }
                    catch (exc) {
                        echo 'Something failed'
                        
                    }
                }
            }
        }
    }
}

注：本文主要参考了jenkins pipeline基础语法与示例 - 简书 (jianshu.com)

avatar
文章
阅读
粉丝