intermediategeneral

What are Jenkins shared libraries and how do they promote code reuse?

⚡

Quick Answer

Jenkins shared libraries are reusable Groovy code repositories that can be loaded into any pipeline, allowing teams to define common build steps, deployment logic, and utility functions once and share them across multiple Jenkinsfiles and projects.

Detailed Answer

Imagine a company with dozens of kitchens, each preparing different dishes. Instead of every kitchen independently figuring out how to make the same base sauces, the company creates a central recipe book that all kitchens reference. When the recipe for a sauce improves, every kitchen benefits immediately. Jenkins shared libraries work the same way: they provide a centralized repository of reusable pipeline code that all your projects can reference, ensuring consistency and reducing duplication across your CI/CD pipelines.

A Jenkins shared library is a Git repository with a specific directory structure containing Groovy source code. The structure includes a vars directory for global pipeline steps, a src directory for more complex class-based code, and a resources directory for non-Groovy files like shell scripts or configuration templates. Files in the vars directory define custom pipeline steps that can be called directly by name in any Jenkinsfile, while the src directory follows standard Java package conventions and allows you to create utility classes, data models, and complex logic. Libraries are configured in Jenkins under Manage Jenkins and then Configure System, or they can be loaded dynamically in a Jenkinsfile using the library step.

Internally, when a pipeline references a shared library, Jenkins clones the library repository at the specified version or branch and adds it to the pipeline's classpath. The Groovy CPS (Continuation Passing Style) transformer processes the library code to make it compatible with Jenkins' durable execution model. Variables defined in the vars directory are instantiated as singleton objects, and their call methods become available as pipeline steps. The src directory classes are compiled by the Groovy compiler and loaded into a special classloader that sits alongside the pipeline's own classloader, allowing seamless interaction between library code and pipeline code.

In production environments, shared libraries typically contain standardized build functions for different technology stacks, deployment wrappers that enforce company policies, notification helpers that integrate with multiple communication channels, and security scanning steps that must be consistent across all projects. Teams often version their shared libraries using Git tags, allowing individual projects to pin to a stable version while the library continues to evolve. A governance model usually emerges where a platform engineering team owns the shared library, reviews changes through pull requests, and publishes release notes when new versions are available.

A critical gotcha with shared libraries is the trust boundary. Libraries configured as global libraries in Jenkins run with elevated privileges and can access any Jenkins API, including credentials and system configuration. This means a malicious or buggy change to a shared library can compromise the entire Jenkins instance. Teams must enforce strict code review on shared library repositories and use branch protection rules. Another common mistake is making shared libraries too opinionated, forcing teams to work around the library rather than with it. Design libraries to be configurable with sensible defaults, and always provide an escape hatch for teams with unique requirements.

// vars/standardPipeline.groovy - shared library custom step // This defines a reusable pipeline template for microservices def call(Map config) { // Begin the declarative pipeline block pipeline { // Use the agent label passed in config or default to docker agent { label config.agentLabel ?: 'docker' } // Define shared environment variables environment { // Service name from the calling pipeline's config SERVICE_NAME = config.serviceName // Docker registry from config with fallback default REGISTRY = config.registry ?: 'registry.company.com' } // Define the pipeline stages stages { // Build stage using the appropriate build tool stage('Build') { steps { // Call the shared build step based on project type buildProject(type: config.buildType ?: 'gradle') } } // Test stage with configurable test commands stage('Test') { steps { // Run tests using the shared test helper runTests(type: config.buildType ?: 'gradle') } } // Docker image creation and push stage stage('Containerize') { steps { // Build Docker image using shared containerize step containerize(serviceName: SERVICE_NAME, registry: REGISTRY) } } // Deployment stage that only runs on main branch stage('Deploy') { // Gate deployment to main branch only when { branch 'main' } steps { // Use shared deploy step with environment config deployService(serviceName: SERVICE_NAME, environment: 'staging') } } } // Post-build actions using shared notification step post { // Notify on failure using shared Slack helper failure { // Send failure notification to the team's channel notifyTeam(channel: config.slackChannel, status: 'FAILED') } // Notify on success using shared Slack helper success { // Send success notification to the team's channel notifyTeam(channel: config.slackChannel, status: 'SUCCESS') } } } } // Jenkinsfile in checkout-worker project - consumes the shared library // Load the shared library from the configured source @Library('[email protected]') _ // Invoke the shared pipeline template with project-specific config standardPipeline( // Set the microservice name for this project serviceName: 'checkout-worker', // Specify Maven as the build tool for this project buildType: 'maven', // Define the Slack channel for notifications slackChannel: '#checkout-team', // Use the kubernetes agent pool for this build agentLabel: 'kubernetes' )

What are Jenkins shared libraries and how do they promote code reuse?

More Jenkins questions