Continuous delivery jenkinsfile syntax

Realization Pipeline The functional scripting language is called Jenkinsfile, from Groovy Language implementation .Jenkinsfile It is usually placed in the project root directory , Controlled by source control software along with the project , There is no need to create " Free style \" Same project , You may need to copy many settings to a new project at a time , Provides some direct benefits ：

• Pipeline Code review on / iteration
• Pipeline Audit trail for
• Pipeline The only real source of , Can be viewed and edited by multiple members of the project Pipeline Support ：Declarative（ stay Pipeline 2.5 Introduction in ） and Scripted Pipeline Two formats . Both support the establishment of Pipeline, Both can be used in Web UI Define a pipeline in Jenkinsfile, take Jenkinsfile Creating and checking files into the source code control library is often considered a best practice .

Declared Pipeline

Declared Pipeline Trees

Declared Pipeline Must be included in fixed format Pipeline {} block , Each declaration statement must have a separate line , There is no need to use a semicolon at the end of the line . block （ blocks{} ） Only chapters can be included （Sections）, Instructions （Directives）, step （Steps） Or assignment statement .

block blocks{}

A statement enclosed in braces , Such as Pipeline{},Section{},parameters{},script{}

chapter （Sections）

A chapter usually contains one or more instructions or steps . Such as agent 、post、stages、steps

Instructions （Directives）

environment、options、parameters、triggers（ Trigger ）、stage、tools、when

node （agent）

There must be ,agent Must be in Pipeline The top level definition within the block , but stage It is optional whether to use in

Parameters ：any/none/label/node/docker/dockerfile

Common options label/cuetomWorkspace/reuseNode

Example ：

agent { label 'my-label' }

agent {
    node {
        label 'my-label'
        customWorkspace '/some/other/path'
    }
}

agent {
    docker {
        image 'nginx:1.12.2'
        label 'my-label'
        args '-v /tmp:/tmp'
    }
}

Copy

After construction （post）

It's not necessary , be used for Pipeline The outermost layer of or stage{} in , Mainly used to express Jenkins What needs to be done after the build action is completed .

Example ：

pipeline {
    agent any
    stages {
        stage('Example'){
            steps {
                echo 'Hello world'
            }
        }
    }
    post {
        always {
            echo 'say goodbay'
        }
    }
}

Copy

Stage set （stages）

There must be , Includes one or more that are executed sequentially stage command , stay Pipeline It can only be used once in the , Usually located in agent/options Back .

step （steps）

There must be ,steps be located stage Inside the instruction block , Include one or more step. There is only one step Keywords can be ignored if step And its {}.

Environmental Science （environment）

It's not necessary ,environment Defines a set of global environment variable key value pairs , Exist in pipeline {} perhaps stage In command . Perform special methods credentials() Can get Jenkins Document clear text content predefined in .

Example ：

environment {CC='clang'}
environment {AN_ACCESS_KEY = credentials('my-prefined-secret-text')}
steps {sh 'printenv'}

Copy

Options （options）

It's not necessary , predefined Pipeline Proprietary configuration information , Can only be defined once

Example ：

pipeline {
    agent any
    options{
        timeout(time:1,unit: 'HOURS')
    }
}

Copy

Parameters （parameters）

It's not necessary , Define the parameters of the parametric build optional parameters , Parameter type booleanParam,choice,file,text,password,run,string

Example ：

parameters {
        string(name: 'PERSON', defaultValue: 'Jenkins', description: ' Input text parameters ')
        choice(name: 'CHOICE', choices: ['One', 'Two', 'Three'], description: 'Pick something')
}

Copy

trigger （rtiggers）

It's not necessary , Definition Pipeline Automatically triggered mode options cron、pollSCM、upstream

Example ：

triggers {
       cron('0 8 * * 1-5')
}

Copy

Script Pipeline

Script Pipeline Statement tree

One Script Pipeline It can be divided into several Stage, Every Stage Represents a group of operations , for example Build,Test;Node representative Jenkins node , such as Master, Slave Such a node ;Step Is the most basic unit of operation , In the corresponding Node The action statements executed on the node are written directly in the node {} in .

Flow control statement

Simultaneous interpreting script language is the same as traditional script language. ,Script Pipeline It is executed from top to bottom , have access to Groovy Expression for process control , Such as if/else Statement controls the process through logical condition judgment ：

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

Copy

Exception handling statements

Script Pipeline Another way of script flow control is the exception handling mechanism . When any step is abnormal for various reasons , Must be used in code try/catch/finally Statement block for exception capture , And through the preset code for processing , Ensure that the script can execute smoothly ：

stage('Error Handling') {
    node{
        echo "This is test demo for the error handling"

        try {

            echo "This is in the try block."

            sh 'exit 1'

        }catch (exc) {

            echo "Something failed, I'm in the catch block."

        }finally {

            echo "Finally, I'm in the finally block."

        }
    }
}

Copy

Jenkinsfile Call in plugin function

stay Jenkinsfile In addition to using regular logic 、 Process control , You can also call Jenkins Plug in function of . The following examples are used to illustrate .

Email Extension plug-in unit

Email Extension yes Jenkins An external plug-in in , Used to send mail , from Jenkins Of Plugin Manager Installation in . stay Pipeline The operation of the plug-in can be triggered through code calls in , Realize the function of sending mail .

Basic configuration

After installation Email Extension After the plug-in , First, you need to select one to send Jenkins Email address of notification mail , The specific parameters of the email should be known in advance （ Generally, the parameters can be found on the configuration parameter information page of the mailbox ）; After that Manage Jenkins -> Configure System Fill the corresponding parameters in the corresponding configuration items of the plug-in , The parameters that must be configured are as follows ：

• SMTP server：smtp Service address
• SMTP port：smtp Port number
• Use SMTP Authentication： Enable smtp Security check
• User Name： Sender's user name
• Password： Sender's password
• Default Recipients： Default recipient Other parameters can be configured according to your own needs ,Email Extension The configuration reference screenshot is as follows ：

Pipeline Code

pipeline{
    agent {
        label 'master'
    }
    stages{
        stage(' Send email test ') {
            steps{
                echo 'Test Email'
            }
        }
    }
    post {
        always {
            emailext body: '$DEFAULT_CONTENT', recipientProviders: [[$class: 'RequesterRecipientProvider']], subject: '$DEFAULT_SUBJECT'
        }
    }
}

Copy