The Ultimate Jenkins Cheatsheet

pipeline {
    agent any

    // ── Global Environment ──
    environment {
        DOCKER_REGISTRY = 'registry.example.com'
        IMAGE_NAME       = 'myapp'
        IMAGE_TAG        = "${env.BUILD_NUMBER}"
        CREDENTIALS_ID   = 'docker-registry-creds'
    }

    // ── Pipeline Triggers ──
    triggers {
        pollSCM('H/5 * * * *')       // Poll every 5 minutes
        // OR use webhook from GitHub/GitLab
    }

    options {
        timeout(time: 30, unit: 'MINUTES')
        retry(2)                     // Retry failed stages
        buildDiscarder(logRotator(numToKeepStr: '20'))
        disableConcurrentBuilds()
        timestamps()
        ansiColor('xterm')
    }

    // ── Stages ──
    stages {
        stage('Checkout') {
            steps {
                checkout scmGit(
                    branches: [[name: '*/main']],
                    extensions: [[$class: 'CleanBeforeCheckout']]
                )
                sh 'git log --oneline -5'
            }
        }

        stage('Install Dependencies') {
            steps {
                sh 'npm ci --production=false'
            }
        }

        stage('Lint & Format') {
            parallel {
                stage('ESLint') {
                    steps { sh 'npm run lint' }
                }
                stage('Type Check') {
                    steps { sh 'npx tsc --noEmit' }
                }
            }
        }

        stage('Test') {
            steps {
                sh 'npm run test:coverage'
            }
            post {
                always {
                    junit 'reports/junit.xml'
                    publishHTML(target: [
                        allowMissing: false,
                        alwaysLinkToLastBuild: true,
                        keepAll: true,
                        reportDir: 'coverage',
                        reportFiles: 'index.html',
                        reportName: 'Coverage Report'
                    ])
                }
            }
        }

        stage('Build') {
            steps {
                sh 'npm run build'
                archiveArtifacts artifacts: 'dist/**', fingerprint: true
            }
        }

        stage('Docker Build & Push') {
            steps {
                script {
                    docker.withRegistry("https://${DOCKER_REGISTRY}", CREDENTIALS_ID) {
                        def img = docker.build("${IMAGE_NAME}:${IMAGE_TAG}")
                        img.push()
                        img.push('latest')
                    }
                }
            }
        }

        stage('Deploy') {
            when { branch 'main' }
            steps {
                sh '''
                    kubectl set image deployment/myapp                         myapp=${DOCKER_REGISTRY}/${IMAGE_NAME}:${IMAGE_TAG}                         --namespace=production
                '''
            }
        }
    }

    post {
        success { echo 'Pipeline completed successfully!' }
        failure { echo 'Pipeline FAILED. Check logs.' }
        always {
            cleanWs()
            emailext(
                subject: "Build ${currentBuild.result}: ${env.JOB_NAME} #${env.BUILD_NUMBER}",
                body: "${env.JOB_NAME} - Build #${env.BUILD_NUMBER} - ${currentBuild.result}",
                to: 'team@example.com'
            )
        }
    }
}

// ── Shared Variables & Functions ──
def getGitBranch() {
    return sh(returnStdout: true, script: 'git rev-parse --abbrev-ref HEAD').trim()
}

def getDockerTags() {
    def commit = sh(returnStdout: true, script: 'git rev-parse --short HEAD').trim()
    def branch = getGitBranch()
    def tags = ["${env.BUILD_NUMBER}", commit]
    if (branch == 'main') {
        tags << 'latest'
    }
    return tags
}

// ── Conditional Logic ──
script {
    if (env.BRANCH_NAME == 'main') {
        stage('Production Deploy') {
            sh 'kubectl apply -f k8s/production/'
        }
    } else if (env.BRANCH_NAME.startsWith('feature/')) {
        stage('Dev Deploy') {
            sh 'kubectl apply -f k8s/development/'
        }
    } else {
        echo "No deployment for branch: ${env.BRANCH_NAME}"
    }
}

// ── Retry Logic ──
retry(3) {
    sh 'npm install --registry=https://registry.npmjs.org'
}

// ── Timeout ──
timeout(time: 5, unit: 'MINUTES') {
    sh 'npm run test:e2e'
}

// ── Wait for Condition ──
waitUntil {
    script {
        def r = sh(script: 'curl -s -o /dev/null -w "%{http_code}" http://localhost:3000', returnStdout: true).trim()
        return (r == "200")
    }
}

// ── Parallel Stages with Matrix ──
matrix {
    axes {
        axis {
            name 'NODE_VERSION'
            values '18', '20', '22'
        }
    }
    stages {
        stage('Test') {
            steps {
                sh "docker run --rm node:${NODE_VERSION} npm test"
            }
        }
    }
}

// ── Shared Library: vars/buildApp.groovy ──
def call(Map config = [:]) {
    def registry = config.registry ?: 'registry.example.com'
    def imageName = config.imageName ?: env.JOB_NAME.toLowerCase()
    def tag = config.tag ?: env.BUILD_NUMBER

    pipeline {
        agent any
        stages {
            stage('Build') {
                steps {
                    sh "docker build -t ${registry}/${imageName}:${tag} ."
                }
            }
            stage('Push') {
                steps {
                    withCredentials([usernamePassword(
                        credentialsId: 'registry-creds',
                        usernameVariable: 'REGISTRY_USER',
                        passwordVariable: 'REGISTRY_PASS'
                    )]) {
                        sh """
                            echo $REGISTRY_PASS | docker login ${registry} -u $REGISTRY_USER --password-stdin
                            docker push ${registry}/${imageName}:${tag}
                        """
                    }
                }
            }
        }
    }
}

// ── Shared Library: vars/deployK8s.groovy ──
def call(String namespace, String deployment, String image) {
    sh """
        kubectl set image deployment/${deployment} \
            container=${deployment}=${image} \
            --namespace=${namespace}
        kubectl rollout status deployment/${deployment} \
            --namespace=${namespace} --timeout=300s
    """
}

// ── Shared Library: vars/notify.groovy ──
def call(String status, String channel = '#ci-cd') {
    if (status == 'SUCCESS') {
        emailext(subject: "Build OK: ${env.JOB_NAME} #${env.BUILD_NUMBER}",
                 body: "Success! View: ${env.BUILD_URL}", to: 'team@example.com')
    } else {
        emailext(subject: "Build FAILED: ${env.JOB_NAME} #${env.BUILD_NUMBER}",
                 body: "Failed! View: ${env.BUILD_URL}", to: 'team@example.com')
    }
}

// ── Jenkinsfile Using Shared Library ──
@Library('my-shared-lib') _

pipeline {
    agent any
    stages {
        stage('Build & Push') {
            steps {
                buildApp(
                    registry: 'registry.example.com',
                    imageName: 'frontend',
                    tag: env.BUILD_NUMBER
                )
            }
        }
        stage('Deploy to Production') {
            when { branch 'main' }
            steps {
                deployK8s('production', 'frontend', "registry.example.com/frontend:${env.BUILD_NUMBER}")
            }
        }
    }
    post {
        always { notify(currentBuild.result) }
    }
}