Perfektes CI/CD mit Jenkins Pipeline auf Google Kubernetes Engine

#!groovy  
  
node('nodejs') {  
  
    currentBuild.result = "SUCCESS"  
  
    try {  
  
       stage('Checkout'){  
          checkout scm  
       }  
  
       stage('Build'){  
          sh 'npm install'  
       }  
  
       stage('Test'){  
         env.NODE_ENV = "test"  
         sh 'npm run ci-test'  
       }  
  
       stage('Deploy'){  
         sh 'docker build -t myapp . && docker run -d myapp'  
       }  
  
       stage('Cleanup'){  
         sh 'npm prune'  
         sh 'rm node_modules -rf'  
         slackNotify channel: '#ci-nodejs', message: 'pipeline successful: myapp'  
       }  
    }  
    catch (err) {  
  
        currentBuild.result = "FAILURE"  
        slackNotify channel: '#ci-nodejs', message: 'pipeline failed: myapp'  
        throw err  
    }  
  
}

(root)  
+- src                     # Groovy source files  
|   +- org  
|       +- foo  
|           +- Bar.groovy  # for org.foo.Bar class  
+- vars  
|   +- foo.groovy          # for global 'foo' variable  
|   +- foo.txt             # help for 'foo' variable  
+- resources               # resource files (external libraries only)  
|   +- org  
|       +- foo  
|           +- bar.json    # static helper data for org.foo.Bar

@Library('my-shared-library@development') _

PipelineNodejs{  
  
  // MODIFY  
  projectName = 'node-template'  
  slackChannel = '#ci-nodejs'  
  appName = 'api' // microservice name, unique in project  
  cloudProject = [development: 'kube-dev-cluster', master: 'kube-prod-cluster']  
  buildCommand = 'npm install && npm run postinstall'  
  
  // MODIFY ONLY IF YOU KNOW WHAT YOU ARE DOING  
  nodeImage = 'node:5.12.0'  
  nodeEnv = "-e NODE_PATH=./app:./config"  
  nodeTestEnv = '-e NODE_ENV=test -e NODE_PATH=./app:./config'  
  namespace = [development: "${projectName}-development", master: "${projectName}-master"]  
}

def call(body) {  
  // evaluate the body block, and collect configuration into the object  
  def config = [:]  
  body.resolveStrategy = Closure.DELEGATE_FIRST  
  body.delegate = config  
  body()  
  
  properties([disableConcurrentBuilds()])  
  def agent = config.agent ?: 'nodejs'  
  
  node(agent) {  
  
    def workspace = pwd()  
  
    ... code omitted for brevity ...  
  
    stage('Test') {  
      if (config.runTests){  
  
        docker.image(nodeImage).inside(nodeTestEnv) {  
          sh "npm run ci-test"  
        }  
        echo "npm run ci-test finished. currentBuild.result=${currentBuild.result}"  
  
        ... code omitted for brevity ...  
  
        if (currentBuild.result == 'UNSTABLE') {  
          throw new RuntimeException("Tests failed")  
        }  
      }  
      else {  
        echo 'Tests skipped'  
      }  
... code omitted for brevity ...  

env.CHANGELOG_PATH = "outputs/changelog.txt"  
env.SLACK_CHANNEL = "ci-merge-requests"  
env.FASTLANE_SKIP_UPDATE_CHECK = 1  
env.FASTLANE_DISABLE_COLORS = 1  
env.CHANGELOG = ""  
  
node('ios') {  
      
   try {  
         
       gitlabBuilds(builds: ["carthage", "pods", "test", "build ipa"]) {  
             
            def gemfileExists = fileExists 'Gemfile'  
              
            fastlane = "fastlane"  
  
            if (gemfileExists) {  
                fastlane = "bundle exec fastlane"  
            }  
              
            stage('Checkout') {  
                println env.dump()  
                withCredentials([string(credentialsId: 'jenkins-gitlab-credentials', variable: 'credentials')]) {  
                  checkout changelog: true,   
                           poll: true,   
                           scm: [$class: 'GitSCM',   
                                  branches: [[name: "origin/${env.gitlabSourceBranch}"]],   
                                  doGenerateSubmoduleConfigurations: false,   
                                  extensions: [[$class: 'WipeWorkspace'],   
                                  [$class: 'PreBuildMerge',   
                                    options: [fastForwardMode: 'FF',   
                                              mergeRemote: 'origin',   
                                              mergeStrategy: 'default',   
                                              mergeTarget: "${env.gitlabTargetBranch}"]  
                                  ]  
                                 ],   
                           submoduleCfg: [],   
                           userRemoteConfigs: [[name: 'origin', credentialsId: credentials, url: env.gitlabSourceRepoSshUrl ]]]  
                }      
            }  
      
            stage('Prepare') {  
                sh("security unlock -p ${MACHINE_PASSWORD} ~/Library/Keychains/login.keychain")  
                  
                if (gemfileExists) {   
                    sh "bundle install --path ~/.bundle"   
                }  
            }  
          
            gitlabCommitStatus("carthage") {  
                stage('Carthage') {  
                    sh(fastlane + " cart")  
                }  
            }  
             
            gitlabCommitStatus("pods") {  
                stage('Pods') {  
                    sh(fastlane + " pods")  
                }  
            }  
              
            gitlabCommitStatus("test") {  
                stage('Test') {  
                    sh(fastlane + ' test type:unit')  
                    junit allowEmptyResults: true, testResults: 'fastlane/test_output/report.junit'      
                }  
            }  
              
            gitlabCommitStatus("build ipa") {     
                stage('Build IPA') {  
                    sh(fastlane + " beta")  
                }  
            }     
              
        }      
        currentBuild.result = 'SUCCESS'  
    }  
    catch (e) {  
        currentBuild.result = "FAILURE"  
        throw e  
    }  
    finally {  
        notifyBuild(currentBuild.result,reason)  
    }  
}  

String scriptPath = "jobs/gitlab"  
String jobSuffix = "merge-request-builder"  
String mCommentTrigger = "rebuild pls"  
  
def gitlabOn = {  
  it / 'properties' / 'com.dabsquared.gitlabjenkins.connection.GitLabConnectionProperty' {  
    'gitLabConnection'('gitlab')  
  }  
}  
  
def platform = 'ios'  
def jobName = "$platform-$jobSuffix"  
  
pipelineJob(jobName) {  
  concurrentBuild(false)  
  configure gitlabOn  
  definition {  
    cps {  
      script(readFileFromWorkspace("${scriptPath}/${jobName}.groovy"))  
      sandbox()  
    }  
  }  
  
  triggers {  
    gitlabPush {  
      buildOnMergeRequestEvents(true)  
      buildOnPushEvents(false)  
      enableCiSkip(true)  
      setBuildDescription(true)  
      commentTrigger(mCommentTrigger)  
      rebuildOpenMergeRequest('both')  
      skipWorkInProgressMergeRequest(false)  
    }  
  }  
}  

// use a Pipeline class src/cz/ackee/Pipeline.groovy rather than the global func  
def pipeline = new cz.ackee.Pipeline()  
  
node {  
  
properties([  
disableConcurrentBuilds()  
])  
  
pipeline.checkoutScm()  
  
// set additional envvars and config  
pipeline.setEnv()  
  
stage('seed jobs') {  
withCredentials([string(credentialsId: 'jenkins-gitlab-credentials', variable: 'gitlabCredentials')]) {  
jobDsl targets: 'jobs/**/seed.groovy',  
additionalParameters: [credentials: gitlabCredentials]  
}  
}  
  
stage('test') {  
// run basic tests on pipeline like mysql reporting, slack, gcloud, kubectl and gitlab integrations checking   
pipeline.envTest()  
  
// test Node.js Pipeline  
def obj = build job: '../node-template/master/', propagate: false  
if(obj.result == 'FAILURE') throw new RuntimeException("Node.js Pipeline test failed.")  
  
// test React Pipeline  
obj = build job: '../react-template/master', propagate: false  
if(obj.result == 'FAILURE') throw new RuntimeException("React Pipeline test failed.")  
  
// test Middleman Pipeline  
obj = build job: '../middleman-template/master', propagate: false  
if(obj.result == 'FAILURE') throw new RuntimeException("Middleman Pipeline test failed.")  
  
}  
  
stage('lint') {  
//TODO: add groovy lint  
}  
}