Pipeline with Kubernetes

pipeline {

    agent {
        kubernetes {
            // The full pod specification in YAML
            // Jenkins creates exactly this pod for every build
            yaml '''
apiVersion: v1
kind: Pod
metadata:
  labels:
    app: jenkins-build
spec:
  # Service account with permissions to deploy to the cluster
  serviceAccountName: jenkins-deployer

  containers:

  # Mandatory: the JNLP agent container
  # Jenkins uses this to communicate with the pod
  # Do NOT remove this or run your steps in it
  - name: jnlp
    image: jenkins/inbound-agent:latest
    resources:
      requests:
        cpu: 100m
        memory: 256Mi

  # Maven container for building and testing the Java service
  - name: maven
    image: maven:3.9-eclipse-temurin-21
    command: [cat]
    tty: true
    resources:
      requests:
        cpu: 500m
        memory: 1Gi
      limits:
        cpu: "1"
        memory: 2Gi
    volumeMounts:
    - name: maven-cache
      mountPath: /root/.m2

  # Docker container for building and pushing the image
  - name: docker
    image: docker:24-dind
    command: [cat]
    tty: true
    securityContext:
      privileged: true    # required for Docker-in-Docker
    resources:
      requests:
        cpu: 500m
        memory: 512Mi

  # kubectl container for Kubernetes deployments
  - name: kubectl
    image: bitnami/kubectl:latest
    command: [cat]
    tty: true
    resources:
      requests:
        cpu: 100m
        memory: 128Mi

  volumes:
  # Shared Maven cache across builds — speeds up dependency downloads
  - name: maven-cache
    persistentVolumeClaim:
      claimName: maven-cache-pvc
'''
        }
    }

    environment {
        APP_NAME    = 'order-service'
        REGISTRY    = 'registry.acmecorp.com'
        IMAGE_TAG   = "${BUILD_NUMBER}-${env.GIT_COMMIT?.take(7) ?: 'local'}"
        DOCKER_CREDS = credentials('docker-registry-credentials')
    }

    stages {

        stage('Checkout') {
            steps {
                checkout scm
                echo "Building ${APP_NAME}:${IMAGE_TAG} in Kubernetes pod"
            }
        }

        stage('Test') {
            steps {
                // 'container' switches to the maven container for these steps
                container('maven') {
                    sh 'mvn --version'
                    sh 'mvn clean test'
                }
            }
            post {
                always {
                    junit 'target/surefire-reports/**/*.xml'
                }
            }
        }

        stage('Build and Push Image') {
            when { branch 'main' }
            steps {
                // Switch to the docker container to build and push the image
                container('docker') {
                    sh """
                        docker login -u ${DOCKER_CREDS_USR} -p ${DOCKER_CREDS_PSW} ${REGISTRY}
                        docker build -t ${REGISTRY}/${APP_NAME}:${IMAGE_TAG} .
                        docker push ${REGISTRY}/${APP_NAME}:${IMAGE_TAG}
                        docker push ${REGISTRY}/${APP_NAME}:latest
                    """
                }
            }
        }

        stage('Deploy to Staging') {
            when { branch 'main' }
            steps {
                // Switch to the kubectl container to interact with the cluster
                container('kubectl') {
                    sh """
                        # Update the image tag in the staging deployment
                        kubectl set image deployment/${APP_NAME} \
                          ${APP_NAME}=${REGISTRY}/${APP_NAME}:${IMAGE_TAG} \
                          --namespace=staging

                        # Wait for the rollout to complete before declaring success
                        kubectl rollout status deployment/${APP_NAME} \
                          --namespace=staging \
                          --timeout=120s
                    """
                }
            }
        }

    }

    post {
        success {
            slackSend(
                channel: '#deployments',
                color: 'good',
                message: "✅ *${APP_NAME}:${IMAGE_TAG}* deployed to staging — <${env.BUILD_URL}|Build #${BUILD_NUMBER}>"
            )
        }
        failure {
            slackSend(
                channel: '#deployments',
                color: 'danger',
                message: "❌ *${APP_NAME}* build failed — <${env.BUILD_URL}|Build #${BUILD_NUMBER}>"
            )
        }
        always { cleanWs() }
    }

}

// Simplified namespace promotion pipeline
// Assumes the Docker image is already built and pushed
// This pipeline handles the environment promotion only
pipeline {
    agent {
        kubernetes {
            yaml '''
spec:
  containers:
  - name: jnlp
    image: jenkins/inbound-agent:latest
  - name: kubectl
    image: bitnami/kubectl:latest
    command: [cat]
    tty: true
'''
        }
    }

    parameters {
        // Release manager picks which image to promote
        string(name: 'IMAGE_TAG', defaultValue: '', description: 'Image tag to promote — e.g. 61-b5c6d7e')
        choice(name: 'TARGET_ENV', choices: ['staging', 'qa', 'production'], description: 'Target namespace')
    }

    stages {

        stage('Validate') {
            steps {
                script {
                    if (!params.IMAGE_TAG) {
                        error('IMAGE_TAG is required')
                    }
                    echo "Promoting order-service:${params.IMAGE_TAG} to ${params.TARGET_ENV}"
                }
            }
        }

        stage('Approve Production') {
            // Only require approval for production deploys
            when {
                expression { return params.TARGET_ENV == 'production' }
            }
            steps {
                input(
                    message: "Deploy order-service:${params.IMAGE_TAG} to PRODUCTION?",
                    ok: 'Promote to Production',
                    submitter: 'release-managers'
                )
            }
        }

        stage('Deploy') {
            steps {
                container('kubectl') {
                    sh """
                        kubectl set image deployment/order-service \
                          order-service=registry.acmecorp.com/order-service:${params.IMAGE_TAG} \
                          --namespace=${params.TARGET_ENV}

                        kubectl rollout status deployment/order-service \
                          --namespace=${params.TARGET_ENV} \
                          --timeout=180s
                    """
                }
            }
        }

    }

    post {
        success {
            echo "✅ order-service:${params.IMAGE_TAG} successfully deployed to ${params.TARGET_ENV}"
        }
        failure {
            echo "❌ Promotion of order-service:${params.IMAGE_TAG} to ${params.TARGET_ENV} failed"
        }
    }
}