对声明性管道阶段使用轻量级执行器（代理无）

Question

我正在使用声明性语法的Jenkins Pipeline，目前有以下阶段：

1. 准备
2. 构建（两组平行的步骤）
3. 测试（也是两组平行的步骤）
4. 询问是否/在何处部署
5. 部署

对于步骤1、2、3和5，我需要和代理（一个执行者），因为他们在工作区上做实际工作。对于步骤4，我不需要一个，并且我不希望在等待用户输入时阻止可用的执行器。对于经典的脚本语法，这似乎被称为“flyweight”或“lightweight”执行器，但我找不到任何关于如何使用声明性语法实现这一点的信息。

到目前为止，我已经尝试：

1. 直接在管道选项中设置代理，然后在舞台上设置agent none。这没有效果，管道以normalt运行，在等待输入时阻塞执行器。文档中也提到它不会有任何效果，但我想我还是要试一试

以下是我的Jenkins文件的概要：

pipeline {
    agent {
        label 'build-slave'
    }
    stages {
        stage("Prepare build") {
            steps {
                // ...
            }
        }
        stage("Build") {
            steps {
                parallel(
                    frontend: {
                        // ...
                    },
                    backend: {
                        // ...
                    }
                )
            }
        }
        stage("Test") {
            steps {
                parallel(
                    jslint: {
                        // ...
                    },
                    phpcs: {
                        // ...
                    },
                )
            }
            post {
                // ...
            }
        }
        stage("Select deploy target") {
            steps {
                script {
                    // ... code that determines choiceParameterDefinition based on branch name ...
                    try {
                        timeout(time: 5, unit: 'MINUTES') {
                            deployEnvironment = input message: 'Deploy target', parameters: [choiceParameterDefinition]
                        }
                    } catch(ex) {
                        deployEnvironment = null
                    }
                }
            }
        }
        stage("Deploy") {
            when {
                expression {
                    return binding.variables.get("deployEnvironment")
                }
            }
            steps {
                // ...
            }
        }
    }
    post {
        // ...
    }
}

我在这里遗漏了什么，还是在当前版本中不可能？

Answer 1

截至今天（2021年），您可以使用嵌套阶段（https://www.jenkins.io/doc/book/pipeline/syntax/#sequential-stages）对输入步骤之前必须在同一工作区中运行的所有阶段以及输入步骤之后必须在同一工作区中运行的所有阶段进行分组。当然，在输入步骤之前，您需要将工件隐藏或存储在某些外部存储库中，因为第二个工作区可能与第一个不同：

pipeline {
    agent none
    stages {
        stage('Deployment to Preproduction') { 
            agent any 
            stages {
                stage('Stage PRE.1') { 
                    steps {
                        echo "StagePRE.1"
                        sleep(10)
                    }
                }
                stage('Stage PRE.2') { 
                    steps {
                        echo "Stage PRE.2"
                        sleep(10)
                    }
                }
            }
        }
        stage('Stage Ask Deploy') { 
            steps {
                input message: 'Deploy to production?'
            }
        }
        stage('Deployment to Production') { 
            agent any 
            stages {
                stage('Stage PRO.1') { 
                    steps {
                        echo "Stage PRO.1"
                        sleep(10)
                    }
                }
                stage('Stage PRO.2') { 
                    steps {
                        echo "Stage PRO.2"
                        sleep(10)
                    }
                }
            }
        }
    }
}

Answer 2

有一种变通方法可以在其他阶段使用相同的构建从属。可以使用节点名设置变量，并在其他变量中使用它。

即：

pipeline {
    agent none
    stages {
        stage('First Stage Gets Agent Dynamically') {
            agent {
                node {
                    label "some-agent"
                }
            }
            steps {
                echo "first stage running on ${NODE_NAME}"
                script {
                  BUILD_AGENT = NODE_NAME
                }
            }
        }
        stage('Second Stage Setting Node by Name') {
            agent {
                node {
                    label "${BUILD_AGENT}"
                }
            }
            steps {
                echo "Second stage using ${NODE_NAME}"
            }
        }
    }
}

Answer 3

在顶层设置agent none，然后在每个阶段设置agent{label'foo'}，在input阶段再次设置agent none，这对我来说似乎是正常的。

即。每个执行某些工作的阶段都在同一个代理上运行，而输入阶段不使用任何代理上的执行器。

pipeline {
    agent none
    stages {
        stage("Prepare build") {
            agent { label 'some-agent' }
            steps {
                echo "prepare: ${pwd()}"
            }
        }
        stage("Build") {
            agent { label 'some-agent' }
            steps {
                parallel(
                    frontend: {
                        echo "frontend: ${pwd()}"
                    },
                    backend: {
                        echo "backend: ${pwd()}"
                    }
                )
            }
        }
        stage("Test") {
            agent { label 'some-agent' }
            steps {
                parallel(
                    jslint: {
                        echo "jslint: ${pwd()}"
                    },
                    phpcs: {
                        echo "phpcs: ${pwd()}"
                    },
                )
            }
        }
        stage("Select deploy target") {
            agent none
            steps {
                input message: 'Deploy?'
            }
        }
        stage("Deploy") {
            agent { label 'some-agent' }
            steps {
                echo "deploy: ${pwd()}"
            }
        }
    }
}

但是，不能保证在管道中使用相同的代理标签将始终使用相同的工作区，例如，当第一个生成等待输入时，作为同一作业的另一个生成。

在构建步骤之后，您必须使用stash。正如您所注意到的，这目前无法通过并行正常完成，因此您必须另外使用脚本块，以便在并行步骤之后/之前为隐藏/取消隐藏编写脚本管道的片段。