Jenkins Pipeline: Jenkinsfile Syntax, Stages & Shared Libraries

Declarative Pipeline Structure

Declarative Pipeline is the recommended approach for most teams. The pipeline block enforces a clear structure: agent, environment, stages, and post. Jenkins validates the syntax before any agent is allocated, giving you faster feedback on configuration errors.

// Jenkinsfile (Declarative Pipeline)
pipeline {
  agent any

  environment {
    NODE_VERSION = '20'
    DEPLOY_ENV   = 'staging'
  }

  stages {
    stage('Install') {
      steps {
        sh 'npm ci'
      }
    }
    stage('Test') {
      steps {
        sh 'npm test -- --ci --coverage'
      }
      post {
        always {
          junit 'coverage/junit.xml'
        }
      }
    }
    stage('Build') {
      steps {
        sh 'npm run build'
        archiveArtifacts artifacts: 'dist/**', fingerprint: true
      }
    }
    stage('Deploy') {
      when {
        branch 'main'
      }
      steps {
        sh './scripts/deploy.sh ${DEPLOY_ENV}'
      }
    }
  }

  post {
    failure {
      slackSend(color: 'danger', message: "Build failed: ${env.JOB_NAME} #${env.BUILD_NUMBER}")
    }
    always {
      cleanWs()
    }
  }
}

Parallel Stages

Running stages in parallel dramatically reduces total pipeline duration. Jenkins allocates separate executors for each parallel branch. Use failFast: true to cancel all other branches the moment one fails — essential for fast feedback in large test suites.

stage('Parallel Checks') {
  parallel {
    stage('Unit Tests') {
      steps { sh 'npm run test:unit' }
    }
    stage('Integration Tests') {
      steps { sh 'npm run test:integration' }
    }
    stage('Lint') {
      steps { sh 'npm run lint' }
    }
    stage('Security Scan') {
      steps { sh 'npm audit --audit-level=high' }
    }
  }
  // abort all branches when any one fails
  failFast true
}

Shared Libraries

Shared Libraries eliminate copy-paste across Jenkinsfiles. Define reusable steps in a dedicated Git repository under vars/ and import them with @Library. Configure the library URL in Jenkins → Manage Jenkins → Configure System → Global Pipeline Libraries.

// vars/deployApp.groovy  (in your shared library repo)
def call(String environment, String appName) {
  echo "Deploying ${appName} to ${environment}"
  sh "kubectl set image deployment/${appName} app=${appName}:${env.BUILD_NUMBER} -n ${environment}"
  sh "kubectl rollout status deployment/${appName} -n ${environment}"
}

// Jenkinsfile  (in your application repo)
@Library('my-shared-library') _

pipeline {
  agent any
  stages {
    stage('Deploy to Staging') {
      steps {
        deployApp('staging', 'my-api')
      }
    }
  }
}

Jenkins vs GitHub Actions vs CircleCI

Key Best Practices

• ✓Pin agent images. Use agent { docker { image 'node:20-alpine' } } to ensure reproducible builds across all runs.
• ✓Use credentials binding. Reference secrets via withCredentials([string(credentialsId: 'API_KEY', variable: 'KEY')]) — never hardcode secrets.
• ✓Gate deploys with when conditions. Use when { branch 'main' } to prevent feature branches from deploying to production accidentally.
• ✓Archive test reports. Use junit and publishHTML to make test results visible in the Jenkins UI without digging through logs.