Jenkins 2 Pipelines - 如何为持续交付管道建模

Question

我对 Jenkins 2 管道完全陌生。

我曾使用 Jenkins 1 管道进行过以下操作：

你可以直接开始某个阶段，假设我可以选择运行ning从发布阶段开始，跳过测试。

我有一个非常简单的 Jenkins 2 管道定义：

stage('Preparation'){
    echo """
         Preparing
         something
         """
}
stage('Greeting') { 
    parallel 'hello1':{
        node{
            echo 'hello world 1'
        }
    }, 'hello2':{
        node{
            echo 'hello world 2'
        }
    }
}

在管道页面中，我有 "Build now"，其中运行是从准备开始的所有阶段。

我的问题是：

怎样才能运行自己喜欢的舞台？例如问候而不是从准备开始？
你如何定义阶段之间的依赖关系？我的意思是在另一个阶段完成后调用的阶段
有没有办法限制某个用户可以开始的阶段？想象一下，我只希望特定用户启动 Greeting 阶段。
如何设置手动阶段？

更新：我的问题背后的真正目标是持续交付管道的建模，如下面的詹金斯 2 个管道：

Build stage --> AUTO --> Acceptance Stage --> MANUAL --> Production Stage
                                          --> MANUAL --> QA Stage

这是我想要的行为：

构建阶段（任何用户都可以启动它）完成后会自动触发验收阶段。这个不能手动启动，只能在成功完成构建阶段后自动启动。

从验收阶段我需要只有授权用户才能手动触发QA阶段和生产阶段.

业务流程是：开发人员进入构建阶段，构建并打包其代码。验收阶段开始，使用打包好的代码运行一堆自动化测试

此时，当验收阶段完成 OK 时，可能会发生两件事：

可能需要 QA Stage 来运行更多测试（Cucumber、手册等）。一些授权用户会触发此阶段。
当产品负责人高兴时，他可以决定启动生产阶段以在生产环境中部署代码。

我正在努力使用 Jenkins 2 管道对此进行建模。

Answer 1

您的某些问题没有直接答案，但可以通过一些额外的编码来实现。虽然某些人可能会找到其他方法来实现，但让我尝试一下我的想法：

1) How can I run the stage I prefer? For instance Greeting instead of starting from Preparation?

这可以通过添加一个布尔参数 FASTFORWARD_TO_GREETING 来实现，而不是使用在执行构建时提供的值来操纵构建流程。所以你的代码现在看起来像：

if (FASTFORWARD_TO_GREETING == 'false') {
stage('Preparation'){
    echo """
         Preparing
         something
         """
}
}

stage('Greeting') { 
    parallel 'hello1':{
        node{
            echo 'hello world 1'
        }
    }, 'hello2':{
        node{
            echo 'hello world 2'
        }
    }
}


2) How do you define the dependencies between stages? I mean the stage called after another one completes

阶段是连续执行的，因此如果先定义阶段，它将先开始并完成，然后再进入下一阶段。但是在并行步骤中，这并不成立，因为所有步骤都将并行执行。因此，在您的示例代码中，您定义的依赖项是阶段 "Preparation" 将首先执行，而不是仅 "hello1" 和 "hello2" 步骤将并行执行。但是，无法保证将打印 "hello world1" 或 "hello world 2"。

3) Is there a way to limit the stages that a certain user can start? Imagine that I only want a specific user to launch the Greeting stage.

您可以在某个阶段之前进行手动批准步骤。例如，在您的代码中，您希望执行阶段 Preparation 并且希望它在执行阶段 Greeting 之前经过手动批准，您的代码将如下所示：

stage('Preparation'){
    echo """
         Preparing
         something
         """
}
stage concurrency: 1, name: 'approve-greeting'
input id: 'greeting-deploy', message: 'Proceed to Greeting?', ok: 'Deploy'

stage('Greeting') { 
    parallel 'hello1':{
        node{
            echo 'hello world 1'
        }
    }, 'hello2':{
        node{
            echo 'hello world 2'
        }
    }
}

这之后会发生什么，当你执行构建时，阶段准备将被执行，但之后作业将等待手动批准才能继续。在 Jenkins Pipeline 视图中，该阶段将被称为 "approve-greeting"，它会等到有人通过在视图中单击它来批准构建。

4) How do you setup manual stages?

我相信答案 3 中已经回答了这个问题？

如果您需要更多信息，请告诉我 information/explanation。

编辑:: 请在下面找到更多答案：

Build Stage (any user can start it) when it finishes it triggers automatically the Acceptance Stage.

很明显，构建阶段和验收阶段都将被定义为 Jenkins 管道中的正常阶段。所以你的代码会很简单，比如：

node {
    //define any variable here
    // Get source code from repo using checkout to directory say Whosebug
    // Get source code from repo for acceptance test using checkout to directory say Whosebug-test
    //Define any tool like Maven etc. location if required.
    dir('Whosebug') {
      stage name: 'build'
        //Do required steps
    }
    dir('Whosebug-test') {
      stage name: 'Acceptance'
        //Do required steps here 
    }

At this point, when Acceptance Stage has finished OK, two things can happen:

Maybe QA Stage is needed to run more tests (Cucumber, manual, etc.). Some some authorized user would fire this stage.

When the product owner is happy, he can decide to launch the Production Stage to deploy the code in a production environment.

你可以通过输入选项来做到这一点，所以在上面的代码之后你现在可以写：

    stage 'promotion'
      def userInput = input(
      id: 'userInput', message: 'Let\'s promote?', parameters: [
      [$class: 'BooleanParameterDefinition', defaultValue: false, description: 'Production', name: 'prod'],
      [$class: 'BooleanParameterDefinition', defaultValue: false, description: 'ManualQA', name: 'qa']
      ])
      echo ("Env: "+userInput['prod'])
      echo ("Target: "+userInput['qa'])

然后您可以从上面获取值并再次操纵流。喜欢：

如果 prod 的值为真，则进入 Production 阶段，如果 qa 的值为真，则继续 QA-Manual 阶段，就像我上面的 FASTFORWARD_TO_GREETING.

示例代码一样

编辑 2

评论区进一步回答问题：

1) How or where do I specify parameters like FASTFORWARD_TO_GREETING

像FASTFORWARD_TO_GREETING这样的参数将被定义为工作级别parameter

2) In the promotion stage you have to choose between ManualQA and Production. If the user chooses ManualQA it runs that Stage skipping Production. After it I want the user to be promted if he wants to promote to production stage. If you could provide a full definition of the pipeline it'd be great.

您可以在 MaualQA 阶段之后使用另一个输入步骤进行操作，但这次只使用一个参数。所以在 Promotion 阶段之后，会有 ManualQA 阶段，然后是下面的输入步骤：

def userInput1 = input(
 id: 'userInput', message: 'Let\'s promote?', parameters: [
 [$class: 'BooleanParameterDefinition', defaultValue: false, description: 'Production', name: 'prod']
])

3) How can I determine if a user has permissions to run a stage or not. Ideally I would like to do it based on roles

我不确定如何使用角色来做到这一点，但我相信任何具有管理员访问权限或运行该工作的人都可以访问 run/approve 那个阶段，但我不是 100% 确定如果可以以某种方式对其进行修改。

Answer 2

这是一个完整的持续交付管道，根据我从已接受的答案中获得的指示构建：

node{
    def user
    def userInput
    def mvnHome = tool 'M3'

    wrap([$class: 'BuildUser']) {
        user = env.BUILD_USER_ID
    }

    stage('Commit Stage'){
        echo 'Downloading from Git...'
        git 'https://github.com/codependent/spring-nio-rest.git'
        'Building project...'
        sh "${mvnHome}/bin/mvn clean install -DskipTests"
    }

    stage('Acceptance Stage') { 
        echo """
             Getting image from Nexus...OK
             Deploying image...OK
             Executing tests...OK
             """
        userInput = input(id: 'userInput', message: 'Select the next stage:', parameters: [
            [$class: 'BooleanParameterDefinition', defaultValue: false, description: 'Run QA tests', name: 'QA'],
            [$class: 'BooleanParameterDefinition', defaultValue: false, description: 'Run performance tests', name: 'performance']
        ])
    }

    if(userInput['QA']){
        stage('QA Stage') { 
         echo """
             Getting image from Nexus...OK
             Deploying image...OK
             Executing QA tests...OK
             """
        }
    }

    if(userInput['performance']){
        stage('Performance Stage') { 
         echo """
             Getting image from Nexus...OK
             Deploying image...OK
             Executing Performance tests...OK
             """
        }
    }

    stage('Production Stage') { 
        input message: 'Are you sure you want to deploy to Production?', submitter: 'codependent'
        echo 'Deploying to Production...OK'
    }
}

Jenkins 2 Pipelines - 如何为持续交付管道建模

Jenkins 2 Pipelines - How to model a continuous delivery pipeline

jenkins

continuous-delivery

jenkins-plugins

jenkins-pipeline

jenkins-2