jenkins pipeline基礎語法與示例

一、Jenkins介紹

 
 

 
 

二、Jenkins Pipeline介紹

Jenkins Pipeline總體介紹

1.Pipeline 是Jenkins 2.X核心特性,幫助Jenkins實現從CI到CD與DevOps的轉變
2.Pipeline 簡而言之,就是一套運行於Jenkins上的工作流框架,將原本獨立
運行於單個或者多個節點的任務連接起來,實現單個任務難以完成的複雜流
程編排與可視化。

什麼是Jenkins Pipeline

1.Jenkins Pipeline是一組插件,讓Jenkins可以實現持續交付管道的落地和實施。
2.持續交付管道(CD Pipeline)是將軟件從版本控制階段到交付給用戶或客戶的完
整過程的自動化表現。
3.軟件的每一次更改(提交到源代碼管理系統)都要經過一個複雜的過程才能被髮布。

  1. Pipeline提供了一組可擴展的工具,通過Pipeline Domain Specific Language
    (DSL) syntax可以達到Pipeline as Code的目的
  2. Pipeline as Code:Jenkinsfile 存儲在項目的源代碼庫

Why Pipeline?

本質上,Jenkins 是一個自動化引擎,它支持許多自動模式。 Pipeline向Jenkins中添加了一組強大的工具, 支持用例 簡單的CI到全面的CD pipeline。通過對一系列的相關任務進行建模, 用戶可以利用pipeline的很多特性:

• 代碼:Pipeline以代碼的形式實現,通常被檢入源代碼控制,使團隊能夠編輯,
審查和迭代其CD流程。
• 可持續性:Jenkins重啓或者中斷後都不會影響Pipeline Job。
• 停頓:Pipeline可以選擇停止並等待人工輸入或批准,然後再繼續Pipeline運行。
• 多功能:Pipeline支持現實世界的複雜CD要求,包括fork/join子進程,循環和
並行執行工作的能力。
• 可擴展:Pipeline插件支持其DSL的自定義擴展以及與其他插件集成的多個選項。

Pipeline與freestyle區別

 
 

1.Job調度方式
pipeline:通過結構化pipeline 語法進行調度,易於理解與閱讀
freestyle:通過jenkins api或者cli進行調度

2.Job顯示形式
pipline:提供上帝視角(全局視圖)
freestyle:沒有視圖

Jenkins Pipeline 基礎語法

官網鏈接:https://jenkins.io/doc/

Pipeline 支持兩種語法

1.聲明式(jenkins2.5新加入的語法)


 
 

特點:
1.最外層必須由pipline{ //do something }來進行包裹
2.不需要分好作爲分隔符,每個語句必須在一行內
3.不能直接使用groovy語句(例如循環判斷等),需要被script {}包裹

2.腳本式


 
 

特點:
1.最外層有node{}包裹
2.可直接使用groovy語句

Declarative Pipeline(聲明式)核心概念

核心概念用來組織pipeline的運行流程

1.pipeline :聲明其內容爲一個聲明式的pipeline腳本
2.agent:執行節點(job運行的slave或者master節點)
3.stages:階段集合,包裹所有的階段(例如:打包,部署等各個階段)
4.stage:階段,被stages包裹,一個stages可以有多個stage
5.steps:步驟,爲每個階段的最小執行單元,被stage包裹
6.post:執行構建後的操作,根據構建結果來執行對應的操作

根據上面幾個概念就能夠輕易的創建一個簡單的pipeline

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

下面針對幾個核心概念,逐一進行說明

1.pipeline

作用域:應用於全局最外層,表明該腳本爲聲明式pipeline
是否必須:必須
參數:無

2.agent

作用域:可用在全局與stage內
是否必須:是,
參數:any,none, label, 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也是能夠展現在視圖裏面的


 
 

4.stage

作用域:被stages包裹,作用在自己的stage包裹範圍內
是否必須:必須
參數:需要一個string參數,表示此階段的工作內容
備註:stage內部可以嵌套stages,內部可單獨制定運行的agent

5.steps

作用域:被stage包裹,作用在stage內部
是否必須:必須
參數:無

6.post

作用域:作用在pipeline結束後者stage結束後
條件:always、changed、failure、success、unstable、aborted

Declarative Pipeline(聲明式)指令

指令是幫助pipeline更容易的執行命令,可以理解爲一個封裝好的公共函數和方法,提供給pipeline使用

1.environment:聲明一個全局變量或者步驟內部的局部變量

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

2.options: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() }

備註:當options作用在stage內部的時候,可選的只能是跟stage相關的選項(skipDefaultCheckout、timeout、retry、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.parameters:提供pipeline運行的參數

  • 作用域:被最外層pipeline所包裹,並且只能出現一次,參數可被全局使用
  • 好處:使用parameters好處是能夠使參數也變成code,達到pipeline as code,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.triggers:觸發器是自動化運行pipeline的方法

  • 作用域:被pipeline包裹,在符合條件下自動觸發pipeline

目前包含三種自動觸發的方式:
第一種:cron

  • 作用:以指定的時間來運行pipeline
  • 用法:triggers { cron('*/1 * * * *') }

第二種: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."
            }
        }
    }
}

看下效果


 
 

7.when:根據when指令的判斷結果來決定是否執行後面的階段

可選條件

  • branch :判斷分支名稱是否符合預期
    用法:when { branch 'master' }
  • environment : 判斷環境變量是否符合預期
    用法:when { environment name: 'DEPLOY_TO', value: 'production' }
  • expression:判斷表達式是否符合預期
    用法:when { expression { return params.DEBUG_BUILD } }
  • not : 判斷條件是否爲假
    用法:when { not { branch 'master' } }
  • allOf:判斷所有條件是不是都爲真
    用法:when { allOf { branch 'master'; environment name: 'DEPLOY_TO', value: 'production' } }
  • anyOf:判斷是否有一個條件爲真
    用法: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'
            }
        }
    }
}

並行執行

通過將階段設置爲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"
                    }
                }
            }
        }
    }
}

腳本

在聲明式的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'
                        
                    }
                }
            }
        }
    }
}


作者:MR_Hanjc
鏈接:https://www.jianshu.com/p/f1167e8850cd
來源:簡書
著作權歸作者所有。商業轉載請聯繫作者獲得授權,非商業轉載請註明出處。
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章