jenkins☞002Pipelines

阅读量: zyh 2021-01-16 20:07:13
Categories: > Tags:

前言

纯图形化的配置,并不能很有效的支撑自动化,也不灵活,一般jenkins的工程会通过Jenkinsfile来配置pipeline。

pipeline 有声明和脚本两种方式,声明式官方比较推荐。当然声明也可以嵌入脚本。

最后,脚本语言采用groovy语言编写。

关于groovy的语法,可以简单的看看https://www.w3cschool.cn/groovy/

流水线语法

基本流程如下:
Jenkins工程 => scm git => Jenkinsfile => pipeline

声明式语法

agent

用于指明运行程序的节点

可用参数:

pipeline {
    agent {
        node {
        	label "master" //指定【运行节点】的标签或者名称
        	customWorkspace "${workspace}"
        }
    }
    stages {
        stage {
            steps {
                pass
            }
        }
    }
    post {
        always {
            pass
        }
    }
}
agent {
    node {
        label "master" //指定【运行节点】的标签或者名称
        customWorkspace "${workspace}"
    }
}

stages

运行阶段,包含多个阶段,每个阶段包含步骤所需的代码

pipeline {
    agent any
    stages {
        stage(){
            steps {
                pass
            }
        }
    }
}

post

根据stages运行状态,执行后续处理的代码

可用状态:

pipeline {
    agent any
    stages {
        stage {
            pass
        }
    }
    post {
        always {
            pass
        }
    }
}

除了上面的三大块,在agent后,你还可以添加一些额外的

environment

环境变量

pipeline {
    agent
    environment {
        key = "123456"
    }
}

options

配置特定于流水线的选项

pipeline {
	agent any
	options {
    	timeout(time: 1, unit: 'HOURS') 
	}
	stages {
    	stage('Example') {
        	steps {
            	echo 'Hello World'
        	}
    	}
	}
}

parameters

添加一些参数,比较特殊的是,参数只有流水线运行一次后,才可以在web图形化里看到相关的配置

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

触发器

triggers { upstream(upstreamProjects: 'job1,job2', threshold: hudson.model.Result.SUCCESS) }
pipeline {
    agent any
    triggers {
        cron('H */4 * * 1-5')
    }
    stages {
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
}

tools

获取通过自动安装或手动放置工具的环境变量。支持maven/jdk/gradle。工具的名称必须在系统设置->全局工具配置中定义。

示例:

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

input

input用户在执行各个阶段的时候,由人工确认是否继续进行。

示例:

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."
            }
        }
    }
}

when

when 指令允许流水线根据给定的条件决定是否应该执行阶段。 when 指令必须包含至少一个条件。 如果when 指令包含多个条件, 所有的子条件必须返回True,阶段才能执行。 这与子条件在 allOf 条件下嵌套的情况相同。

内置条件

示例:

pipeline {
    agent any
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            when {
                branch 'production'
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}
pipeline {
    agent any
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            when {
                branch 'production'
                environment name: 'DEPLOY_TO', value: 'production'
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}
pipeline {
    agent any
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            when {
                allOf {
                    branch 'production'
                    environment name: 'DEPLOY_TO', value: 'production'
                }
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}
pipeline {
    agent any
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            when {
                branch 'production'
                anyOf {
                    environment name: 'DEPLOY_TO', value: 'production'
                    environment name: 'DEPLOY_TO', value: 'staging'
                }
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}
pipeline {
    agent any
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            when {
                expression { BRANCH_NAME ==~ /(production|staging)/ }
                anyOf {
                    environment name: 'DEPLOY_TO', value: 'production'
                    environment name: 'DEPLOY_TO', value: 'staging'
                }
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}
pipeline {
    agent none
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            agent {
                label "some-label"
            }
            when {
                beforeAgent true
                branch 'production'
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}

parallel

声明式流水线的阶段可以在他们内部声明多隔嵌套阶段, 它们将并行执行。 注意,一个阶段必须只有一个 steps 或 parallel的阶段。 嵌套阶段本身不能包含 进一步的 parallel 阶段, 但是其他的阶段的行为与任何其他 stageparallel的阶段不能包含 agenttools阶段, 因为他们没有相关 steps

另外, 通过添加 failFast true 到包含parallelstage中, 当其中一个进程失败时,你可以强制所有的 parallel 阶段都被终止。

示例:

pipeline {
    agent any
    stages {
        stage('Non-Parallel Stage') {
            steps {
                echo 'This stage will be executed first.'
            }
        }
        stage('Parallel Stage') {
            when {
                branch 'master'
            }
            failFast true  // 如果第一个stage失败,则后续stage不再执行
            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"
                    }
                }
            }
        }
    }
}