詹金斯 - ＆gt;循环槽Docker-Agent

Question

我想在 jenkins-pipeline中使用几个 docker-images 构建一些软件包 。下面的管道有效..但是我想实现阶段是一个更“循环”的方式。...

pipeline {
  
  agent { label 'docker' }

  stages {

    stage ('Running on ubuntu:20.04') {
      agent {
        docker {
          reuseNode true
          label 'docker'
          image 'ubuntu:20.04'
        }
      }

      steps {
        sh 'uname -a && bash --version'
      }
    }

    stage ('Running on ubuntu:22.04') {
      agent {
        docker {
          reuseNode true
          label 'docker'
          image 'ubuntu:22.04'
        }
      }
      steps {
        sh 'uname -a && bash --version'
      }
    }
  }
}

一个想法如何实施？ ..

最初，我尝试使用这样的东西

pipeline {
  agent { label 'docker' }

  stages {
    stage ('Loop-Stage') {
      steps {
        script {
     
          // Loop trough List (*works*)
          for (item in ['ubuntu:20.04', 'ubuntu:22.04']) {
            
            // Create new stage (*works*)
            stage ('Running on ${item}') {
              
              // Set agent (*fails*)
              agent {
                docker {
                  reuseNode true
                  label 'docker'
                  image "${item}"
                }
              }

              steps {
                sh 'uname -a && bash --version'
              }
            }
          }
        }
      }
    }
  }
}

，但现在确实有效。该错误似乎表明脚本化和声明语法之间的混合物。您会收到以下错误：

java.lang.NoSuchMethodError: No such DSL method 'agent' found among steps [ArtifactoryGradleBuild, MavenDescriptorStep, addInteractivePromotion, ansiColor, archive, artifactoryBuildTrigger, artifactoryDistributeBuild, artifactoryDownload, artifactoryEditProps, artifactoryGoPublish, ar

如何将相应的“代理”应用于动态生成的阶段？

Answer 1

当您进入脚本块时，您无法再使用一些声明语法，例如agent。这就是为什么您会收到错误java.lang.lang.nosuchmethoderror：没有这样的DSL方法'agent'。詹金斯（Jenkins）对您是否正在尝试使用声明的管道语法或仅使用Groovy的脚本语法感到困惑。

您可以做这样的事情。这将创建一个阶段列表，然后并行执行。

def stageList

def getStages(image) {
    return {
        stage("Running on Ubunt:${image}") {
          docker.image("ubuntu:${image}").inside {
                sh 'uname -a'
            }
        }
    }
}

pipeline {
agent any
  stages {
      
    stage ("Generate Stages") {
        steps {
            script {
                def imageList = ["20.04", "22.04"]
                stageList = imageList.collectEntries {
                        ["${it}" : getStages(it)]}
                    }
                
            }
        }

        stage("Run Stages") {
            steps {
                    script {
                        parallel stageList
                    }
                }
        }
        
    }
}

如果需要顺序执行，则可以修改管道，如下所示。

pipeline {
  agent { label 'docker' }

  stages {
    stage ('Loop-Stage') {
      steps {
        script {
     
          // Loop trough List (*works*)
          for (item in ['ubuntu:20.04', 'ubuntu:22.04']) {
            
            // Create new stage (*works*)
            stage ('Running on ${item}') {
              
            docker.image("${item}").inside {
                sh 'uname -a'
                sh 'uname -a && bash --version'
            }
            }
          }
        }
      }
    }
  }
}