Implicit vs explicit loading in Jenkins - Hands-On Comparison

Implicit vs Explicit Loading in Jenkins Pipeline

📖 Scenario: You are working on a Jenkins pipeline for a software project. You want to understand how to load shared libraries in Jenkins pipelines using implicit and explicit methods.

🎯 Goal: Build a Jenkins pipeline script that demonstrates both implicit and explicit loading of a shared library.

📋 What You'll Learn

Create a Jenkins pipeline script with a pipeline block

Use implicit loading of a shared library named utils

Use explicit loading of the same shared library utils

Call a function sayHello from the shared library in both cases

Print the outputs of the function calls

💡 Why This Matters

🌍 Real World

Jenkins shared libraries help reuse common pipeline code across many projects, improving maintainability and consistency.

💼 Career

Understanding implicit and explicit loading of shared libraries is essential for Jenkins pipeline developers and DevOps engineers to write modular and scalable pipelines.

1

Create a Jenkins pipeline with implicit library loading

Create a Jenkins pipeline script with a pipeline block. Use the @Library('utils') annotation to implicitly load the shared library named utils. Inside the stages, add a stage named Implicit Load that calls the function sayHello() from the library and stores the result in a variable called implicitResult.

Jenkins

@Library('utils') _

pipeline {
    agent any
    stages {
        stage('Implicit Load') {
            steps {
                // Your code here
            }
        }
    }
}

Hint

Use @Library('utils') annotation at the top and call sayHello() inside a script block.

2

Add explicit loading of the shared library

Add a variable called utilsLib that explicitly loads the shared library utils using the library step. Call the sayHello() function inside a new stage named Explicit Load and store the result in a variable called explicitResult.

Jenkins

@Library('utils') _

pipeline {
    agent any
    stages {
        stage('Implicit Load') {
            steps {
                script {
                    def implicitResult = sayHello()
                    env.implicitResult = implicitResult
                }
            }
        }
        stage('Explicit Load') {
            steps {
                script {
                    // Your code here
                }
            }
        }
    }
}

Hint

Use def utilsLib = library('utils') to explicitly load the library, then call sayHello() on the loaded library object.

3

Combine implicit and explicit results

Inside the script block of the Explicit Load stage, create a new variable called combinedResult that concatenates env.implicitResult and explicitResult separated by a comma and a space.

Jenkins

@Library('utils') _

pipeline {
    agent any
    stages {
        stage('Implicit Load') {
            steps {
                script {
                    def implicitResult = sayHello()
                    env.implicitResult = implicitResult
                }
            }
        }
        stage('Explicit Load') {
            steps {
                script {
                    def utilsLib = library('utils')
                    def explicitResult = utilsLib.sayHello()
                    // Your code here
                }
            }
        }
    }
}

Hint

Use string concatenation with env.implicitResult + ", " + explicitResult to combine the two variables.

4

Print the combined result

Add a println statement inside the Explicit Load stage's script block to print the combinedResult variable.

Jenkins

@Library('utils') _

pipeline {
    agent any
    stages {
        stage('Implicit Load') {
            steps {
                script {
                    def implicitResult = sayHello()
                    env.implicitResult = implicitResult
                }
            }
        }
        stage('Explicit Load') {
            steps {
                script {
                    def utilsLib = library('utils')
                    def explicitResult = utilsLib.sayHello()
                    def combinedResult = env.implicitResult + ", " + explicitResult
                    // Your code here
                }
            }
        }
    }
}

Hint

Use println(combinedResult) to display the combined message.

Practice

1. What is the main difference between implicit and explicit loading of shared libraries in Jenkins pipelines?

easy

A. Implicit loading loads libraries from GitHub, explicit loads from local files.

B. Implicit loading requires manual script calls, explicit loading is automatic.

C. Implicit loading is only for scripted pipelines, explicit is for declarative pipelines.

D. Implicit loading uses the @Library annotation, explicit uses the library() step.

Solution

1. Step 1: Understand implicit loading

   Implicit loading uses the @Library annotation at the top of the Jenkinsfile to automatically load shared libraries.

2. Step 2: Understand explicit loading

   Explicit loading uses the library() step inside the pipeline script to load libraries manually when needed.

3. Final Answer:

   Implicit loading uses the @Library annotation, explicit uses the library() step. -> Option D

4. Quick Check:

   Implicit = @Library, Explicit = library() [OK]

Hint: Remember: @Library is automatic, library() is manual [OK]

Common Mistakes:

• Confusing which method is automatic
• Thinking explicit loading is automatic
• Mixing up syntax of @Library and library()
• Assuming implicit loading requires code inside pipeline

2. Which of the following is the correct syntax for implicit loading of a shared library named 'utils' in a Jenkinsfile?

easy

A. library('utils')

B. @Library('utils') _

C. loadLibrary('utils')

D. import 'utils'

Solution

1. Step 1: Recall implicit loading syntax

   Implicit loading uses the @Library('libraryName') _ annotation at the top of the Jenkinsfile.

2. Step 2: Check options for correct syntax

   @Library('utils') _ matches the correct syntax: @Library('utils') _. Others are incorrect or invalid in Jenkins.

3. Final Answer:

   @Library('utils') _ -> Option B

4. Quick Check:

   Implicit loading = @Library('name') _ [OK]

Hint: Implicit loading always starts with @Library and ends with underscore [OK]

Common Mistakes:

• Using library() instead of @Library for implicit loading
• Missing the underscore after @Library annotation
• Using import or loadLibrary which are invalid
• Placing @Library inside pipeline steps

3. Given the Jenkinsfile snippet below, what will be the output if the shared library 'mathLib' has a function add(a, b) that returns the sum?

@Library('mathLib') _
pipeline {
  agent any
  stages {
    stage('Add') {
      steps {
        script {
          def result = add(3, 4)
          echo "Sum is ${result}"
        }
      }
    }
  }
}

medium

A. Sum is 7

B. Error: add() function not found

C. Sum is 34

D. Pipeline fails to load

Solution

1. Step 1: Identify loading method

   The Jenkinsfile uses implicit loading with @Library('mathLib') _, so the library functions are available automatically.

2. Step 2: Understand function call and output

   The add(3, 4) function returns 7, so the echo prints "Sum is 7".

3. Final Answer:

   Sum is 7 -> Option A

4. Quick Check:

   Implicit loading allows direct function use = Sum is 7 [OK]

Hint: Implicit loading lets you call library functions directly [OK]

Common Mistakes:

• Assuming add() is undefined without explicit library() call
• Confusing string concatenation with addition
• Thinking pipeline fails due to missing library
• Ignoring the underscore after @Library

4. You have this Jenkins pipeline snippet:

pipeline {
  agent any
  stages {
    stage('Load Lib') {
      steps {
        script {
          @Library('toolsLib') _
          def result = toolFunc()
          echo "Result: ${result}"
        }
      }
    }
  }
}

What is the problem with this code?

medium

A. The @Library annotation cannot be used inside the script block.

B. The library name 'toolsLib' is invalid syntax.

C. The function toolFunc() must be called with library() step.

D. The echo statement is missing parentheses.

Solution

1. Step 1: Check usage of @Library annotation

   The @Library annotation must be placed at the top of the Jenkinsfile, not inside script blocks or stages.

2. Step 2: Identify error cause

   Using @Library inside the script block causes a syntax error; explicit loading with library() should be used inside scripts.

3. Final Answer:

   The @Library annotation cannot be used inside the script block. -> Option A

4. Quick Check:

   @Library only at top, not inside script [OK]

Hint: Put @Library only at the top of Jenkinsfile [OK]

Common Mistakes:

• Placing @Library inside pipeline steps
• Confusing explicit and implicit loading syntax
• Assuming library() is optional inside script
• Ignoring syntax error from misplaced annotation

5. You want to load two shared libraries in a Jenkins pipeline: 'libA' implicitly and 'libB' explicitly. Which Jenkinsfile snippet correctly achieves this?

hard

A. @Library('libB') _
pipeline {
agent any
stages {
stage('Use LibA') {
steps {
script {
library('libA')
libAFunc()
libBFunc()
}
}
}
}
}

B. pipeline {
agent any
stages {
stage('Use LibA and LibB') {
steps {
script {
library('libA')
library('libB')
libAFunc()
libBFunc()
}
}
}
}
}

C. @Library('libA') _
pipeline {
agent any
stages {
stage('Use LibB') {
steps {
script {
library('libB')
libBFunc()
}
}
}
}
}

D. @Library('libA') _
@Library('libB') _
pipeline {
agent any
stages {
stage('Use Both') {
steps {
script {
libAFunc()
libBFunc()
}
}
}
}
}

Solution

1. Step 1: Understand implicit and explicit loading together

   Implicit loading uses @Library('libA') _ at the top. Explicit loading uses library('libB') inside the script block.

2. Step 2: Check each option for correct usage

   @Library('libA') _ pipeline { agent any stages { stage('Use LibB') { steps { script { library('libB') libBFunc() } } } } } correctly uses implicit loading for 'libA' and explicit loading for 'libB' inside the script block. Others misuse annotations or load both explicitly or implicitly incorrectly.

3. Final Answer:

   @Library('libA') _ at top (implicit for libA), library('libB') inside script (explicit for libB) -> Option C

4. Quick Check:

   Implicit @Library top, explicit library() inside script [OK]

Hint: Implicit @Library top, explicit library() inside script block [OK]

Common Mistakes:

• Using multiple @Library annotations for explicit loading
• Calling library() outside script block
• Loading both libraries only explicitly or only implicitly
• Misplacing annotations inside pipeline stages