phonebill/deployment/cicd/Jenkinsfile

def PIPELINE_ID = "${env.BUILD_NUMBER}"

def getImageTag() {
    def dateFormat = new java.text.SimpleDateFormat('yyyyMMddHHmmss')
    def currentDate = new Date()
    return dateFormat.format(currentDate)
}

podTemplate(
    cloud: 'k8s',
    label: "${PIPELINE_ID}",
    serviceAccount: 'jenkins',
    slaveConnectTimeout: 300,
    idleMinutes: 1,
    activeDeadlineSeconds: 3600,
    podRetention: never(),
    yaml: '''
        spec:
          terminationGracePeriodSeconds: 3
          restartPolicy: Never
    ''',
    containers: [
        containerTemplate(
            name: 'podman',
            image: "mgoltzsche/podman",
            ttyEnabled: true,
            command: 'cat',
            privileged: true,
            resourceRequestCpu: '500m',
            resourceRequestMemory: '2Gi',
            resourceLimitCpu: '2000m',
            resourceLimitMemory: '4Gi'
        ),
        containerTemplate(
            name: 'gradle',
            image: 'gradle:jdk21',
            ttyEnabled: true,
            command: 'cat',
            resourceRequestCpu: '500m',
            resourceRequestMemory: '1Gi',
            resourceLimitCpu: '1000m',
            resourceLimitMemory: '2Gi',
            envVars: [
                envVar(key: 'DOCKER_HOST', value: 'unix:///run/podman/podman.sock'),
                envVar(key: 'TESTCONTAINERS_DOCKER_SOCKET_OVERRIDE', value: '/run/podman/podman.sock'),
                envVar(key: 'TESTCONTAINERS_RYUK_DISABLED', value: 'true')
            ]
        ),
        containerTemplate(
            name: 'kubectl',
            image: 'hiondal/azure-kubectl:latest',
            command: 'cat',
            ttyEnabled: true,
            resourceRequestCpu: '200m',
            resourceRequestMemory: '512Mi',
            resourceLimitCpu: '500m',
            resourceLimitMemory: '1Gi'
        )
    ],
    volumes: [
        emptyDirVolume(mountPath: '/home/gradle/.gradle', memory: false),
        emptyDirVolume(mountPath: '/root/.azure', memory: false),
        emptyDirVolume(mountPath: '/run/podman', memory: false)
    ]
) {
    node(PIPELINE_ID) {
        def props
        def imageTag = getImageTag()
        def environment = params.ENVIRONMENT ?: 'dev'
        def skipSonarQube = params.SKIP_SONARQUBE ?: 'true'
        def services = ['api-gateway', 'user-service', 'bill-service', 'product-service', 'kos-mock']

        try {
            stage("Get Source") {
                checkout scm
                props = readProperties file: "deployment/cicd/config/deploy_env_vars_${environment}"
            }

            stage("Setup Kubernetes2") {
                container('kubectl') {
                    sh """
                          kubectl create namespace ${props.namespace} --dry-run=client -o yaml | kubectl apply -f -
                        """
                }
            }

            stage('Build') {
                container('gradle') {
                    sh """
                        chmod +x gradlew
                        ./gradlew build -x test
                    """
                }
            }

            stage('SonarQube Analysis & Quality Gate') {
                if (skipSonarQube) {
                    echo "⏭️ Skipping SonarQube Analysis (SKIP_SONARQUBE=${params.SKIP_SONARQUBE})"
                } else {
                    container('gradle') {
                        // 각 서비스별로 개별적으로 SonarQube 분석 및 Quality Gate 확인
                        services.each { service ->
                            withSonarQubeEnv('SonarQube') {
                                echo "🔍 Starting SonarQube analysis for ${service}..."

                                // 서비스별 테스트 및 SonarQube 분석
                                sh """
                                    ./gradlew :${service}:test :${service}:jacocoTestReport :${service}:sonar \
                                        -Dsonar.projectKey=phonebill-${service}-${environment} \
                                        -Dsonar.projectName=phonebill-${service}-${environment} \
                                        -Dsonar.java.binaries=build/classes/java/main \
                                        -Dsonar.coverage.jacoco.xmlReportPaths=build/reports/jacoco/test/jacocoTestReport.xml \
                                        -Dsonar.exclusions=**/config/**,**/entity/**,**/dto/**,**/*Application.class,**/exception/**
                                """

                                echo "✅ SonarQube analysis completed for ${service}"
                            }

                            // 각 서비스별 Quality Gate 확인
                            timeout(time: 5, unit: 'MINUTES') {
                                echo "⏳ Waiting for Quality Gate result for ${service}..."
                                def qg = waitForQualityGate()
                                if (qg.status != 'OK') {
                                    error "❌ Quality Gate failed for ${service}: ${qg.status}"
                                } else {
                                    echo "✅ Quality Gate passed for ${service}"
                                }
                            }
                        }

                        echo "🎉 All services passed SonarQube Quality Gates!"
                    }
                }
            }

            stage('Build & Push Images') {
                timeout(time: 30, unit: 'MINUTES') {
                    container('podman') {
                        withCredentials([
                            usernamePassword(
                                credentialsId: 'imagereg-credentials',
                                usernameVariable: 'IMG_USERNAME',
                                passwordVariable: 'IMG_PASSWORD'
                            ),
                            usernamePassword(
                                credentialsId: 'dockerhub-credentials',
                                usernameVariable: 'DOCKERHUB_USERNAME',
                                passwordVariable: 'DOCKERHUB_PASSWORD'
                            )
                        ]) {
                            // Docker Hub 로그인 (rate limit 해결)
                            sh "podman login docker.io --username \$DOCKERHUB_USERNAME --password \$DOCKERHUB_PASSWORD"

                            // Image Registry 로그인
                            sh "podman login docker.io --username \$IMG_USERNAME --password \$IMG_PASSWORD"

                            services.each { service ->
                                sh """
                                    podman build \
                                        --build-arg BUILD_LIB_DIR="${service}/build/libs" \
                                        --build-arg ARTIFACTORY_FILE="${service}.jar" \
                                        -f deployment/container/Dockerfile-backend \
                                        -t docker.io/hiondal/${service}:${environment}-${imageTag} .

                                    podman push docker.io/hiondal/${service}:${environment}-${imageTag}
                                """
                            }
                        }
                    }
                }
            }

            stage('Update Kustomize & Deploy') {
                container('kubectl') {
                    def namespace = props.namespace
                    sh """
                        # Kustomize 설치 (sudo 없이 사용자 디렉토리에 설치)
                        curl -s "https://raw.githubusercontent.com/kubernetes-sigs/kustomize/master/hack/install_kustomize.sh" | bash
                        mkdir -p \$HOME/bin
                        mv kustomize \$HOME/bin/
                        export PATH=\$PATH:\$HOME/bin

                        # 환경별 디렉토리로 이동
                        cd deployment/cicd/kustomize/overlays/${environment}

                        # 서비스 목록 정의 (공백으로 구분)
                        services="api-gateway user-service bill-service product-service kos-mock"

                        # 이미지 태그 업데이트
                        for service in \$services; do
                            \$HOME/bin/kustomize edit set image docker.io/hiondal/\$service=docker.io/hiondal/\$service:${environment}-${imageTag}
                        done

                        # 매니페스트 적용
                        kubectl apply -k .

                        # 배포 상태 확인
                        echo "Waiting for deployments to be ready..."
                        for service in \$services; do
                            kubectl -n ${namespace} wait --for=condition=available deployment/\$service --timeout=300s
                        done
                    """
                }
            }

            // 파이프라인 완료 로그 (Scripted Pipeline 방식)
            stage('Pipeline Complete') {
                echo "🧹 Pipeline completed. Pod cleanup handled by Jenkins Kubernetes Plugin."

                // 성공/실패 여부 로깅
                if (currentBuild.result == null || currentBuild.result == 'SUCCESS') {
                    echo "✅ Pipeline completed successfully!"
                } else {
                    echo "❌ Pipeline failed with result: ${currentBuild.result}"
                }
            }

        } catch (Exception e) {
            currentBuild.result = 'FAILURE'
            echo "❌ Pipeline failed with exception: ${e.getMessage()}"
            throw e
        } finally {
            echo "🧹 Cleaning up resources and preparing for pod termination..."
            echo "Pod will be terminated in 3 seconds due to terminationGracePeriodSeconds: 3"
        }
    }
}