Jenkins - How to get and use upstream info in downstream

ONLINECAST

2 min read

·

07-10-2024

5

0

Share

Jenkins: Passing Upstream Information Downstream

Jenkins is a powerful automation server widely used for continuous integration and continuous delivery (CI/CD). One common scenario involves multiple jobs, where a "downstream" job depends on the successful completion of an "upstream" job. This dependency often necessitates passing information from the upstream job to the downstream job for further processing.

Let's explore how to efficiently leverage this information flow in Jenkins.

Scenario: Building and Deploying a Project

Imagine a simple project where the upstream job builds a software application, and the downstream job deploys it to a server. The downstream job needs to know the version of the built artifact to deploy it correctly.

Upstream Job (Build)

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                script {
                    // Build the application and generate a version tag
                    def version = "1.0.0" 
                    sh "echo \"Building version ${version}\"" 
                    // Store the version in a global variable
                    build job: 'Deploy', parameters: [string(name: 'VERSION', value: version)]
                }
            }
        }
    }
}

Downstream Job (Deploy)

pipeline {
    agent any
    parameters {
        string(name: 'VERSION', defaultValue: '1.0.0', description: 'Application version')
    }
    stages {
        stage('Deploy') {
            steps {
                script {
                    // Retrieve the version parameter
                    def version = params.VERSION
                    sh "echo \"Deploying version ${version}\""
                    // Deployment logic using the version
                }
            }
        }
    }
}

Explanation and Insights

1. Passing Parameters: In the upstream job, we use the build job step with the parameters option. We define a string parameter called VERSION and pass the generated version value to the downstream job.

2. Retrieving Parameters: In the downstream job, we define a string parameter with the same name (VERSION). The params.VERSION expression allows us to access the value passed from the upstream job.

3. Environment Variables: Instead of parameters, you can also store information in environment variables within the upstream job and access them in the downstream job. For example, use env.VERSION = version in the upstream script and retrieve it using env.VERSION in the downstream job.

4. Triggering Downstream Jobs: Ensure the downstream job is triggered by the upstream job. You can achieve this by using the "Trigger parameterized build on other projects" option in the upstream job configuration.

Additional Considerations

• Shared Workspace: If both jobs need to access the same build artifacts, you can configure them to share a workspace. This way, the downstream job can directly access the artifacts generated by the upstream job.

• Build Artifacts: Store build artifacts in a central location (e.g., an artifact repository) so both jobs can access them independently of the workspace.

• Complex Information: For passing more complex information, consider using JSON objects or other structured formats. You can serialize the information in the upstream job and deserialize it in the downstream job.

Benefits of Information Passing

• Improved Dependency Management: Tightly couple the upstream and downstream jobs, ensuring consistency and reducing manual intervention.
• Dynamic Configuration: Adapt the downstream job's behavior based on information from the upstream job, achieving flexibility in your pipeline.
• Reduced Errors: Eliminate the risk of inconsistencies by automatically transferring critical information between jobs.

By understanding these methods and applying them appropriately, you can build robust and efficient CI/CD pipelines in Jenkins, effectively leveraging information from upstream jobs to streamline your development and deployment processes.