Pipelines With Docker Alternatives¶

@Library('jenkins-pipeline-library@master') _

def scmVars
def label = "jenkins-slave-${UUID.randomUUID().toString()}"

podTemplate(
        label: label,
        yaml: """
apiVersion: v1
kind: Pod
spec:
  containers:
  - name: kubectl
    image: vfarcic/kubectl
    command: ["cat"]
    tty: true
"""
) {
    node(label) {
        node("docker") {
            stage('SCM & Prepare') {
                scmVars = checkout scm
            }
            stage('Lint') {
                dockerfileLint()
            }
            stage('Build Docker') {
                sh "docker image build -t demo:rc-1 ."
            }
            stage('Tag & Push Docker') {
                IMAGE = "${DOCKER_IMAGE_NAME}"
                TAG = "${DOCKER_IMAGE_TAG}"
                FULL_NAME = "${FULL_IMAGE_NAME}"

                withCredentials([usernamePassword(credentialsId: "dockerhub", usernameVariable: "USER", passwordVariable: "PASS")]) {
                    sh "docker login -u $USER -p $PASS"
                }
                sh "docker image tag ${IMAGE}:${TAG} ${FULL_NAME}"
                sh "docker image push ${FULL_NAME}"
            }
        } // end node docker
        stage('Prepare Pod') {
            // have to checkout on our kubernetes pod aswell
            checkout scm
        }
        stage('Check version') {
            container('kubectl') {
                sh 'kubectl version'
            }
        }
    } // end node random label
} // end pod def

def scmVars
def tag

pipeline {
    options {
        buildDiscarder logRotator(artifactDaysToKeepStr: '5', artifactNumToKeepStr: '5', daysToKeepStr: '5', numToKeepStr: '5')
    }
    libraries {
        lib('core@master')
        lib('maven@master')
    }
    agent {
        kubernetes {
            label 'mypod'
            defaultContainer 'jnlp'
            yaml """
apiVersion: v1
kind: Pod
metadata:
  labels:
    some-label: some-label-value
spec:
  containers:
  - name: maven
    image: maven:3-jdk-11-slim
    command:
    - cat
    tty: true
"""
        }
    }
    stages {
        stage('Test versions') {
            steps {
                container('maven') {
                    sh 'uname -a'
                    sh 'mvn -version'
                }
            }
        }
        stage('Checkout') {
            steps {
                script {
                    scmVars = checkout scm
                }
                gitRemoteConfigByUrl(scmVars.GIT_URL, 'githubtoken')
                sh '''
                git config --global user.email "jenkins@jenkins.io"
                git config --global user.name "Jenkins"
                '''
            }
        }
        stage('Build') {
            steps {
                container('maven') {
                    sh 'mvn clean verify -B -e'
                }
            }
        }
        stage('Version & Analysis') {
            parallel {
                stage('Version Bump') {
                    when { branch 'master' }
                    environment {
                        NEW_VERSION = gitNextSemverTagMaven('pom.xml')
                    }
                    steps {
                        script {
                            tag = "${NEW_VERSION}"
                        }
                        container('maven') {
                            sh 'mvn versions:set -DnewVersion=${NEW_VERSION}'
                        }
                        gitTag("v${NEW_VERSION}")
                    }
                }
                stage('Sonar Analysis') {
                    when {branch 'master'}
                    environment {
                        SONAR_HOST='https://sonarcloud.io'
                        KEY='spring-maven-demo'
                        ORG='demomon'
                        SONAR_TOKEN=credentials('sonarcloud')
                    }
                    steps {
                        container('maven') {
                            sh '''mvn sonar:sonar \
                                -Dsonar.projectKey=${KEY} \
                                -Dsonar.organization=${ORG} \
                                -Dsonar.host.url=${SONAR_HOST} \
                                -Dsonar.login=${SONAR_TOKEN}
                            '''
                        }
                    }
                }
            }
        }
        stage('Publish Artifact') {
            when { branch 'master' }
            environment {
                DHUB=credentials('dockerhub')
            }
            steps {
                container('maven') {
                    // we should never come here if the tests have not run, as we run verify before
                    sh 'mvn clean compile -B -e jib:build -Djib.to.auth.username=${DHUB_USR} -Djib.to.auth.password=${DHUB_PSW} -DskipTests'
                }
            }
        }
    }
    post {
        always {
            cleanWs()
        }
    }
}

pipeline {
    agent {
        kubernetes {
            //cloud 'kubernetes'
            label 'kaniko'
            yaml """
kind: Pod
metadata:
  name: kaniko
spec:
  containers:
  - name: golang
    image: golang:1.11
    command:
    - cat
    tty: true
  - name: kaniko
    image: gcr.io/kaniko-project/executor:debug
    imagePullPolicy: Always
    command:
    - /busybox/cat
    tty: true
    volumeMounts:
      - name: jenkins-docker-cfg
        mountPath: /root
      - name: go-build-cache
        mountPath: /root/.cache/go-build
      - name: img-build-cache
        mountPath: /root/.local
  volumes:
  - name: go-build-cache
    emptyDir: {}
  - name: img-build-cache
    emptyDir: {}
  - name: jenkins-docker-cfg
    projected:
      sources:
      - secret:
          name: regcred
          items:
            - key: .dockerconfigjson
              path: .docker/config.json
"""
        }
    }
    stages {
        stage('Checkout') {
            steps {
                git 'https://github.com/joostvdg/cat.git'
            }
        }
        stage('Build') {
            steps {
                container('golang') {
                    sh './build-go-bin.sh'
                }
            }
        }
        stage('Make Image') {
            environment {
                PATH = "/busybox:$PATH"
            }
            steps {
                container(name: 'kaniko', shell: '/busybox/sh') {
                    sh '''#!/busybox/sh
                    /kaniko/executor -f `pwd`/Dockerfile.run -c `pwd` --cache=true --destination=index.docker.io/caladreas/cat
                    '''
                }
            }
        }
    }
}

pipeline {
    agent {
        kubernetes {
            label 'img'
            yaml """
kind: Pod
metadata:
  name: img
  annotations:
    container.apparmor.security.beta.kubernetes.io/img: unconfined  
spec:
  containers:
  - name: golang
    image: golang:1.11
    command:
    - cat
    tty: true
  - name: img
    workingDir: /home/jenkins
    image: caladreas/img:0.5.1
    imagePullPolicy: Always
    securityContext:
        rawProc: true
        privileged: true
    command:
    - cat
    tty: true
    volumeMounts:
      - name: jenkins-docker-cfg
        mountPath: /root
  volumes:
  - name: temp
    emptyDir: {}
  - name: jenkins-docker-cfg
    projected:
      sources:
      - secret:
          name: regcred
          items:
            - key: .dockerconfigjson
              path: .docker/config.json
"""
        }
    }
    stages {
        stage('Checkout') {
            steps {
                git 'https://github.com/joostvdg/cat.git'
            }
        }
        stage('Build') {
            steps {
                container('golang') {
                    sh './build-go-bin.sh'
                }
            }
        }
        stage('Make Image') {
            steps {
                container('img') {
                    sh 'mkdir cache'
                    sh 'img build -s ./cache -f Dockerfile.run -t caladreas/cat .'
                }
            }
        }
    }
}