JavaLand 2017 - Pipeline as code

Pipeline as code
Building Continuous Delivery Pipelines with Jenkins 2
Bert Jan Schrijver
@bjschrijverbertjan@jpoint.nl

@bjschrijver
Let’s meet
Bert Jan Schrijver

@bjschrijver
Outline
• Definitions
• Jenkins 1.x
• What’s new in Jenkins 2?
• Pipeline as code
• Pipelines in depth
• Jenkins 2 in the wild
Thanks to @alexsotob
and @kohsukekawa!

@bjschrijver
Definitions
Every change goes through the
build/test pipeline and
automatically gets put into
production.
Continuous Deployment
An automated sequence of stages
to deliver software from version
control to your users.
Pipeline
Building and testing software in
such a way that the software can be
released to production at any time.
Continuous Delivery
Team members integrate their work
frequently. Commits are verified by
automated builds and tests.
Continuous Integration
Who’s who in CI & CD

@bjschrijver
About Jenkins
• De-facto standard tool for automation in software
development and beyond
• Around for 10+ years, millions of users
• Over 120.000 active installations
• Jenkins is mission critical for >90% of its users
• Version 2: first major release in years

@bjschrijver
Jenkins: an overview
• TODO: Jenkins overview slide uit talk Alex Soto
Source: http://www.slideshare.net/asotobu/jenkins-20-65705621

@bjschrijver
What’s new in Jenkins 2?
• Better out-of-the-box experience
• Default set of plugins
• Secured by default
• Revamped UI
• Pipeline as code
• In general: more code, less GUI, less state
• Drop-in upgrade, backwards compatible w/1.6

@bjschrijver
Pipeline as code
• Key new feature
• Positions Jenkins for:
• continuous delivery use cases
• other more complex automations of today
• Allows to:
• describe chain of automation in textual form 
and put it in version control

@bjschrijver
Pipeline as code
• Grows with you from simple to complex
• Handle lots of jobs without repetition
• Survives Jenkins restarts
• Brings next level of reuse to Jenkins

@bjschrijver
Scripted vs. declarative pipelines
• Scripted
• more flexible, better reuse, compact
• Declarative
• No Groovy experience necessary
• Syntax checking
• Linting via API and CLI
• Visual editor (beta)

@bjschrijver
My first scripted pipeline
node('java8') { 
 
stage('Configure') { 
env.PATH = "${tool 'maven-3.3.9'}/bin:${env.PATH}" 
}  
 
stage('Checkout') { 
git 'https://github.com/bertjan/spring-boot-sample' 
}  
 
stage('Build') { 
sh 'mvn -B -V -U -e clean package'  
}  
 
stage('Archive') { 
junit allowEmptyResults: true, testResults: '**/target/**/TEST*.xml' 
}  
 
}

@bjschrijver
My first declarative pipeline
pipeline {
agent {
node {
label 'java8'
}
}
tools {
maven 'maven-3.3.9'
}
stages {
stage('Checkout') {
steps {
git 'https://github.com/bertjan/spring-boot-sample'
}
}
stage('Build') {
steps {
sh 'mvn -B -V -U -e clean package'
}
}
stage('Archive') {
steps {
junit(testResults: '**/target/**/TEST*.xml', allowEmptyResults: true)
}
}
}
}

@bjschrijver
Pipeline syntax
• Built-in syntax and snippet generator
• Groovy DSL definition (GDSL file) for IDE
• Pipeline reference: 
https://jenkins.io/doc/pipeline/steps
• Plugin documentation
• If all else fails: dive into the source

@bjschrijver@bjschrijver
SNIPPETS

@bjschrijver
Archive build artifacts
archiveArtifacts artifacts: '**/target/*.jar', fingerprint: true

@bjschrijver
Cleanup old builds
properties( 
[buildDiscarder(logRotator( 
artifactDaysToKeepStr: '',  
artifactNumToKeepStr: '',  
daysToKeepStr: '',  
numToKeepStr: '10')) 
])

@bjschrijver
E-mail notification
try { 
 
// build steps here 
 
} catch (e) { 
currentBuild.result = "FAILED" 
def subject = 'Build '' + env.JOB_NAME + '' (branch '' + branch + '') ' + 
'failed in Jenkins' 
def body = 'Build log is attached. Details: ' + env.BUILD_URL 
def to = 'email@domain.com' 
mail to: to, subject: subject, body: body, attachLog: true 
throw e 
}

@bjschrijver
Including files, using constants
// File common/Constants.groovy:
class Constants { 
static final MAJOR_VERSION_NUMBER = '3.2.1'; 
 
static final SONAR_URL = 'https://sonar.my.company.com'; 
} 
 
return this; 
// Jenkinsfile:
load 'common/Constants.groovy' 
sh "mvn -B -V -U -e sonar:sonar -Dsonar.host.url='${Constants.SONAR_URL}'"

@bjschrijver
Re-usable workflow steps
// In file <some git repo>/src/my/company/package/SomeLibrary.groovy 
package my.company.package 
 
def someBuildStep() { 
// Some build step 
}
// In Jenkinsfile:
@Library('pipeline-library') 
import my.company.package.* 
def myLibrary = new SomeLibrary() 
myLibrary.someBuildStep()

@bjschrijver
Re-usable workflow steps

@bjschrijver
Parallel run on multiple nodes
stage('Checkout') { 
git 'https://github.com/bertjan/spring-boot-sample' 
stash excludes: 'build/', includes: '**', name: 'source' 
}  
 
stage ('Test') { 
parallel 'unit': { 
node { 
// run unit tests 
unstash 'source' 
sh 'mvn test' 
junit '**/build/test-results/*.xml' 
} 
}, 'integration': { 
node { 
// run integration tests 
unstash 'source' 
sh 'mvn integration-test' 
junit '**/build/test-results/*.xml' 
} 
} 
}

@bjschrijver
Jenkins 2 in the wild
• Upgraded a 1.6 instance with about 50 builds
• Replaced all builds with pipelines
• One single Git repo for all builds
• Re-usable pipeline library
• Builds are far more consistent

@bjschrijver
Jenkins 2: Moving forward
• Upcoming changes: focused on ease of use
• simplified pipeline model
• look less like programming, more declarative
• cater both point-and-click and editor people
• fails when Jenkins reads it, not when it runs it

@bjschrijver@bjschrijver
SUMMARY

@bjschrijver
Summary
• Jenkins 2: powerful continuous delivery platform
• UI improvements, more curated experience
• Scripted pipelines: less clicks, more code
• Declarative pipelines: syntax checking, visual editor

@bjschrijver
20
JAVA MAGAZINE
JAVA MAGAZINE | 06 2016
PIPELINE AS CODE
Op JavaOne vertelde Kohsuke Kawaguchi, demaker van Jenkins, dat er meer dan 120.000actieve installaties zijn. Voor meer dan 90%van de gebruikers is Jenkins “mission critical”.Jenkins is dus niet zomaar een hobbypro-jectje. Een belangrijke factor in het succes vanJenkins is de enorme verzameling plug-ins,die beschikbaar zijn. Er is een heel ecosys-teem ontstaan, waarmee Jenkins in vrijwelelke omgeving kan worden ingezet.
Nieuw in Jenkins 2Jenkins 2 is een drop-in upgrade, volledigbackward compatible met versie 1.6, met driegrote wijzigingen.
Betere out-of-the-box ervaringVroeger was Jenkins standaard vrij beperkt.Je moest veel plug-ins installeren, voordatje aan de gang kon. Dat is nu beter geregeld.Je kunt tijdens de installatie kiezen voor eenaanbevolen set plug-ins, waardoor je directaan de slag kunt.
Security is nu standaard. Bij de eerste keeropstarten wordt er een initieel admin wacht-
woord gezet, dat je uit de logs moet vissen.Dat is iets meer werk vergeleken met vroegerwaar alles open stond, maar het is wel eenstuk veiliger. Zeker als je te weten komt, dater bots zijn die het internet af scannen naaronbeveiligde Jenkins-instanties.
Opgefriste GUI
De GUI van Jenkins is licht verbeterd tenopzichte van Jenkins 1.x. Bij installatie enupgrade krijg je nu een wizard voorgeschoteld,die je helpt bij de configuratie. Eenmaal ge-installeerd zijn de wijzigingen marginaal. Hetaanmaken van een nieuwe job ziet er iets an-ders uit en bij het configureren van jobs heb jenu tabjes, waarmee je snel naar een bepaaldesectie kunt springen. De echt grote GUI-wijzigingen zitten in project “Blue Ocean”,waarover je verderop meer kunt lezen.
Pipeline as code
Veruit de grootste wijziging in Jenkins 2 ishet pipeline as code concept. Een pipeline iseen geautomatiseerde reeks van stappen, diesoftware vanuit versiebeheer naar de handenvan je gebruikers brengt. Met pipeline as code
Pipeline as codeContinuous Delivery pipelines met Jenkins 2In de afgelopen tien jaar heeft Jenkins zich ontpopt tot de standaardtool voor automatisering
in software development. Dit jaar is de eerste grote Jenkins release sinds tijden uitgekomen:
Jenkins 2.0. In dit artikel lees je wat er allemaal nieuw is.
Bert Jan Schrijver is
software craftsman
bij JPoint en is
momenteel
werkzaam bij de
Nationale Politie
Listing 1: pipeline script voor een Maven project
Afbeelding 2: visualisatie van een Jenkins pipeline
Afbeelding 1: Het Jenkins ecosysteem. Bron: [1]
kun je pipelines in tekstuele vormbeschrijven en in versiebeheer bewa-ren. Deze pipelines schrijf je met eenflexibele Groovy DSL.
In Jenkins 1 werkte het maken vanpipelines niet echt optimaal, zekerniet in een microservice-omgevingals je veel losse jobs hebt voor build,test en deploy. Een project met 20services leverde dan al gauw een stukof 100 Jenkins jobs op.
Met Jenkins 2 pipelines werkt dat eenstuk praktischer om twee redenen:1. Je kunt jobs precies zo samenstel-len als je zelf wilt. Een enkele jobkan een complete pipeline vancommit tot en met productie-deployment afhandelen.
2. Hergebruik van onderdelen vanjobs is veel eenvoudiger. Hieroververderop meer.
Jenkins wordt hiermee gepositio-neerd voor continuous delivery usecases en voor andere meer complexeautomatiserings-scenario’s.
Pipelines
Je kunt een Jenkins 2 pipeline optwee manieren definiëren: door depipeline in de Jenkins GUI in te tik-ken of door een bestand met daarinde pipeline-definitie in versiebeheerte plaatsen. Voor de laatste optie ishet een conventie om een“Jenkinsfile” in de root van het pro-ject te zetten waar de job betrekkingop heeft. Dit is vergelijkbaar met deDockerfile of een Maven
pom.xml: een standaard configuratie-file op een standaard plek.
Als je in je IDE aan Jenkinsfiles werkt,dan kun je een GDSL file importeren[2]. Dit bestand regelt de highlightingen code completion in je IDE.
Een voorbeeld
Het volgende pipeline script bouwteen eenvoudig Maven project (zieListing 1).
De eerste stap is het kiezen van hettype Jenkins node waar de build opmoet gaan draaien. In het eenvoudig-ste scenario heb je alleen een Jenkins“master” node. In wat complexereomgevingen zie je vaak een masternode en een aantal tot zelfs tientallenslave nodes om veel builds tegelijker-tijd te kunnen draaien.
In dit voorbeeld geven we aan datde job op een node met label ‘java8’moet draaien. Jenkins kiest dan de
eerstvolgende beschikbare node waardit label aan toegekend is. De helepipeline draait nu op deze ‘java8’node. Je kunt er ook voor kiezen omverschillende onderdelen op ver-schillende nodes en zelfs parallel tedraaien.
De pipeline in dit voorbeeld kent vier“stages”. Een stage is een stap in eenpipeline, die als zodanig herkenbaaris in de Jenkins GUI. In de eerste stagezoeken we geïnstalleerde tool‘maven-3.3.9’ op en maken dezebeschikbaar door hem in de path-variabele van het OS te zetten. Detweede stap is een Git checkout, dederde een Maven build en de vierde ar-chiveert de resultaten van de unit tests.
Als we de pipeline uitvoeren, zien wede volgende resultaten terug in deJenkins GUI (zie Afbeelding 2).
De praktijk leert dat pipelinesmeegroeien van eenvoudig naar com-plex. Met gecodeerde pipelines kun jemeerdere jobs definiëren zonder jezelfte herhalen. Dit is een groot voordeelten opzichte van traditionele, point-and-click pipelines.
Pipelines overleven een herstart vanJenkins. Dat is handig als je af en toeeen upgrade van Jenkins wilt uitvoe-ren, waarvoor een herstart nodig is.Jenkins bevat daarnaast de mogelijk-heid om een pipeline te
“replayen”, waarbij je via de GUIkleine wijzigingen kunt doen en depipeline vervolgens opnieuw kan uit-voeren. Dat is erg handig bij het ont-wikkelen van gecodeerde pipelines.
node('java8') {
stage('Configure') {env.PATH = "${tool 'maven-3.3.9'}/bin:${env.PATH}"
}
stage('Checkout') {git 'https://github.com/bertjan/spring-boot-sample'
}
stage('Build') {
sh 'mvn -B -V -U -e clean package'
}
stage('Archive') {
junit allowEmptyResults: true,testResults: '**/target/**/TEST*.xml'
}
}
• https://github.com/bertjan/spring-boot-sample
• https://github.com/politie/pipeline-library
• https://www.voxxed.com/blog/2017/01/pipeline-as-
code-with-jenkins-2/
• https://github.com/bertjan/javamagazine (Dutch)
Resources

@bjschrijver
Questions?Questions?

Thanks for your time.
Got feedback? Tweet it! @bjschrijver
All pictures belong
to their respective
authors

JavaLand 2017 - Pipeline as code

More Related Content

Viewers also liked (11)

Similar to JavaLand 2017 - Pipeline as code (20)

JavaLand 2017 - Pipeline as code