Automation & DevOps - CI/CD Pipelines & Workflow Automation

Jenkins Declarative Pipeline

// Jenkinsfile
pipeline {
    agent {
        kubernetes {
            yaml """
apiVersion: v1
kind: Pod
spec:
  containers:
  - name: maven
    image: maven:3.8.6-openjdk-17
    command:
    - cat
    tty: true
    volumeMounts:
    - name: docker-sock
      mountPath: /var/run/docker.sock
  - name: docker
    image: docker:20.10.21-dind
    securityContext:
      privileged: true
    volumeMounts:
    - name: docker-sock
      mountPath: /var/run/docker.sock
  - name: kubectl
    image: bitnami/kubectl:1.25
    command:
    - cat
    tty: true
  volumes:
  - name: docker-sock
    hostPath:
      path: /var/run/docker.sock
"""
        }
    }
    
    environment {
        DOCKER_REGISTRY = 'your-registry.com'
        IMAGE_NAME = 'my-java-app'
        KUBECONFIG = credentials('kubeconfig')
        SONAR_TOKEN = credentials('sonar-token')
        SLACK_WEBHOOK = credentials('slack-webhook')
    }
    
    parameters {
        choice(
            name: 'DEPLOY_ENV',
            choices: ['dev', 'staging', 'production'],
            description: 'Environment to deploy to'
        )
        booleanParam(
            name: 'SKIP_TESTS',
            defaultValue: false,
            description: 'Skip running tests'
        )
        string(
            name: 'IMAGE_TAG',
            defaultValue: '',
            description: 'Custom image tag (optional)'
        )
    }
    
    stages {
        stage('Checkout') {
            steps {
                checkout scm
                script {
                    env.GIT_COMMIT_SHORT = sh(
                        script: 'git rev-parse --short HEAD',
                        returnStdout: true
                    ).trim()
                    
                    env.BUILD_TAG = params.IMAGE_TAG ?: "${env.BUILD_NUMBER}-${env.GIT_COMMIT_SHORT}"
                }
            }
        }
        
        stage('Build') {
            steps {
                container('maven') {
                    sh '''
                        mvn clean compile -DskipTests=true
                        mvn versions:set -DnewVersion=${BUILD_TAG}
                    '''
                }
            }
        }
        
        stage('Test') {
            when {
                not { params.SKIP_TESTS }
            }
            parallel {
                stage('Unit Tests') {
                    steps {
                        container('maven') {
                            sh 'mvn test'
                        }
                    }
                    post {
                        always {
                            publishTestResults(
                                testResultsPattern: 'target/surefire-reports/*.xml',
                                allowEmptyResults: false
                            )
                        }
                    }
                }
                
                stage('Integration Tests') {
                    steps {
                        container('maven') {
                            sh 'mvn verify -Dtest.profile=integration'
                        }
                    }
                    post {
                        always {
                            publishTestResults(
                                testResultsPattern: 'target/failsafe-reports/*.xml',
                                allowEmptyResults: false
                            )
                        }
                    }
                }
            }
        }
        
        stage('Code Quality') {
            parallel {
                stage('SonarQube Analysis') {
                    steps {
                        container('maven') {
                            withSonarQubeEnv('SonarQube') {
                                sh '''
                                    mvn sonar:sonar \
                                        -Dsonar.token=${SONAR_TOKEN} \
                                        -Dsonar.projectKey=my-java-app \
                                        -Dsonar.projectName="My Java App"
                                '''
                            }
                        }
                    }
                }
                
                stage('Security Scan') {
                    steps {
                        container('maven') {
                            sh 'mvn org.owasp:dependency-check-maven:check'
                        }
                    }
                    post {
                        always {
                            publishHTML([
                                allowMissing: false,
                                alwaysLinkToLastBuild: true,
                                keepAll: true,
                                reportDir: 'target',
                                reportFiles: 'dependency-check-report.html',
                                reportName: 'OWASP Dependency Check'
                            ])
                        }
                    }
                }
            }
        }
        
        stage('Quality Gate') {
            steps {
                timeout(time: 5, unit: 'MINUTES') {
                    waitForQualityGate abortPipeline: true
                }
            }
        }
        
        stage('Package') {
            steps {
                container('maven') {
                    sh 'mvn package -DskipTests=true'
                }
                
                container('docker') {
                    script {
                        def image = docker.build("${DOCKER_REGISTRY}/${IMAGE_NAME}:${BUILD_TAG}")
                        
                        docker.withRegistry("https://${DOCKER_REGISTRY}", 'docker-registry-credentials') {
                            image.push()
                            image.push('latest')
                        }
                    }
                }
            }
        }
        
        stage('Deploy') {
            when {
                anyOf {
                    branch 'main'
                    branch 'develop'
                    expression { params.DEPLOY_ENV != null }
                }
            }
            steps {
                container('kubectl') {
                    script {
                        def deployEnv = params.DEPLOY_ENV ?: (env.BRANCH_NAME == 'main' ? 'production' : 'staging')
                        
                        sh """
                            # Update deployment image
                            kubectl set image deployment/my-java-app \
                                my-java-app=${DOCKER_REGISTRY}/${IMAGE_NAME}:${BUILD_TAG} \
                                -n ${deployEnv}
                            
                            # Wait for rollout
                            kubectl rollout status deployment/my-java-app -n ${deployEnv} --timeout=300s
                            
                            # Verify deployment
                            kubectl get pods -n ${deployEnv} -l app=my-java-app
                        """
                    }
                }
            }
        }
        
        stage('Smoke Tests') {
            when {
                anyOf {
                    branch 'main'
                    branch 'develop'
                }
            }
            steps {
                container('maven') {
                    script {
                        def deployEnv = env.BRANCH_NAME == 'main' ? 'production' : 'staging'
                        def baseUrl = deployEnv == 'production' ? 
                            'https://api.myapp.com' : 
                            'https://staging-api.myapp.com'
                        
                        sh """
                            mvn test -Dtest.profile=smoke \
                                -Dapi.base.url=${baseUrl} \
                                -Dtest.timeout=60
                        """
                    }
                }
            }
        }
    }
    
    post {
        always {
            // Archive artifacts
            archiveArtifacts(
                artifacts: 'target/*.jar,target/dependency-check-report.html',
                allowEmptyArchive: true
            )
            
            // Clean workspace
            cleanWs()
        }
        
        success {
            script {
                def deployEnv = params.DEPLOY_ENV ?: (env.BRANCH_NAME == 'main' ? 'production' : 'staging')
                slackSend(
                    channel: '#deployments',
                    color: 'good',
                    message: """
✅ Deployment Successful!
• Project: ${env.JOB_NAME}
• Build: ${env.BUILD_NUMBER}
• Environment: ${deployEnv}
• Image: ${DOCKER_REGISTRY}/${IMAGE_NAME}:${BUILD_TAG}
• Duration: ${currentBuild.durationString}
                    """.trim(),
                    webhookUrl: env.SLACK_WEBHOOK
                )
            }
        }
        
        failure {
            slackSend(
                channel: '#deployments',
                color: 'danger',
                message: """
❌ Deployment Failed!
• Project: ${env.JOB_NAME}
• Build: ${env.BUILD_NUMBER}
• Stage: ${env.STAGE_NAME}
• Duration: ${currentBuild.durationString}
• Logs: ${env.BUILD_URL}console
                """.trim(),
                webhookUrl: env.SLACK_WEBHOOK
            )
        }
        
        unstable {
            slackSend(
                channel: '#deployments',
                color: 'warning',
                message: """
⚠️ Deployment Unstable!
• Project: ${env.JOB_NAME}
• Build: ${env.BUILD_NUMBER}
• Issues: Check test results
• Logs: ${env.BUILD_URL}console
                """.trim(),
                webhookUrl: env.SLACK_WEBHOOK
            )
        }
    }
}