[CI/CD] Jenkins + Docker를 이용한 무중단 배포 - ① Application Linux(Ubuntu)에 SSH를 이용한 파일 전송

 

 

🗂 목차

⚠️ 아래 목차 중 몇몇개의 링크가 걸리지 않는 문제로 글 맨 하단에 다음 글로 이동할 수 있게 해 두었습니다.

✅ [CI/CD] Jenkins와 Gitea 연동
✅ [CI/CD] Jenkins Trigger 정보 Discord로 보내기
✅ [CI/CD] 정적 코드 분석 툴 SonarQube와 Jenkins 연동
✅ [CI/CD] SonarQube를 통해 Code Convention 적용
✅ [DevOps] JAVA Gradle JaCoCo (Code coverage) 설정하기 
✅ [DevOps] JAVA Gradle JaCoCo (Code coverage) 설정하기 (추가)(https://junyharang.tistory.com/392)
✅ [CI/CD] Jenkins + Docker를 이용한 무중단 배포 - ① Application Linuxt(Ubuntu)에 SSH를 이용한 파일 전송
✅ [CI/CD] Jenkins + Docker를 이용한 무중단 배포 - ② Create Docker Image And BackUp
✅ [CI/CD] Jenkins + Docker를 이용한 무중단 배포 - ③ Application Server Docker Job (① Application 도커 존재 여부 확인)
✅ [CI/CD] Jenkins + Docker를 이용한 무중단 배포 - ③ Application Server Docker Job (② Application Docker Run)(https://junyharang.tistory.com/406)
✅ [CI/CD] Jenkins + Docker를 이용한 무중단 배포 - ③ Application Server Docker Job (③ Application Docker Health Check)
✅ [CI/CD] Jenkins + Docker를 이용한 무중단 배포 - ④ NGINX Server Docker Job (① NGINX 각 종 설정) 
✅ [CI/CD] Jenkins + Docker를 이용한 무중단 배포 - ④ NGINX Server Docker Job (② NGINX Docker 존재 여부 확인) 
✅ [CI/CD] Jenkins + Docker를 이용한 무중단 배포 - ④ NGINX Server Docker Job (③ NGINX Docker Run & Health Check)
✅ [CI/CD] Jenkins + Docker를 이용한 무중단 배포 - ④ NGINX Server Docker Job (③ NGINX 재 설정)

🤔 내가 만난 문제

⛔️ [Jenkins] java.lang.OutOfMemoryError: Java heap space

 

 

배포 자동화와 지속적 인도:도커와 젠킨스 쿠버네티스로 만드는

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

 

 

 

🚀 젠킨스에서 리눅스 서버 SSH를 이용한 파일 전송

    🔽 개요

        📦 구성도

CI/CD 무중단 배포 구성도

 

 

 

 

 

 

 

deploy Directory Path

 

 

 

        📦 소개

주니는 이 전 글들을 통해 소나큐브와 젠킨스 그리고, 형상 관리 서비스 gitea를 연동해 보았어요.
이제 실제 Application과 Nginx를 이용해서 주니가 구성한 WAS를 배포하고, 실제 접속이 되는지까지 확인해보려고 해요.

주니가 도커를 이용하려고 하는 이유는 대상 서버 즉, 서비스가 구동될 리눅스 서버에 직접 JDK 등을 설치하고, Application Build File을 SSH를 이용하여 보내 구동 시키고, Nginx를 설치하여 서비스를 할 수도 있지만, 대상 서버에 직접 설치하게 되면 격리화가 되지 않아 문제가 될 수 있으며, 도커를 이용하여 백업도 할 수 있기 때문에 도커를 이용하려고 해요.

구성도를 보면 개발 환경과 운영 환경이 나눠져 있고, 운영 환경에서는 외부망과 NAT로 통신이 가능한 서버와 내부망에서 WAS를 구동 시킬 서버가 나눠져 있고, 젠킨스와 소나큐브 도커 컨테이너가 구동중인 관리용 서버로 나눠져 있는데, 이번 작업에서는 젠킨스를 이용하여 운영 환경에 도커를 이용하여 NGINX와 Spring Boot 무중단 배포 하는 방법에 대해 정리해 보려고 해요.

전통적인 방식의 배포 방식에 문제점 (출처: https://hudi.blog)

무중단 배포란 새로운 Application이 구동 대상 서버로 옮겨지고, 다시 서비스를 재개할 때, 즉, Version 최신화가 이뤄질 때, 기존 전통 방식에서는 서비스가 중단 되었다가 새로운 Version Update가 완료된 뒤 다시 서비스가 재개되는 방식이였는데, 버전 최신화가 이뤄져도 서비스가 중단되지 않고, 배포할 수 있는 방법을 이야기 해요.

💡 참고 사항
무중단 배포 방식

1. Rolling Update

출처: https://hudi.blog

이 방식은 사용 중인 서버에서 새 버전을 점직적으로 즉, 단계별로 교체하는 방식으로 무중단 배포의 가장 기본적인 방식.
서비스 중인 애플리케이션 구동 서버 하나를 로드밸런서에서 Routing 하지 않도록 한 뒤, 새 버전을 다시 라우팅하도록 하는 방법을 반복하여 모든 애플리케이션 구동 서버에 새 버전의 애플리케이션을 배포하는 방식

장점
✅ 대상 서버별로 차례대로 배포를 진행하기 때문에 문제가 발생했을 때, Roll Back 가능.
✅ k8s, elastic geanstalk과 같은 오케스트레이션 도구에서 지원하여 간편하며, 많은 서버 자원 확보를 하지 않아도 됨.

단점
⛔️ 새 버전 배포시 서비스를 하는 서버가 줄어들기 때문에 서비스 중인 서버에 트래픽 증가.
⛔️ 배포가 진행될 때, 구 버전과 신 버전이 같이 서비스 되는 구간이 있기 때문에 호환성 문제 발생.



2. Blue & Green

출처: https://hudi.blog

배포 시 트래픽을 한번에 구버전에서 신버전으로 옮기는 방법으로 해당 전략에서는 현재 운영중인 서비스의 환경을 Blue라고 부르고, 새롭게 배포할 환경을 Green이라고 부름.

Blue와 Green의 서버를 동시에 나란히 구성해둔 상태로 배포 시점에 로드 밸런서가 트래픽을 Blue에서 Green으로 일제히 전환 시키고, Green 배포가 성공적으로 완료 되고, 문제가 없다고 판단되면 Blue 서비스 배포를 한 뒤 Green 서비스 제거 혹은 다음 배포를 위해 유지


장점
✅ 롤링 배포와 달리 한번에 트래픽을 모두 새로운 버전으로 옮기기 때문에 호환성 문제가 발생하지 않음.
✅ 구 버전의 애플리케이션이 그대로 남아있기 때문에 손쉬운 Roll Back 가능
✅ 운영 환경에 영향 없이 새 버전 테스트 가능

단점
⛔️ 실제 운영에 필요한 서버 자원 대비 두 배의 자원 필요. 클라우드 환경에서 운영 시 필요 없는 인스턴스를 제거하면 되지만,
      온프레미스 방식에서는 자원 부담 증가.




2. Canary (카나리) 배포

출처: https://hudi.blog

점진적으로 구버전에 대한 트래픽을 신버전으로 옮기는 것은 롤링 배포 방식과 비슷하지만, 카나리 배포의 핵심은 새로운 버전에 대한 오류 조기 탐지.

소수 인원에 대해서만 트래픽을 새로운 버전에 옮겨둔 상태에서 서비스를 운영하고, 새로운 버전에 이상이 없다고 판단하였을 경우 모든 트래픽을 신규 버전으로 옮기는 방식으로 트래픽을 새로운 버전으로 옮기는 기준은 내부 규칙(특정 유저 등) 혹은 랜덤이다.

즉, 블루 그린 방식처럼 트래픽을 한번에 바꾸는 것이 아니고, 단계적으로 전환하기 때문에 부정적 영향을 최소화 하고, 상황에 따라 트래픽 양 조절하며, Roll Back 가능.

이러한 특징으로 인해 A/B 테스트 진행에 적합.


장점
✅ 새로운 버전으로 인한 위험 최소화
✅ 문제 상황 빠르게 탐지
✅ A/B 테스트 활용 가능 (대조군과 실험군으로 나누어 특정 UI나, 알고리즘 효과 비교 방법론)

단점
⛔️ 네트워크 트래픽 제어 부담
⛔️ 롤링 배포와 마찬가지로 신/구 버전 애플리케이션이 공존하기 때문에 호환성 문제 발생 가능.

 

이번에 주니는 롤링 방식을 채택하여 무중단 배포를 진행해보려고 해요.

롤링 방식을 선택한 이유는 현재 사용하고 있는 서버 한 대에 윈도우 OS를 올리고, Hyper-V 통해 가상 Ubuntu Linux를 여러 대 올려 사용 하고 있는데, 서버 자원적인 문제도 있고, 실제 서버는 한 대이기 때문에 이 방식을 선택하였어요.

 

 

 

 

    🔽 젠킨스

        📦 Jenkins Script (젠킨스 스크립트)

이 전에 작성한 내용과 다르게 젠킨스 스크립트에 많은 변경이 이뤄졌어요.

def SET_VARIABLE = "Jenkins File 변수 설정"
def SONARQUBE_ANALYSIS = "소나큐브 Analysis 확인"
def SONARQUBE_QUALITY_GATE = "소나큐브 Quality Gate 확인"
def APPLICATION_NAME = "total-back-office"

// git 환경 정보 가져오기
def get_commit_message() {  // git Commit Message 가져오기
    script {
        return sh(script: "git show -s --format=%B ${env.GIT_COMMIT}", returnStdout: true).trim()
    }
}

def get_commit_author() {   // git commit 작성자 가져오기
    script {
        return sh(script: "git --no-pager show -s --format=%an ${env.GIT_COMMIT}", returnStdout: true).trim()
    }
}

pipeline {
    agent any
    environment {
        DISCORD_WEBHOOK_URL = credentials("Total-Back-Office-BE-Discord-Webhook")
    }
    stages {
        stage(SET_VARIABLE) {
            steps {
                script {
                    // 구동 환경 설정 (삼항 연산자로 브런치 이름이 master라면 prod 환경이고, 아니면 dev 환경
                    def DRIVE_ENV = env.BRANCH_NAME.equals("master") ? "prod" : "dev"
                    // DRIVE_ENV DRIVE_ENV 변수를 다른 스테이지에서 참조할 수 있도록 환경 변수로 설정
                    env.DRIVE_ENV = DRIVE_ENV

                    // gitea 환경 설정
                    GITEA_CREDENTIAL_ID = "[기깔나는 사람들]gitea-backend"
                    GITEA_REPOSITORY_URL = "http://192.168.20.3:81/giggals-s-people/TotalBackOffice-BackEnd.git"

                    GIT_COMMIT_AUTHOR = get_commit_author()
                    GIT_COMMIT_MESSAGE = get_commit_message()

                    PR_ID = 'PR이 존재하지 않아요.'
                    PR_BRANCH = 'PR이 존재하지 않아요.'
                    if ("${GIT_COMMIT_MESSAGE}".contains('Merge')) {
                        PR_ID = "${GIT_COMMIT_MESSAGE}".substring("${GIT_COMMIT_MESSAGE}".indexOf('#') + 1, "${GIT_COMMIT_MESSAGE}".indexOf(')')).trim()
                        PR_BRANCH = "${GIT_COMMIT_MESSAGE}".split("from")[1].split("into")[0].trim()
                    }

                    // 소나큐브 설정
                    SONARQUBE_SERVER_NAME = 'SonarQube_BackEnd'
                    SONARQUBE_CREDENTIAL_ID = "backend-total-back-office"

                    // TEST Coverage Report Path
                    JUNIT_REPORT_PATH = "build/test-results/test"
                    JACOCO_REPORT_PATH = "build/jacoco/jacoco.xml"
                    CHECKSTYLE_REPORT_PATH = "build/reports/checkstyle-output/checkstyle-report.xml"

                    DISCORD_SEND_MESSAGE_TITLE = "기깔나는 사람들 통합 관리 서비스 무중단 배포"

                    DOCKER_SERVER_BASE_DIRECTORY = "/data/deploy/giggal-total-back-office"
                }
            }

            post {
                success {
                    sendStartAlarmToDiscord()
                }
            }
        } // stage(SET_VARIABLE) 끝

        stage('GITEA CHECKOUT') {
            steps {
                echo "Repository Clone 작업이 시작 되었어요 😀"

                git branch: "${env.BRANCH_NAME}",
                        credentialsId: GITEA_CREDENTIAL_ID,
                        url: GITEA_REPOSITORY_URL
            }

            post {
                success {
                    script {
                        sendSuccessAlarmToDiscord('GITEA CHECKOUT')
                    }
                }

                failure {
                    sendFailedAlarmToDiscord('GITEA CHECKOUT')
                }
            } // Discord Send Post 끝
        } // stage('GITEA CHECKOUT') 끝

        stage('Project Build 그리고 Test 작업') {
            steps {
                script {
                    def startTimeMillis = System.currentTimeMillis()

                    echo 'Project Build 그리고 Test 작업을 시작합니다!'
                    sh './gradlew clean build --stacktrace --warning-mode all --info --console=verbose'

                    def endTimeMillis = System.currentTimeMillis()
                    def requiredTimeMillis = endTimeMillis - startTimeMillis
                    def requiredTimeSecond = requiredTimeMillis / 1000

                    echo 'Project Build 그리고 Test 작업 소요 시간 : ' + requiredTimeSecond + ' 초'
                }
            }

            post {
                success {
                    script {
                        sendSuccessAlarmToDiscord('Project Build 그리고 Test 작업')
                    }
                }

                failure {
                    sendFailedAlarmToDiscord('Project Build 그리고 Test 작업')
                }
            } // Discord Send Post 끝
        } // stage('Project Build 작업') 끝

        stage(SONARQUBE_ANALYSIS) {
            when {
                branch pattern: "(develop|master)", comparator: "REGEXP"
            }

            steps {
                script {
                    def scannerHome = tool 'SonarQube-Scanner'
                    withSonarQubeEnv(credentialsId: SONARQUBE_CREDENTIAL_ID, installationName: SONARQUBE_SERVER_NAME) {
                        sh "${scannerHome}/bin/sonar-scanner \
                        -Dsonar.projectKey=BE-total-back-office \
                        -Dsonar.projectName=BE-total-back-office \
                        -Dsonar.branch.name=master \
                        -Dsonar.language=java \
                        -Dsonar.java.source=1.8 \
                        -Dsonar.sources=src/main/java \
                        -Dsonar.test=src/test/java \
                        -Dsonar.test.inclusion=**/*Test.java \
                        -Dsonar.issuesReport.console.enable=true \
                        -Dsonar.junit.reportPaths=${JUNIT_REPORT_PATH} \
                        -Dsonar.java.binaries=build/classes \
                        -Dsonar.java.coveragePlugin=jacoco \
                        -Dsonar.coverage.jacoco.xmlReportPaths=${JACOCO_REPORT_PATH} \
                        -Dsonar.java.libraries.empty=true \
                        -Dsonar.sourceEncoding=UTF-8 \
                        -Dsonar.java.checkstyle.reportPaths=${CHECKSTYLE_REPORT_PATH} \
                        -Dsonar.exclusions=**/dto/**,**/exception/**,**/constant/**,**/SpringInitProjectApplication.java,**/WebRestController.java,**/FileUploadYaml.java \
                        "
                    }
                }
            }

            post {
                success {
                    script {
                        sendSuccessAlarmToDiscord(SONARQUBE_ANALYSIS)
                    }
                }

                failure {
                    sendFailedAlarmToDiscord(SONARQUBE_ANALYSIS)
                }
            } // Discord Send Post 끝
        } // stage(SONARQUBE_ANALYSIS) 끝

        stage(SONARQUBE_QUALITY_GATE) {
            when {
                branch pattern: "(develop|master)", comparator: "REGEXP"
            }

            steps {
                timeout(time: 5, unit: 'MINUTES') {
                    waitForQualityGate abortPipeline: true
                    script {
                        echo "소나큐브 Quality Gate 검사가 시작 되었어요!"
                        def sonarQubeQualityGate = waitForQualityGate()
                        def qualityGateStatus = sonarQubeQualityGate.status
                        echo "Quality Gate 상태: ${qualityGateStatus}"

                        if (qualityGateStatus != 'OK') {
                            echo "Quality Gate 검증 상태: ${qualityGateStatus}"
                            error "Quality Gate 검증에 실패 하였어요 😭: ${qualityGateStatus}"

                        } else {
                            echo "Quality Gate 검증에 성공 하였어요 😀: ${qualityGateStatus}"
                        }

                        echo "Quality Gate 검증을 모두 완료 하였어요 😎"
                    }
                }
            }

            post {
                success {
                    script {
                        sendSuccessAlarmToDiscord(SONARQUBE_QUALITY_GATE)
                    }
                }

                failure {
                    sendFailedAlarmToDiscord(SONARQUBE_QUALITY_GATE)
                }
            } // Discord Send Post 끝
        } // stage(SONARQUBE_QUALITY_GATE) 끝

        stage('개발 환경 Application 서버에 File 전달 및 스크립트 실행 권한 부여') {
            when {
                expression { env.GIT_BRANCH == 'develop' }
            }

            steps([$class: 'BapSshPromotionPublisherPlugin']) {
                script {
                    def startTimeMillis = System.currentTimeMillis()

                    sshPublisher(
                            continueOnError: false, failOnError: true,

                            publishers: [
                                    sshPublisherDesc(
                                            configName: "op-management-api",
                                            verbose: true,
                                            transfers: [
                                                    sshTransfer(
                                                            remoteDirectory: "deploy/",
                                                            execCommand: "rm -rf *;"),
                                                    sshTransfer(
                                                            remoteDirectory: "deploy/dev/docker/",
                                                            sourceFiles: "build/libs/*.jar"),
                                                    sshTransfer(
                                                            sourceFiles: "deploy/dev/**",
                                                            execCommand: "chmod +x $DOCKER_SERVER_BASE_DIRECTORY/deploy/dev/shell-script/createDockerImageAndBackup.sh; \
                                                                          chmod +x $DOCKER_SERVER_BASE_DIRECTORY/deploy/dev/shell-script/nginxContainerExistenceStatusCheck.sh; \
                                                                          chmod +x $DOCKER_SERVER_BASE_DIRECTORY/deploy/dev/shell-script/application/applicationContainerNewRun.sh; \
                                                                          chmod +x $DOCKER_SERVER_BASE_DIRECTORY/deploy/dev/shell-script/application/applicationHealthCheck.sh; \
                                                                          chmod +x $DOCKER_SERVER_BASE_DIRECTORY/deploy/dev/shell-script/nginx/nginxDockerContainerRun.sh; \
                                                                          chmod +x $DOCKER_SERVER_BASE_DIRECTORY/deploy/dev/shell-script/nginx/nginxServiceSetting.sh; \
                                                                          chmod +x $DOCKER_SERVER_BASE_DIRECTORY/deploy/dev/shell-script/nginx/nginxHealthCheck.sh"),
                                            ]
                                    )
                            ]
                    )

                    def endTimeMillis = System.currentTimeMillis()
                    def requiredTimeMillis = endTimeMillis - startTimeMillis
                    def requiredTimeSecond = requiredTimeMillis / 1000

                    echo '개발 환경 Application 서버에 File 전달 작업 소요 시간 : ' + requiredTimeSecond + ' 초'
                }
            }

            post {
                success {
                    script {
                        sendSuccessAlarmToDiscord('개발 환경 Application 서버에 File 전달 및 스크립트 실행 권한 부여')
                    }
                }

                failure {
                    sendFailedAlarmToDiscord('개발 환경 Application 서버에 File 전달 및 스크립트 실행 권한 부여')
                }
            } // Discord Send Post 끝
        } // stage('개발 환경 Application 서버에 File 전달 및 스크립트 실행 권한 부여') 끝

        stage('개발 환경 Docker Image 생성 및 Backup 작업') {
            when {
                expression { env.GIT_BRANCH == 'develop' }
            }
            steps([$class: 'BapSshPromotionPublisherPlugin']) {
                script {
                    def startTimeMillis = System.currentTimeMillis()

                    sshPublisher(
                            continueOnError: false, failOnError: true,
                            publishers: [
                                    sshPublisherDesc(
                                            configName: "op-management-api",
                                            verbose: true,
                                            transfers: [
                                                    sshTransfer(execCommand: "$DOCKER_SERVER_BASE_DIRECTORY/deploy/dev/shell-script/createDockerImageAndBackup.sh")
                                            ]
                                    )
                            ]
                    )

                    def endTimeMillis = System.currentTimeMillis()
                    def requiredTimeMillis = endTimeMillis - startTimeMillis
                    def requiredTimeSecond = requiredTimeMillis / 1000

                    echo '개발 환경 Docker Image 생성 및 Backup 작업 소요 시간 : ' + requiredTimeSecond + ' 초'
                }
            }

            post {
                success {
                    script {
                        sendSuccessAlarmToDiscord('개발 환경 Docker Image 생성 및 Backup 작업')
                    }
                }

                failure {
                    sendFailedAlarmToDiscord('개발 환경 Docker Image 생성 및 Backup 작업')
                }
            } // Discord Send Post 끝
        } // stage("개발 환경 Docker Image 생성 및 Backup 작업") 끝

        stage('개발 환경 Docker 관련 작업') {
            when {
                expression { env.GIT_BRANCH == 'develop' }
            }
            steps([$class: 'BapSshPromotionPublisherPlugin']) {
                script {
                    def startTimeMillis = System.currentTimeMillis()

                    sshPublisher(
                            continueOnError: false, failOnError: true,
                            publishers: [
                                    sshPublisherDesc(
                                            configName: "op-management-api",
                                            verbose: true,
                                            transfers: [
                                                    sshTransfer(execCommand: "$DOCKER_SERVER_BASE_DIRECTORY/deploy/dev/shell-script/nginxContainerExistenceStatusCheck.sh")
                                            ]
                                    )
                            ]
                    )

                    def endTimeMillis = System.currentTimeMillis()
                    def requiredTimeMillis = endTimeMillis - startTimeMillis
                    def requiredTimeSecond = requiredTimeMillis / 1000

                    echo '개발 환경 Docker 관련 작업 소요 시간 : ' + requiredTimeSecond + ' 초'
                }
            }

            post {
                success {
                    script {
                        sendSuccessAlarmToDiscord('개발 환경 Docker 관련 작업')
                    }
                }

                failure {
                    sendFailedAlarmToDiscord('개발 환경 Docker 관련 작업')
                }
            } // Discord Send Post 끝
        } // stage("개발 환경 Docker 관련 작업") 끝

        stage('운영 환경 WAS 서버에 File 전달 및 스크립트 실행 권한 부여') {
            when {
                expression { env.GIT_BRANCH == 'master' | env.GIT_BRANCH == 'main' }
            }

            steps([$class: 'BapSshPromotionPublisherPlugin']) {
                script {
                    def startTimeMillis = System.currentTimeMillis()

                    sshPublisher(
                            continueOnError: false, failOnError: true,

                            publishers: [
                                    sshPublisherDesc(
                                            configName: "op-total-back-office-was",
                                            verbose: true,
                                            transfers: [
                                                    sshTransfer(
                                                            remoteDirectory: "deploy/",
                                                            execCommand: "rm -rf *;"),
                                                    sshTransfer(
                                                            remoteDirectory: "deploy/prod/was/docker/",
                                                            sourceFiles: "build/libs/*.jar"),
                                                    sshTransfer(
                                                            sourceFiles: "deploy/prod/was/**",
                                                            execCommand: "chmod +x $DOCKER_SERVER_BASE_DIRECTORY/deploy/prod/was/shell-script/createDockerImageAndBackup.sh; \
                                                                          chmod +x $DOCKER_SERVER_BASE_DIRECTORY/deploy/prod/was/shell-script/applicationContainerExistenceStatusCheck.sh; \
                                                                          chmod +x $DOCKER_SERVER_BASE_DIRECTORY/deploy/prod/was/shell-script/application/applicationContainerNewRun.sh; \
                                                                          chmod +x $DOCKER_SERVER_BASE_DIRECTORY/deploy/prod/was/shell-script/application/applicationHealthCheck.sh; \
                                                                          chmod +x $DOCKER_SERVER_BASE_DIRECTORY/deploy/prod/was/shell-script/nginx/nginxDockerContainerRun.sh; \
                                                                          chmod +x $DOCKER_SERVER_BASE_DIRECTORY/deploy/prod/was/shell-script/nginx/nginxServiceSetting.sh; \
                                                                          chmod +x $DOCKER_SERVER_BASE_DIRECTORY/deploy/prod/was/shell-script/nginx/nginxHealthCheck.sh"),
                                            ]
                                    )
                            ]
                    )

                    def endTimeMillis = System.currentTimeMillis()
                    def requiredTimeMillis = endTimeMillis - startTimeMillis
                    def requiredTimeSecond = requiredTimeMillis / 1000

                    echo '운영 환경 Application 서버에 File 전달 및 스크립트 쓰기 권한 설정 작업 소요 시간 : ' + requiredTimeSecond + ' 초'
                }
            }

            post {
                success {
                    script {
                        sendSuccessAlarmToDiscord('운영 환경 Application 서버에 File 전달 및 스크립트 실행 권한 부여')
                    }
                }

                failure {
                    sendFailedAlarmToDiscord('운영 환경 Application 서버에 File 전달 및 스크립트 실행 권한 부여')
                }
            } // Discord Send Post 끝
        } // stage('운영 환경 Application 서버에 File 전달 및 스크립트 실행 권한 부여') 끝

        stage('운영 환경 Docker Image 생성 및 Backup 작업') {
            when {
                expression { env.GIT_BRANCH == 'master' | env.GIT_BRANCH == 'main' }
            }
            steps([$class: 'BapSshPromotionPublisherPlugin']) {
                script {
                    def startTimeMillis = System.currentTimeMillis()

                    sshPublisher(
                            continueOnError: false, failOnError: true,
                            publishers: [
                                    sshPublisherDesc(
                                            configName: "op-total-back-office-was",
                                            verbose: true,
                                            transfers: [
                                                    sshTransfer(execCommand: "$DOCKER_SERVER_BASE_DIRECTORY/deploy/prod/was/shell-script/createDockerImageAndBackup.sh")
                                            ]
                                    )
                            ]
                    )

                    def endTimeMillis = System.currentTimeMillis()
                    def requiredTimeMillis = endTimeMillis - startTimeMillis
                    def requiredTimeSecond = requiredTimeMillis / 1000

                    echo '운영 환경 Docker Image 생성 및 Backup 작업 소요 시간 : ' + requiredTimeSecond + ' 초'
                }
            }

            post {
                success {
                    script {
                        sendSuccessAlarmToDiscord('운영 환경 Docker Image 생성 및 Backup 작업')
                    }
                }

                failure {
                    sendFailedAlarmToDiscord('운영 환경 Docker Image 생성 및 Backup 작업')
                }
            } // Discord Send Post 끝
        } // stage("운영 환경 Application 서버 배포 작업") 끝

        stage('운영 환경 Application Docker 관련 작업') {
            when {
                expression { env.GIT_BRANCH == 'master' | env.GIT_BRANCH == 'main' }
            }
            steps([$class: 'BapSshPromotionPublisherPlugin']) {
                script {
                    def startTimeMillis = System.currentTimeMillis()

                    sshPublisher(
                            continueOnError: false, failOnError: true,
                            publishers: [
                                    sshPublisherDesc(
                                            configName: "op-total-back-office-was",
                                            verbose: true,
                                            transfers: [
                                                    sshTransfer(execCommand: "$DOCKER_SERVER_BASE_DIRECTORY/deploy/prod/was/shell-script/application/applicationContainerExistenceStatusCheck.sh")
                                            ]
                                    )
                            ]
                    )

                    def endTimeMillis = System.currentTimeMillis()
                    def requiredTimeMillis = endTimeMillis - startTimeMillis
                    def requiredTimeSecond = requiredTimeMillis / 1000

                    echo '운영 환경 Application Docker 관련 작업 소요 시간 : ' + requiredTimeSecond + ' 초'
                }
            }

            post {
                success {
                    script {
                        sendSuccessAlarmToDiscord('운영 환경 Application Docker 관련 작업')
                    }
                }

                failure {
                    sendFailedAlarmToDiscord('운영 환경 Application Docker 관련 작업')
                }
            } // Discord Send Post 끝
        } // stage("운영 환경 Docker 관련 작업") 끝

        stage('운영 환경 DMZ 서버 NGINX 관련 File 전달 및 스크립트 실행 권한 부여') {
            when {
                expression { env.GIT_BRANCH == 'master' | env.GIT_BRANCH == 'main' }
            }

            steps([$class: 'BapSshPromotionPublisherPlugin']) {
                script {
                    def startTimeMillis = System.currentTimeMillis()

                    sshPublisher(
                            continueOnError: false, failOnError: true,

                            publishers: [
                                    sshPublisherDesc(
                                            configName: "op-total-back-office-nginx",
                                            verbose: true,
                                            transfers: [
                                                    sshTransfer(
                                                            remoteDirectory: "deploy/",
                                                            execCommand: "rm -rf *;"),
                                                    sshTransfer(
                                                            sourceFiles: "deploy/prod/nginx/**",
                                                            execCommand: "chmod +x $DOCKER_SERVER_BASE_DIRECTORY/deploy/prod/nginx/shell-script/nginxContainerExistenceStatusCheck.sh; \
                                                                          chmod +x $DOCKER_SERVER_BASE_DIRECTORY/deploy/prod/nginx/shell-script/nginxDockerContainerRun.sh; \
                                                                          chmod +x $DOCKER_SERVER_BASE_DIRECTORY/deploy/prod/nginx/shell-script/nginxServiceSetting.sh; \
                                                                          chmod +x $DOCKER_SERVER_BASE_DIRECTORY/deploy/prod/nginx/shell-script/nginxHealthCheck.sh"),
                                            ]
                                    )
                            ]
                    )

                    def endTimeMillis = System.currentTimeMillis()
                    def requiredTimeMillis = endTimeMillis - startTimeMillis
                    def requiredTimeSecond = requiredTimeMillis / 1000

                    echo '운영 환경 DMZ 서버 NGINX 관련 File 전달 및 스크립트 실행 권한 부여 작업 소요 시간 : ' + requiredTimeSecond + ' 초'
                }
            }

            post {
                success {
                    script {
                        sendSuccessAlarmToDiscord('운영 환경 DMZ 서버 NGINX 관련 File 전달 및 스크립트 실행 권한 부여')
                    }
                }

                failure {
                    sendFailedAlarmToDiscord('운영 환경 DMZ 서버 NGINX 관련 File 전달 및 스크립트 실행 권한 부여')
                }
            } // Discord Send Post 끝
        } // stage('운영 환경 DMZ 서버 NGINX 관련 File 전달 및 스크립트 실행 권한 부여') 끝

        stage('운영 환경 DMZ 서버 NGINX Docker 관련 작업') {
            when {
                expression { env.GIT_BRANCH == 'master' | env.GIT_BRANCH == 'main' }
            }
            steps([$class: 'BapSshPromotionPublisherPlugin']) {
                script {
                    def startTimeMillis = System.currentTimeMillis()

                    sshPublisher(
                            continueOnError: false, failOnError: true,
                            publishers: [
                                    sshPublisherDesc(
                                            configName: "op-total-back-office-nginx",
                                            verbose: true,
                                            transfers: [
                                                    sshTransfer(execCommand: "$DOCKER_SERVER_BASE_DIRECTORY/deploy/prod/nginx/shell-script/nginxContainerExistenceStatusCheck.sh")
                                            ]
                                    )
                            ]
                    )

                    def endTimeMillis = System.currentTimeMillis()
                    def requiredTimeMillis = endTimeMillis - startTimeMillis
                    def requiredTimeSecond = requiredTimeMillis / 1000

                    echo '운영 환경 DMZ 서버 NGINX Docker 관련 작업 소요 시간 : ' + requiredTimeSecond + ' 초'
                }
            }

            post {
                success {
                    script {
                        sendSuccessAlarmToDiscord('운영 환경 DMZ 서버 NGINX Docker 관련 작업')
                    }
                }

                failure {
                    sendFailedAlarmToDiscord('운영 환경 DMZ 서버 NGINX Docker 관련 작업')
                }
            } // Discord Send Post 끝
        } // stage("운영 환경 Docker 관련 작업") 끝

        stage('Jenkins CI/CD 작업 완료') {
            steps {
                sh 'echo "Jenkins CI/CD 작업이 완료 되었어요. 😎"'
            }

            post {
                success {
                    sendEndSuccessAlarmToDiscord()
                }

                failure {
                    sendEndFailedAlarmToDiscord()
                }
            } // Discord Send Post 끝
        } // stage('Jenkins CI/CD 작업 완료') 끝
    } // stages 끝
}

void sendStartAlarmToDiscord() {
    discordSend(
            title: DISCORD_SEND_MESSAGE_TITLE,
            description: "${DRIVE_ENV} 환경 배포 작업 시작 합니다.",
            footer: "==============배포 작업 시작============\n\n"
                    + "통합 관리 WAS 배포 작업이 시작되었어요.\n"
                    + "${env.JOB_NAME}(${env.BUILD_NUMBER})\n\n"
                    + "Git Pull Request ID 정보 \n"
                    + "${PR_ID}\n\n"
                    + "Git Pull Request BRANCH 정보 \n"
                    + "${PR_BRANCH}\n\n"
                    + "Git COMMIT 유발자 정보 \n"
                    + "${GIT_COMMIT_AUTHOR}\n\n"
                    + "Git COMMIT Message \n"
                    + "${GIT_COMMIT_MESSAGE}\n\n"
                    + "Build URL 정보 \n\n",
            link: env.BUILD_URL,
            result: currentBuild.currentResult,
            webhookURL: DISCORD_WEBHOOK_URL
    )
}

void sendSuccessAlarmToDiscord(String stage) {
    discordSend(
            title: stage,
            description: stage + " 작업 성공했어요. 😀 ",
            footer: "ⓒ 2023. 기깔나는 사람들(giggals.pepole@gmail.com) All Rights Reserved. Blog : https://giggal-people.tistory.com/\n",
            link: env.BUILD_URL,
            result: currentBuild.currentResult,
            webhookURL: DISCORD_WEBHOOK_URL
    )
}

void sendSuccessAlarmAndRequiredTimeToDiscord(String stage, BigDecimal requiredTime) {
    discordSend(
            title: stage,
            description: stage + " 작업 성공했어요. 😀 \n " + "작업 소요 시간 : " + requiredTime + " 초",
            footer: "ⓒ 2023. 기깔나는 사람들(giggals.pepole@gmail.com) All Rights Reserved. Blog : https://giggal-people.tistory.com/\n",
            link: env.BUILD_URL,
            result: currentBuild.currentResult,
            webhookURL: DISCORD_WEBHOOK_URL
    )
}

void sendFailedAlarmToDiscord(String stage) {
    discordSend(
            title: stage,
            description: stage + " 작업 실패 했어요 😤",
            footer: "ⓒ 2023. 기깔나는 사람들(giggals.pepole@gmail.com) All Rights Reserved. Blog : https://giggal-people.tistory.com/\n",
            link: env.BUILD_URL,
            result: currentBuild.currentResult,
            webhookURL: DISCORD_WEBHOOK_URL
    )
}

void sendBuildSuccessAlarmToDiscord(String stage, String environment) {
    discordSend(
            title: environment + stage,
            description: environment + stage + " 작업 성공했어요. 😀 ",
            footer: "ⓒ 2023. 기깔나는 사람들(giggals.pepole@gmail.com) All Rights Reserved. Blog : https://giggal-people.tistory.com/\n",
            link: env.BUILD_URL,
            result: currentBuild.currentResult,
            webhookURL: DISCORD_WEBHOOK_URL
    )
}

void sendBuildFailedAlarmToDiscord(String stage, String environment) {
    discordSend(
            title: environment + stage,
            description: environment + stage + " 작업 실패 했어요 😤",
            footer: "ⓒ 2023. 기깔나는 사람들(giggals.pepole@gmail.com) All Rights Reserved. Blog : https://giggal-people.tistory.com/\n",
            link: env.BUILD_URL,
            result: currentBuild.currentResult,
            webhookURL: DISCORD_WEBHOOK_URL
    )
}

void sendEndSuccessAlarmToDiscord() {
    discordSend(
            title: DISCORD_SEND_MESSAGE_TITLE,
            description: "${DRIVE_ENV} 환경 배포 작업이 성공적으로 끝났어요.",
            footer: "==============배포 작업 끝============\n"
                    + "ⓒ 2023. 기깔나는 사람들(giggals.pepole@gmail.com) All Rights Reserved. Blog : https://giggal-people.tistory.com/\n\n",
            link: env.BUILD_URL,
            result: currentBuild.currentResult,
            webhookURL: DISCORD_WEBHOOK_URL
    )
}

void sendEndFailedAlarmToDiscord() {
    discordSend(
            title: DISCORD_SEND_MESSAGE_TITLE,
            description: "${DRIVE_ENV} 환경 배포 작업이 실패로 끝났어요.",
            footer: "==============배포 작업 끝============\n"
                    + "ⓒ 2023. 기깔나는 사람들(giggals.pepole@gmail.com) All Rights Reserved. Blog : https://giggal-people.tistory.com/\n\n",
            link: env.BUILD_URL,
            result: currentBuild.currentResult,
            webhookURL: DISCORD_WEBHOOK_URL
    )
}

728x90

위의 내용을 알아보기 전에 젠킨스에서 대상 서버 즉, 애플리케이션이 구동될 서버와 SSH로 연결하는 작업이 필요해요.

이 방법에 대해서는 이 곳에 정성스럽게 준비 해 두었어요.

[Jenkins] Publish Over SSH Plugin을 이용한 대상 서버 SSH 이용

 

이번 글에서는 Jenkins에서 SSH를 이용해서 Spring Boot jar File과 배포에 필요한 Shell Script
그리고, Nginx 관련 File 전송 방법에 대해 정리해 볼게요.

jenkinsfile 349 ~ 384

소나큐브의 품질 게이트 검증까지 모두 마무리가 되면 운영 환경에 배포할 당시 이 곳이 먼저 실행되게 되요.

최초 when 절을 통해 push 된 Git Branch 이름을 분기하게 되는데, 해당 Branch가 master이거나, main이면 이 stage가 동작하도록 해 준거에요.

해당 steps는 젠킨스의 sshPublisher 플러그인을 사용하여 대상 서버에 SSH를 이용하여 파일을 전달하거나, 명령어를 실행할 수 있게 해 주는 플러그인을 사용한 부분이에요.

💡 참고 사항
Jenkins sshPublisher Plugin

젠킨스 -> Jenkins 관리 -> Plugin Manager

해당 플러그인은 위와 같이 설치해 주어야 이용 가능.

 

그런 뒤 356번째 줄에 해당 Stage 경과 시간을 알고 싶어서 시작 시각을 ms으로 찍어 startTimeMillis 변수에 담아 주었어요.

359 ~ 366번째 줄에 Option 내용은 아래와 같아요.

💡 참고 사항
sshPublisher는 Jenkins에서 제공하는 플러그인 중 하나인 SSH Publisher 플러그인을 사용하는 명령

1. continueOnError: Jenkins 작업 중 문제가 발생하였을 때, 다음 단계로 넘어갈지에 대한 여부를 결정하는 Option.
false일 경우 sshPublisher 작업 중 문제 발생 시 해당 작업은 중지되고, 실패로 표시.

2. FailOnError: Jenkins 작업 중 문제가 발생하였을 때, 작업을 중지하고, 실패로 표시할지 여부를 결정하는 Option.
true일 경우 sshPublisher 작업 중 문제 발생 시 해당 작업은 중지되고, 실패로 표시

3. publishers[] : SSH Publisher Section 설정

4. sshPublisherDesc() : SSH 전송 작업 정의 Method. 해당 메서드는 다양한 매개 변수를 사용하여 SSH 전송 구성을 세부적으로 지정 가능. 

5. configName: SSH 전송 구성 이름을 나타내는 매개 변수로 젠킨스에서 사전에 구성된 SSH 전송 설정을 참고하여 대상 서버에 SSH 접속 시도

6. verbose: 전송 작업에 자세한 내용 출력 여부를 활성화하는 매개변수로 true일 경우 전송 작업의 상세 정보 출력.

7. transfers: 전송 File 혹은 Directory 구성을 정의하는 매개 변수. sshTransfer 메서드를 사용하여 각 전송을 지정.
sshTransfer 메서드 매개변수로는 전송할 파일 혹은 디렉토리의 경로 등을 지정.

 

jenkinsfile 363 ~ 384

363번째 줄에 configName은 젠킨스 sshPublisher Plugin에서 대상 서버 설정 시에 사용했던
Hostname 값을 넣어주어야 해요.

젠킨스 관리 -> Configure System

반응형

바로 이 부분에 값을 입력해 주면 된답니다.

366 ~ 368번째 줄에서 remoteDirectory에 입력해 준 deploy/ 는 전송할 파일 혹은 디렉토리가 애플리케이션 구동 대상 서버 호스트 어느 디렉토리로 전송될지를 나타내는 매개변수에요.
즉, 젠킨스 SSH 설정에서 Remote Directory를 /data/deploy/giggal-total-back-office라고 정의해주었기 때문에 대당 디렉토리 하위에 deploy를 가르키게 된답니다.

368번째 줄에 execCommand 부분은 애플리케이션 구동 대상 서버 호스트에서 실행할 명령어를 나타내는 매개변수로써 주니는 rm -rf * 명령어 즉, 해당 디렉토리에 모든 내용을 삭제하라는 명령어를 주었어요.

그런 뒤 370번째 줄에 다시 remoteDirectory를 deploy/prod/was/docker/ 라고 설정해 주었고, 
sourceFiles를 통해 Spring Boot Project 최상단에 위치한 build Directory 밑에 libs 밑에 위치한 확장자가 .jar 인 파일을 다 애플리케이션 구동 대상 서버 호스트의 deploy/prod/was/docker/ 밑에 보내라고 해 준거에요.

그리고, 372번째 줄에 Spring Boot Project 최상단에 위치한 deploy Directory 밑에 prod/was 하위에 있는 모든 내용을 애플리케이션 구동 대상 서버 호스트의 /data/deploy/giggal-total-back-office 밑에 보내라고 해 주었어요.

374 ~ 380번째 줄까지는 실제 애플리케이션 구동 대상 서버 호스트에서 도커 배포 및 백업 등에 작업을 처리할 ShellScript에 실행 권한을 주게하여 실행될 수 있도록 처리해 준 부분이에요.

jenkinsfile 386 ~ 405

356번째 줄에 해당 Stage 총 경과 시간을 알기 위해 시작 시각을 ms로 변수에 담아 주었다고 했었어요.

386번째 줄에는 해당 Stage가 끝난 시각을 ms로 endTimeMillis에 담아주었어요.
그리고, 끝난 시각에서 시작 시각을 빼서 requiredTimeMillis 변수에 담아주고, 이를 1000으로 나눠 ms를 초로 바꿔준 뒤 requiredTimeSecond 변수에 담아 주었어요.

그런 뒤 echo 명령어를 통해 해당 Stage 동작 소요 시간이 출력되게 해 주었어요.

post 절에서 해당 Stage 성공 여부에 따라 Discord에 알림이 가도록 해 주었어요.

성공하게 되면 sendSuccessAlarmToDiscord() 가 해당 Stage 제목을 가지고 호출되게 하였고, 실패하게 되면 sendFailedAlarmToDiscord()를 마찬가지로 Stage 제목을 가지고 호출하게 해 주었어요.

jenkinsfile 625 ~ 645

그럼 성공과 실패에 따라 위의 함수가 호출되게 되고, 이에 따라 아래와 같이 Discord에 알림이 오게 된답니다.

Stage 성공 시

 

Stage 실패 시

이번 글에는 여기까지 정리하고, 다음 글에서는 도커 이미지를 만들고, 백업하는 방법에 대해 정리해 볼게요.

배포 자동화와 지속적 인도:도커와 젠킨스 쿠버네티스로 만드는

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

 

 

이전 글: [DevOps] JAVA Gradle JaCoCo (Code coverage) 설정하기 (추가)

다음 글: [CI/CD] Jenkins + Docker를 이용한 무중단 배포 - ② Create Docker Image And BackUp