Question

I m trying to define a agent in a jenkinsfile once, but use it in multiple stages without needing to fully declare it for each stage. As can be seen, I am using a stage to figure out which docker image to use and then setting a global to use in the agent statement, which works fine and if I put the agent statement in each stage it works as desired. This however, seems ineffcient and not very maintainable if I need to modify the agent s args statement or similar. I want to do something similar to below:

def imageURI = ""
def myagent = docker {
    image "$imageURI"
    args "--user 1000:1000 --name ${env.BUILD_NUMBER}_${env.jobName}"
}
pipeline {
    agent none
    stages {
        stage ("Once use agent") {
            agent {
                docker {
                    image "python:3.5-apline"
                }
            }
            steps {
                script {
                    imageURI = sh "command to get image URI"
            }
        }
        stage ("Build" ) {
            agent = myagent
            steps {
                sh "build code"
            }
        stage ( "Run Unit Test" ) {
            parallel {
                stage ( "UT 1" ) {
                    agent = myagent
                    steps {
                        sh "run unit test 1"
                    }
                }
                stage ( "UT 2" ) {
                    agent = myagent
                    steps {
                        sh "run unit test 2"
                    }
                }
            }
        }
    }
}

Using suggestion from comment, I m getting farther. But now the agent s image string is getting evaluated before it s set. With below, I would need some way to set the image variable or a way to defer the variable s evaluation

def imageURI = ""
 
pipeline {
    agent {
        docker {
            image "$imageURI"
            args "--user 1000:1000 --name ${env.BUILD_NUMBER}_${env.jobName}"
        }
    }
    stages {
        stage ("Once use agent") {
            agent {
                docker {
                    image "python:3.5-apline"
                }
            }
            steps {
                script {
                    imageURI = sh "command to get image URI"
            }
        }
        stage ("Build" ) {
            steps {
                sh "build code"
            }
        stage ( "Run Unit Test" ) {
            parallel {
                stage ( "UT 1" ) {
                    steps {
                        sh "run unit test 1"
                    }
                }
                stage ( "UT 2" ) {
                    steps {
                        sh "run unit test 2"
                    }
                }
            }
        }
    }
}

Answer 1

As you correctly note, the variable evaluates when the pipeline begins its execution. To have it ready before your pipeline executes, you can run a combination of scripted and declarative pipeline. The way to do it is outlined in this answer which includes a working example and the output.

In your case, something like this will work:

def imageURI = null
echo "imageURI should be Null: $imageURI"


node() {
    stage("Define imageURI") {
        imageURI = sh "command to get image URI"
        echo "imageURI is now $imageURI"
    }
}

pipeline {
    agent {
        docker {
            image "$imageURI"
            args "--user 1000:1000 --name ${env.BUILD_NUMBER}_${env.jobName}"
        }
    }

Answer 2

In my case, many properties needed to be set for the docker agent, but the values for all of the properties were known before the pipeline started. And the docker agent needed to be used in multiple but not all stages. To avoid having to duplicate all the properties of the docker agent in multiple places, I defined the properties once in a buildAgentConfig() method that returns a map. Then within each stage, I defined agent blocks that used docker agents as docker(buildAgentConfig()). A simplified version of the final pipeline looked something like below:


pipeline {
    agent any

    stages {
        stage( Init ) {
            steps {
                sh    #!/bin/bash
                    some command
                   
            }
        }

        stage( test ) {
            agent {
                docker(buildAgentConfig())
            }
            steps {
                sh    #!/bin/bash
                   ./gradlew test
                   
            }
        }

        stage( build ) {
            when {
                anyOf {
                    branch  master 
                    branch  main 
                }
            }
            agent {
                docker(buildAgentConfig())
            }
            steps {
                sh    #!/bin/bash
                   ./gradlew build -x test
                   
            }
        }
    }
}

def buildAgentConfig() {
    [
        label:  somelabel ,
        image:  myprivateregistry.com/openjdk:11.0-jdk ,
        registryUrl:  myprivateregistry.com ,
        registryCredentialsId:  some-credentials-id ,
        args:  -v /var/lib/jenkins/.gradle/:/home/jenkins/.gradle/  +
                --env GRADLE_USER_HOME=/home/jenkins/.gradle/ 
        reuseNode: true,
    ]
}

友情链接