This document discusses best practices for using Jenkins pipelines, including using scripted versus declarative syntax, shared libraries, configuration as code (JCasC), and useful plugins. It provides examples of scripted and declarative pipelines and highlights features of declarative pipelines like syntax checking and conditional actions. The document also summarizes best practices for shared libraries, including when they are needed, versioning, and avoiding large global files. It demonstrates using JCasC for system configuration and shows links to additional documentation resources.

1. Jenkins
In search of best practices

2. Kuleshov Dmitry
DevOps TechLead
Lohika
https://www.linkedin.com/in/vdksystem
Whoami

3. Why Jenkins?
What is it about…
Jenkins pipelines
Ø Scripted
Ø Declarative
Shared libraries
Ø In general
Ø src
Ø vars
Ø Combined
Ø MPL
JCasC
Conclusion

4. 1. One of top 10 CI/CD tools
2. Still in trends
Why Jenkins?

5. Scripted Declarative
VS
node {
stage('Hello') {
echo 'Hello World!'
}
}
pipeline {
agent any
stages {
stage('Hello') {
steps {
echo 'Hello World'
}
}
}
}

6. Scripted Declarative
VS
node {
try {
…
} catch(e) {
switch(currentBuild.status) {
case “SUCCESS”: …;
case “FAILURE”: …;
}
} finally {
…
}
}
pipeline {
…
post {
always {
…
}
success {
…
}
…
}
}

7. • Syntax Checking
– Immediate runtime syntax checking with explicit error messages.
– API and CLI ability for linting a Jenkinsfile.
• Docker and Kubernetes Pipeline integration
– Run all stages in a single container.
– Run each stage in a different container.
• Easy configuration
– Quickly define parameters for your Pipeline.
– Quickly define environment variables and credentials for your Pipeline.
– Quickly define options (such as timeout, retry, build discarding) for your Pipeline.
• Conditional actions
– Send notifications or take actions depending upon success or failure.
– Skip stages based on branches, environment, or other Boolean expression.
Declarative Pipeline Features

8. Tremendous amount of flexibility
Scripted Pipeline Features

9. • Making sure to use Groovy code in Pipelines as glue
• Avoiding complex Groovy code
• Reducing repetition of similar Pipeline steps
• Be careful with Concurrency
• Avoiding calls to Jenkins.getInstance
Pipeline best practices

10. Templated Pipeline
appPipeline {
unitTests = true,
sonar = true,
…
}
def call(body) {
def config = [:]
body.resolveStrategy = Closure.DELEGATE_FIRST
body.delegate = config
body()
…
}

11. Shared libraries

12. • Customer wants to use it
• Don’t repeat yourself
• Custom steps
• Jenkinsfile is too large
• Lots of microservices with the same type
• Jenkins as a SAAS (e.g. multy-team)
When do we need Shared library

13. General best practices:
• Do not override built-in Pipeline steps
• Avoiding large global variable declaration files
• Avoiding very large shared libraries
• Using @NonCPS
• Versioning shared libraries
• Do not reinvent the wheel
Shared library best practices

14. Shared library - src
class Pipeline
config
build
test…
class customPipeline extends Pipeline
build
test
// Jenkinsfile
@Library('utils') import org.foo.customPipeline
def p = new customPipeline(this)
node {
stage(“Build”) {
p.build()
}
}

15. Shared library - src
// src/org/foo/Utilities.groovy
package org.foo
class Utilities implements Serializable {
def steps
Utilities(steps) {this.steps = steps}
def mvn(args) {
steps.sh "${steps.tool 'Maven'}/bin/mvn -o ${args}"
}
}

16. Shared library - src
// src/org/foo/Zot.groovy
package org.foo
def checkOutFrom(repo) {
git url: "git@github.com:jenkinsci/${repo}"
}
return this
// Jenkinsfile
@Library('utils') import org.foo.Zot
node {
def z = new org.foo.Zot()
z.checkOutFrom(repo)
}

17. Shared library - vars
// vars/gitCheckout.groovy
def call(repo) {
git url: "git@github.com:jenkinsci/${repo}"
}
// vars/gitTools.groovy
def checkout(repo) {
git url: "git@github.com:jenkinsci/${repo}"
}
// Jenkinsfile
@Library('utils’) _
node {
stage(“Checkout”) {
gitCheckout(“repo URL”)
// or
gitTools.checkout(“repo URL”)
}
}

18. Shared library - vars
(root)
+- src/org/foo
| +- GlobalVars.groovy
+- vars
| +- helm.groovy
| +- helm.txt
| +- maven.groovy
| +- maven.txt
| +- utils.groovy
| +- utils.txt
+- resources
| +- org
| +- foo
| +- bar.json
@Library(‘lib’) _
node {
stage(“Checkout”) {
utils.checkout(“repo URL”)
}
stage(“Package”) {
maven.package()
}
stage(“Deploy”) {
helm.deploy()
}
}

19. Shared library - config
// src/org/foo/GlobalVars.groovy
package org.foo
class GlobalConfig {
public static defaults = [
"k8s" : [
"dev": [
"clusterUrl": "k8s.local",
"credentialsId": "k8s-dev-access"
],
"stg": […]
]
]
}
// vars/k8s.groovy
import static org.foo.GlobalConfig.defaults
def apply(filePath, env = ‘dev’) {
def credentialsId = defaults.k8s[env]. credentialsId
def serverUrl = defaults.k8s[env]. serverUrl
withKubeConfig([credentialsId: credentialsId, serverUrl: clusterUrl]) {
sh ”kubectl apply -f ${filePath}"
}
}

20. Shared library - config
// vars/fooPipeline.groovy
import static org.foo.GlobalConfig.defaults
def call(body) {
def config = [:]
body.resolveStrategy = Closure.DELEGATE_FIRST
body.delegate = config
body()
def cfg = defaults << config
pipeline {…}
}
// Jenkinsfile
fooPipeline{
k8s = [
dev: [
clusterUrl: ‘k8s.cluster.notlocal’,
credentialsId: ‘notlocal-credentials’
]
]
}

21. Jenkins Configuration as Code

22. JCasC
unclassified:
globalLibraries:
libraries:
- defaultVersion: "master"
includeInChangesets: false
name: "jsl"
jenkins:
clouds:
- kubernetes:
containerCapStr: "10"
jenkinsTunnel: "jenkins-agent:50000"
jenkinsUrl: "http://jenkins:8080"
name: "kubernetes"
jenkins:
systemMessage: "Jenkins configured as Code”

23. • Standard component of the Jenkins project
• Schema validation
• Vault integration
• JobDSL for jobs declaration
• Dynamic config reload
• Doesn’t support plugin installation
JCasC

24. Demo

25. • Keep it easy to read and maintain
• Use declarative pipelines
• Keep pipeline logic in Jenkinsfile
• Use shared library only if it’s really required
• Write custom steps in vars, don’t forget .txt
• Join methods by tool (log, helm, maven, etc)
• Check plugins first
• Cleanup everything as part of pipeline
• Read documentation
Conclusion

26. • kubernetes
• kubernetes-credentials-provider
• pipeline-utility-steps
• github-organization-folder
• cloudbees-bitbucket-branch-source
• bitbucket-filter-project-trait
• job-dsl
• blueocean
• prometheus
• timestamper
• rebuild
Useful plugins

27. • https://jenkins.io/doc/pipeline/steps/
• https://jenkins.io/doc/book/pipeline/shared-libraries/
• https://github.com/griddynamics/mpl
• https://jenkins.io/doc/book/pipeline/pipeline-best-practices/
• http://aimtheory.com/jenkins/pipeline/continuous-delivery/2018/10/01/jenkins-pipeline-global-
shared-library-best-practices-part-2.html
• https://bmuschko.com/blog/jenkins-shared-libraries/
• https://medium.com/@werne2j/unit-testing-a-jenkins-shared-library-9bfb6b599748
https://github.com/jenkinsci/configuration-as-code-plugin
• https://github.com/jenkinsci/configuration-as-code-plugin/tree/master/demos
• https://github.com/vdksystem/techtalkjenkins-jsl
• https://github.com/vdksystem/techtalkjenkins
Links

28. Thank You!