project-auto-wizard 0.13.3 → 0.14.0

package/payload/workflows/spring/server-deploy/PROJECT-SPRING-NONSTOP-NGINX-CICD.yaml

@@ -1,66 +1,66 @@
 # project-auto-wizard:managed-workflow
-# Spring Boot 무중단 배포 (Nginx Blue-Green, SSH + Docker)
+# Spring Boot zero-downtime deploy (Nginx Blue-Green, SSH + Docker)
 #
-# deploy 브랜치 푸시 시 Docker 이미지를 빌드하고
-# nginx config 의 proxy_pass 포트 토글로 Blue-Green 무중단 배포합니다.
+# On a push to the deploy branch, builds a Docker image and
+# deploys it Blue-Green with no downtime by toggling the proxy_pass port in the nginx config.
 #
-# 본 워크플로우는 무중단 배포 옵션입니다.
-# 기본 배포는 PROJECT-SPRING-SIMPLE-CICD.yaml 입니다.
-# 전환하려면 아래 push.branches 주석 해제 + SIMPLE-CICD 의 push 트리거 주석 처리.
+# This workflow is the zero-downtime deploy option.
+# The default deploy is PROJECT-SPRING-SIMPLE-CICD.yaml.
+# To switch, uncomment push.branches below and comment out the push trigger in SIMPLE-CICD.
 #
-# 필수 GitHub Secrets
-# APPLICATION_PROD_YML (선택): application-prod.yml 내용
-# DOCKERHUB_USERNAME: DockerHub 사용자명
-# DOCKERHUB_TOKEN: DockerHub 액세스 토큰
-# SERVER_HOST: 배포 서버 주소
-# SERVER_USER: SSH 사용자명
-# SERVER_PASSWORD: SSH 비밀번호 (SSH_AUTH_METHOD=password일 때)
-# SSH_KEY: SSH 개인키 .pem 내용 (SSH_AUTH_METHOD=key일 때, AWS EC2 등)
+# Required GitHub Secrets
+# APPLICATION_PROD_YML (optional): contents of application-prod.yml
+# DOCKERHUB_USERNAME: DockerHub username
+# DOCKERHUB_TOKEN: DockerHub access token
+# SERVER_HOST: deployment server address
+# SERVER_USER: SSH username
+# SERVER_PASSWORD: SSH password (when SSH_AUTH_METHOD=password)
+# SSH_KEY: contents of the SSH private key .pem (when SSH_AUTH_METHOD=key, e.g. AWS EC2)
 #
-# 환경변수 설정 (env 섹션에서 설정)
+# Environment variables (set in the env section)
 #
-# 포트 및 컨테이너:
-# PROJECT_NAME: 프로젝트명 (컨테이너/이미지 이름)
-# SERVICE_DOMAIN: 외부 도메인 (nginx server_name 과 일치)
-# CONTAINER_INTERNAL_PORT: Spring Boot 내부 포트 (기본: 8080)
-# BLUE_PORT: Blue 호스트 노출 포트 (기본: 8080)
-# GREEN_PORT: Green 호스트 노출 포트 (기본: 8081)
+# Ports and containers:
+# PROJECT_NAME: project name (container/image name)
+# SERVICE_DOMAIN: external domain (must match the nginx server_name)
+# CONTAINER_INTERNAL_PORT: Spring Boot internal port (default: 8080)
+# BLUE_PORT: host port exposed by Blue (default: 8080)
+# GREEN_PORT: host port exposed by Green (default: 8081)
 #
 # Nginx:
-# NGINX_RP_CONF: nginx 역방향 프록시 config 파일 경로
-# NGINX_BACKUP_DIR: nginx config 백업 디렉토리
-# NGINX_BACKUP_KEEP: 백업 보존 개수 (기본: 10)
+# NGINX_RP_CONF: path of the nginx reverse proxy config file
+# NGINX_BACKUP_DIR: directory for nginx config backups
+# NGINX_BACKUP_KEEP: number of backups to keep (default: 10)
 #
-# 볼륨/스토리지:
-# ENABLE_VOLUME_MOUNT: 볼륨 마운트 여부 (true/false)
-# VOLUME_HOST_PATH: 호스트 볼륨 경로
-# VOLUME_CONTAINER_PATH: 컨테이너 내부 마운트 경로
+# Volume/storage:
+# ENABLE_VOLUME_MOUNT: whether to mount a volume (true/false)
+# VOLUME_HOST_PATH: host volume path
+# VOLUME_CONTAINER_PATH: mount path inside the container
 #
-# SSH 연결:
-# SSH_PORT: SSH 포트 (기본: 2022)
-# SSH_COMMAND_TIMEOUT: 명령 타임아웃 (기본: 600s)
-# SSH_CONNECTION_TIMEOUT: 연결 타임아웃 (기본: 60s)
+# SSH connection:
+# SSH_PORT: SSH port (default: 2022)
+# SSH_COMMAND_TIMEOUT: command timeout (default: 600s)
+# SSH_CONNECTION_TIMEOUT: connection timeout (default: 60s)
 #
-# 헬스체크:
-# HEALTHCHECK_PATH: HTTP 경로 (기본: /actuator/health, fallback: /)
-# HEALTHCHECK_MAX_RETRIES: 컨테이너 헬스체크 최대 횟수 (기본: 120)
-# HEALTHCHECK_RETRY_INTERVAL: 재시도 간격 초 (기본: 1)
-# DOMAIN_CHECK_RETRIES: nginx reload 후 도메인 검증 횟수 (기본: 10)
-# DOMAIN_CHECK_INTERVAL: 도메인 검증 간격 초 (기본: 2)
-# IN_FLIGHT_WAIT: old 컨테이너 제거 전 대기 초 (기본: 5)
+# Health check:
+# HEALTHCHECK_PATH: HTTP path (default: /actuator/health, fallback: /)
+# HEALTHCHECK_MAX_RETRIES: max container health check attempts (default: 120)
+# HEALTHCHECK_RETRY_INTERVAL: retry interval in seconds (default: 1)
+# DOMAIN_CHECK_RETRIES: domain check attempts after the nginx reload (default: 10)
+# DOMAIN_CHECK_INTERVAL: domain check interval in seconds (default: 2)
+# IN_FLIGHT_WAIT: seconds to wait before removing the old container (default: 5)
 #
-# 사전 조건:
-#   - 서버에 nginx 설치 + sites-enabled config 존재
-#   - 해당 config 의 server 블록에 다음 라인 존재:
+# Prerequisites:
+#   - nginx is installed on the server and a sites-enabled config exists
+#   - the server block of that config contains these lines:
 #       server_name ${SERVICE_DOMAIN};
-#       proxy_pass http://127.0.0.1:${BLUE_PORT};   # 또는 ${GREEN_PORT}
-#   - SSH 사용자가 sudo 로 nginx -t / reload, docker 명령 실행 가능
+#       proxy_pass http://127.0.0.1:${BLUE_PORT};   # or ${GREEN_PORT}
+#   - the SSH user can run nginx -t / reload and docker commands via sudo
 
 name: PROJECT-SPRING-NONSTOP-NGINX-CICD
 
-# 트리거 설정
-# deploy 브랜치 push 자동 트리거는 주석 처리되어 있습니다.
-# 본 워크플로우로 전환하려면 아래 push.branches 주석을 해제하세요.
+# Trigger settings
+# The automatic trigger on a push to the deploy branch is commented out.
+# To switch to this workflow, uncomment push.branches below.
 on:
   # push:
   #   branches:
@@ -68,51 +68,51 @@ on:
   workflow_dispatch:
 
 env:
-  # 프로젝트 설정 - 실제 프로젝트명으로 변경하세요
+  # Project settings - change to your actual project name
   PROJECT_NAME: "__PROJECT_NAME__"  # @wizard ask:@repo
-  # 모노레포(--paths)에서 이 프로젝트가 있는 하위 경로. 빌드·Docker context의 기준 ('.'이면 레포 루트)
+  # Subdirectory of this project in a monorepo (--paths). Base for the build and Docker context ('.' = repo root)
   PROJECT_PATH: "."  # @wizard auto:project-path
-  # 모노레포(PROJECT_PATH가 '.'이 아님)에서는 이미지·컨테이너·도메인 이름에 '-spring'를 붙여
-  # 같은 레포의 다른 타입 서비스와 이름이 겹치지 않게 한다 (예: my-app-spring)
+  # In a monorepo (PROJECT_PATH is not '.') '-spring' is appended to image, container and domain names
+  # so they do not collide with services of other types in the same repo (e.g. my-app-spring)
   SERVICE_DOMAIN: "__SERVICE_DOMAIN__"  # @wizard ask:example.com
 
-  # Spring Boot 설정
+  # Spring Boot settings
   SPRING_PROFILE: "prod"
   JAVA_VERSION: "__JAVA_VERSION__"  # @wizard ask:@jdk
   GRADLE_OPTS: "-Dspring.profiles.active=prod"
 
-  # 경로 설정
+  # Path settings
   APPLICATION_YML_DIR: "__APPLICATION_YML_DIR__"  # @wizard auto:spring-app-yml-dir
-  DOCKERFILE_PATH: "./Dockerfile"  # PROJECT_PATH 기준 상대 경로
+  DOCKERFILE_PATH: "./Dockerfile"  # relative to PROJECT_PATH
 
-  # 포트 및 컨테이너 설정
-  # BLUE/GREEN은 서버에서 번갈아 뜨는 두 컨테이너의 호스트 포트다 — 다른 서비스와 겹치면 배포가 실패한다.
+  # Port and container settings
+  # BLUE/GREEN are the host ports of the two containers that alternate on the server - the deploy fails if they clash with another service.
   CONTAINER_INTERNAL_PORT: "8080"
   BLUE_PORT: "__BLUE_PORT__"  # @wizard ask:8080
   GREEN_PORT: "__GREEN_PORT__"  # @wizard ask:8081
 
-  # Nginx 설정
-  # NGINX_RP_CONF 경로가 틀리면 무중단 전환(proxy_pass 포트 토글) 자체가 동작하지 않는다.
+  # Nginx settings
+  # If the NGINX_RP_CONF path is wrong, the zero-downtime switch (proxy_pass port toggle) cannot work at all.
   NGINX_RP_CONF: "__NGINX_RP_CONF__"  # @wizard ask:/etc/nginx/sites-enabled/__PROJECT_NAME__.conf
   NGINX_BACKUP_DIR: "__NGINX_BACKUP_DIR__"  # @wizard ask:/volume1/projects/nginx/backups
   NGINX_BACKUP_KEEP: "10"
 
-  # 볼륨 마운트 설정
+  # Volume mount settings
   ENABLE_VOLUME_MOUNT: "false"  # @wizard ask:false
   VOLUME_HOST_PATH: "/volume1/projects/__PROJECT_NAME__"  # @wizard ask:/volume1/projects/__PROJECT_NAME__
   VOLUME_CONTAINER_PATH: "/app"  # @wizard ask:/app
 
-  # SSH 인증 방식: "password"(Synology·일반 서버) | "key"(AWS EC2·.pem)
-  #   password → SERVER_PASSWORD secret 사용
-  #   key      → SSH_KEY secret 사용 (.pem 파일 전체 내용을 secret 값으로)
+  # SSH auth method: "password" (Synology / generic servers) | "key" (AWS EC2 / .pem)
+  #   password -> uses the SERVER_PASSWORD secret
+  #   key      -> uses the SSH_KEY secret (the full .pem contents as the secret value)
   SSH_AUTH_METHOD: "password"  # @wizard ask:password
 
-  # SSH 연결 설정
+  # SSH connection settings
   SSH_PORT: "__SSH_PORT__"  # @wizard ask:2022
   SSH_COMMAND_TIMEOUT: "600s"
   SSH_CONNECTION_TIMEOUT: "60s"
 
-  # 헬스체크 설정
+  # Health check settings
   HEALTHCHECK_PATH: "/actuator/health"
   HEALTHCHECK_MAX_RETRIES: "120"
   HEALTHCHECK_RETRY_INTERVAL: "1"
@@ -121,17 +121,17 @@ env:
   IN_FLIGHT_WAIT: "5"
 
 jobs:
-  # 빌드 작업
+  # Build job
   build:
-    name: Spring Boot 애플리케이션 빌드
+    name: Build Spring Boot application
     runs-on: ubuntu-latest
 
     steps:
-      - name: 코드 체크아웃
+      - name: Checkout code
         uses: actions/checkout@v7
 
-      # 필수 Secret·Dockerfile이 없으면 docker 로그인 같은 서드파티 오류 대신 빠진 항목을 알려 주고 멈춘다
-      - name: 배포 사전 점검 (Secret·Dockerfile)
+      # If a required Secret or the Dockerfile is missing, name it and stop instead of failing later in a third-party step such as docker login
+      - name: Deploy pre-check (Secrets and Dockerfile)
         working-directory: ${{ env.PROJECT_PATH }}
         env:
           DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
@@ -142,11 +142,12 @@ jobs:
           SSH_KEY: ${{ secrets.SSH_KEY }}
           DOCKERFILE: ${{ env.DOCKERFILE_PATH }}
         run: |
+          m() { python3 "$GITHUB_WORKSPACE/.github/scripts/messages.py" get "$@"; }
           MISSING=""
           for NAME in DOCKERHUB_USERNAME DOCKERHUB_TOKEN SERVER_HOST SERVER_USER; do
             [ -n "${!NAME}" ] || MISSING="$MISSING $NAME"
           done
-          # SSH_AUTH_METHOD=key면 SSH_KEY, 아니면 SERVER_PASSWORD가 필요하다
+          # SSH_AUTH_METHOD=key needs SSH_KEY, anything else needs SERVER_PASSWORD
           if [ "${SSH_AUTH_METHOD:-password}" = "key" ]; then
             [ -n "$SSH_KEY" ] || MISSING="$MISSING SSH_KEY"
           else
@@ -154,45 +155,46 @@ jobs:
           fi
           FAILED=false
           if [ -n "$MISSING" ]; then
-            echo "::error title=필수 Secret 누락::등록되지 않은 GitHub Secret:$MISSING — Settings → Secrets and variables → Actions에서 등록하세요"
+            echo "::error title=$(m cicd.precheck_secret_title)::$(m cicd.precheck_secret_body missing="$MISSING")"
             FAILED=true
           fi
           if [ ! -f "$DOCKERFILE" ]; then
-            echo "::error title=Dockerfile 없음::${PROJECT_PATH}/${DOCKERFILE#./} 파일이 없습니다. 이 워크플로우는 Docker 이미지로 배포하므로 Dockerfile이 필요합니다 (서버 배포를 하지 않는다면 이 워크플로우 파일을 삭제하세요)"
+            echo "::error title=$(m cicd.precheck_dockerfile_title)::$(m cicd.precheck_dockerfile_body path="${PROJECT_PATH}/${DOCKERFILE#./}")"
             FAILED=true
           fi
           if [ "$FAILED" = "true" ]; then
             exit 1
           fi
-          echo "✅ 사전 점검 통과: 필수 Secret과 Dockerfile이 모두 있습니다"
+          m cicd.precheck_ok
 
-      - name: Java 설정
+      - name: Set up Java
         uses: actions/setup-java@v5
         with:
           java-version: ${{ env.JAVA_VERSION }}
           distribution: 'temurin'
           cache: 'gradle'
 
-      - name: Gradle Wrapper 실행권한 부여
+      - name: Make Gradle wrapper executable
         working-directory: ${{ env.PROJECT_PATH }}
         run: chmod +x gradlew
 
-      - name: application-prod.yml 생성
+      - name: Generate application-prod.yml
         run: |
+          m() { python3 "$GITHUB_WORKSPACE/.github/scripts/messages.py" get "$@"; }
           mkdir -p ${{ env.APPLICATION_YML_DIR }}
           cat << 'EOF' > ./${{ env.APPLICATION_YML_DIR }}/application-prod.yml
           ${{ secrets.APPLICATION_PROD_YML }}
           EOF
-          echo "✅ application-prod.yml 파일 생성 완료 (${{ env.APPLICATION_YML_DIR }})"
+          m wf_spring_deploy.prod_yml_created dir="${{ env.APPLICATION_YML_DIR }}"
 
       - name: Build with Gradle
         working-directory: ${{ env.PROJECT_PATH }}
         run: ./gradlew clean build -x test ${{ env.GRADLE_OPTS }}
 
-      - name: Docker 빌드환경 설정
+      - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
 
-      - name: DockerHub 로그인
+      - name: Log in to DockerHub
         uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
@@ -206,7 +208,7 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-buildx-
 
-      - name: Docker 이미지 빌드 및 푸시
+      - name: Build and push Docker image
         uses: docker/build-push-action@v5
         with:
           context: ${{ env.PROJECT_PATH }}
@@ -221,16 +223,34 @@ jobs:
           rm -rf /tmp/.buildx-cache
           mv /tmp/.buildx-cache-new /tmp/.buildx-cache
 
-  # 배포 작업 (Blue-Green 무중단)
+  # Deploy job (Blue-Green, zero downtime)
   deploy:
-    name: Blue-Green 무중단 배포
+    name: Blue-Green zero-downtime deploy
     needs: build
     runs-on: ubuntu-latest
 
     steps:
+      # The deploy script runs on the server, which has no messages.py:
+      # render the message catalog here and pass it along as a base64 env var
+      - name: Checkout message catalog
+        uses: actions/checkout@v7
+        with:
+          sparse-checkout: |
+            .github/scripts/messages.py
+            version.yml
+          sparse-checkout-cone-mode: false
+
+      - name: Load messages
+        run: |
+          MSGS="$(python3 "$GITHUB_WORKSPACE/.github/scripts/messages.py" dump wf_spring_deploy. \
+            | python3 -c 'import json, shlex, sys; d = json.load(sys.stdin); print("\n".join("M_%s=%s" % (k.replace(".", "_"), shlex.quote(v)) for k, v in d.items()))' \
+            | base64 | tr -d '\n')"
+          echo "PAW_MSG_B64=$MSGS" >> "$GITHUB_ENV"
+
       - name: Deploy
         uses: appleboy/ssh-action@v1.0.3
         env:
+          PAW_MSG_B64: ${{ env.PAW_MSG_B64 }}
           PROJECT_NAME: ${{ env.PROJECT_PATH != '.' && format('{0}-spring', env.PROJECT_NAME) || env.PROJECT_NAME }}
           SERVICE_DOMAIN: ${{ env.SERVICE_DOMAIN }}
           SPRING_PROFILE: ${{ env.SPRING_PROFILE }}
@@ -261,49 +281,59 @@ jobs:
           port: ${{ env.SSH_PORT }}
           command_timeout: ${{ env.SSH_COMMAND_TIMEOUT }}
           timeout: ${{ env.SSH_CONNECTION_TIMEOUT }}
-          envs: PROJECT_NAME,SERVICE_DOMAIN,SPRING_PROFILE,CONTAINER_INTERNAL_PORT,BLUE_PORT,GREEN_PORT,ENABLE_VOLUME_MOUNT,VOLUME_HOST_PATH,VOLUME_CONTAINER_PATH,NGINX_RP_CONF,NGINX_BACKUP_DIR,NGINX_BACKUP_KEEP,HEALTHCHECK_MAX_RETRIES,HEALTHCHECK_RETRY_INTERVAL,HEALTHCHECK_PATH,DOMAIN_CHECK_RETRIES,DOMAIN_CHECK_INTERVAL,IN_FLIGHT_WAIT,BRANCH_REF,DOCKERHUB_USERNAME,SERVER_PASSWORD,SSH_AUTH_METHOD
+          envs: PROJECT_NAME,SERVICE_DOMAIN,SPRING_PROFILE,CONTAINER_INTERNAL_PORT,BLUE_PORT,GREEN_PORT,ENABLE_VOLUME_MOUNT,VOLUME_HOST_PATH,VOLUME_CONTAINER_PATH,NGINX_RP_CONF,NGINX_BACKUP_DIR,NGINX_BACKUP_KEEP,HEALTHCHECK_MAX_RETRIES,HEALTHCHECK_RETRY_INTERVAL,HEALTHCHECK_PATH,DOMAIN_CHECK_RETRIES,DOMAIN_CHECK_INTERVAL,IN_FLIGHT_WAIT,BRANCH_REF,DOCKERHUB_USERNAME,SERVER_PASSWORD,SSH_AUTH_METHOD,PAW_MSG_B64
           script: |
             set -e
             export PATH=$PATH:/usr/local/bin
             export PW="${SERVER_PASSWORD}"
 
-            # SSH 인증 방식에 따른 sudo 추상화
+            # Messages arrive as base64 shell assignments (the server has no messages.py)
+            eval "$(printf '%s' "$PAW_MSG_B64" | base64 -d)"
+            m() {
+              local _v="M_wf_spring_deploy_$1" _kv
+              local _s="${!_v}"
+              shift
+              for _kv in "$@"; do _s=${_s//\{${_kv%%=*}\}/${_kv#*=}}; done
+              printf '%s\n' "$_s"
+            }
+
+            # Abstract sudo by SSH auth method
             SSH_AUTH_METHOD="${SSH_AUTH_METHOD:-password}"
             if [ "${SSH_AUTH_METHOD}" = "key" ]; then
               SUDO() { sudo "$@"; }
             else
               SUDO() { echo "$PW" | sudo -S "$@"; }
             fi
-            echo "🔐 SSH 인증 방식: ${SSH_AUTH_METHOD}"
+            m ssh_auth_method method="${SSH_AUTH_METHOD}"
 
             IMAGE="${DOCKERHUB_USERNAME}/${PROJECT_NAME}:${BRANCH_REF}"
             BLUE_CONTAINER_NAME="${PROJECT_NAME}-blue"
             GREEN_CONTAINER_NAME="${PROJECT_NAME}-green"
 
             echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-            echo "🚀 Nginx Blue-Green 무중단 배포 시작"
+            m nginx_deploy_start
             echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-            echo "📦 프로젝트: ${PROJECT_NAME}"
-            echo "🌐 도메인: ${SERVICE_DOMAIN}"
-            echo "🖼️ 이미지: ${IMAGE}"
+            m banner_project name="${PROJECT_NAME}"
+            m banner_domain domain="${SERVICE_DOMAIN}"
+            m banner_image image="${IMAGE}"
             echo "🎨 Blue=${BLUE_PORT} | Green=${GREEN_PORT}"
             echo "🔧 Nginx config: ${NGINX_RP_CONF}"
             echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
 
-            # 1. 최신 이미지 Pull
-            echo "📥 이미지 Pull: ${IMAGE}"
+            # 1. Pull the latest image
+            m image_pull image="${IMAGE}"
             SUDO docker pull "${IMAGE}"
 
-            # 2. nginx 설정 백업
-            echo "📁 nginx 백업 디렉토리 생성: ${NGINX_BACKUP_DIR}"
+            # 2. Back up the nginx config
+            m nginx_backup_dir dir="${NGINX_BACKUP_DIR}"
             SUDO mkdir -p "${NGINX_BACKUP_DIR}"
 
             BACKUP_FILE="${NGINX_BACKUP_DIR}/server.ReverseProxy.conf.$(date +%Y%m%d_%H%M%S).bak"
-            echo "💾 nginx config 백업: ${BACKUP_FILE}"
+            m nginx_backup_file file="${BACKUP_FILE}"
             SUDO cp "${NGINX_RP_CONF}" "${BACKUP_FILE}"
 
-            # 3. 현재 활성 포트 판별 (nginx config proxy_pass 파싱)
-            echo "🔍 nginx config 의 현재 활성 포트 탐색"
+            # 3. Determine the active port (parse proxy_pass in the nginx config)
+            m nginx_find_active
             ACTIVE_PORT=$(
               SUDO awk -v dom="${SERVICE_DOMAIN}" '
                 BEGIN {
@@ -337,10 +367,10 @@ jobs:
             )
 
             if [ -z "${ACTIVE_PORT}" ]; then
-              echo "⚠️ 활성 포트를 찾지 못함 → 기본값(BLUE=${BLUE_PORT})을 활성으로 간주"
+              m nginx_active_missing blue="${BLUE_PORT}"
               ACTIVE_PORT="${BLUE_PORT}"
             fi
-            echo "🎨 현재 활성 포트: ${ACTIVE_PORT}"
+            m nginx_active_port port="${ACTIVE_PORT}"
 
             if [ "${ACTIVE_PORT}" = "${BLUE_PORT}" ]; then
               NEW_PORT="${GREEN_PORT}"
@@ -352,30 +382,30 @@ jobs:
               OLD_CONTAINER_NAME="${GREEN_CONTAINER_NAME}"
             fi
 
-            echo "🐳 신규 배포 → 포트=${NEW_PORT} 컨테이너=${NEW_CONTAINER_NAME}"
-            echo "🗑️ 이전 컨테이너 (제거 예정) = ${OLD_CONTAINER_NAME}"
+            m nginx_new_deploy port="${NEW_PORT}" name="${NEW_CONTAINER_NAME}"
+            m nginx_old_container name="${OLD_CONTAINER_NAME}"
 
-            # 4. 동일 슬롯(idle 쪽) 잔존 컨테이너 정리
+            # 4. Clean up a leftover container in the same (idle) slot
             if SUDO docker ps -a --format '{{.Names}}' | grep -Eq "^${NEW_CONTAINER_NAME}\$"; then
-              echo "🗑️ idle 슬롯 정리: ${NEW_CONTAINER_NAME}"
+              m idle_slot_cleanup name="${NEW_CONTAINER_NAME}"
               SUDO docker rm -f "${NEW_CONTAINER_NAME}"
             fi
 
-            # 5. 볼륨 마운트 옵션 구성
+            # 5. Build the volume mount option
             VOLUME_MOUNT_OPTION="-v /etc/localtime:/etc/localtime:ro"
             if [ "${ENABLE_VOLUME_MOUNT}" = "true" ]; then
               if [ ! -d "${VOLUME_HOST_PATH}" ]; then
-                echo "📁 볼륨 마운트 디렉토리 생성: ${VOLUME_HOST_PATH}"
+                m volume_mkdir path="${VOLUME_HOST_PATH}"
                 SUDO mkdir -p "${VOLUME_HOST_PATH}"
               fi
               VOLUME_MOUNT_OPTION="${VOLUME_MOUNT_OPTION} -v ${VOLUME_HOST_PATH}:${VOLUME_CONTAINER_PATH}"
-              echo "📦 볼륨 마운트 활성화: ${VOLUME_HOST_PATH} → ${VOLUME_CONTAINER_PATH}"
+              m volume_enabled host="${VOLUME_HOST_PATH}" container="${VOLUME_CONTAINER_PATH}"
             else
-              echo "ℹ️ 볼륨 마운트 비활성화됨"
+              m volume_disabled
             fi
 
-            # 6. 새 컨테이너 기동
-            echo "🐳 새 컨테이너 기동: ${NEW_CONTAINER_NAME} (포트 ${NEW_PORT})"
+            # 6. Start the new container
+            m nginx_new_container_start name="${NEW_CONTAINER_NAME}" port="${NEW_PORT}"
             SUDO docker run -d \
               -p ${NEW_PORT}:${CONTAINER_INTERNAL_PORT} \
               --name "${NEW_CONTAINER_NAME}" \
@@ -384,30 +414,30 @@ jobs:
               ${VOLUME_MOUNT_OPTION} \
               "${IMAGE}"
 
-            # 7. 컨테이너 헬스체크 (로컬 포트 직접 호출)
-            echo "⏳ 헬스체크 시작 (최대 ${HEALTHCHECK_MAX_RETRIES}회 × ${HEALTHCHECK_RETRY_INTERVAL}초)"
+            # 7. Container health check (call the local port directly)
+            m nginx_hc_start retries="${HEALTHCHECK_MAX_RETRIES}" interval="${HEALTHCHECK_RETRY_INTERVAL}"
             HEALTHCHECK_SUCCESS=false
             for i in $(seq 1 ${HEALTHCHECK_MAX_RETRIES}); do
               if curl -fsS "http://127.0.0.1:${NEW_PORT}${HEALTHCHECK_PATH}" >/dev/null 2>&1 || \
                  curl -fsS "http://127.0.0.1:${NEW_PORT}/" >/dev/null 2>&1 ; then
-                echo "✅ 헬스체크 성공 (시도 ${i})"
+                m nginx_hc_ok i="${i}"
                 HEALTHCHECK_SUCCESS=true
                 break
               fi
-              echo "⏳ 헬스체크 진행중... (${i}/${HEALTHCHECK_MAX_RETRIES})"
+              m nginx_hc_progress i="${i}" max="${HEALTHCHECK_MAX_RETRIES}"
               sleep ${HEALTHCHECK_RETRY_INTERVAL}
             done
 
             if [ "${HEALTHCHECK_SUCCESS}" != "true" ]; then
-              echo "❌ 헬스체크 실패 → 배포 중단"
+              m nginx_hc_fail
               SUDO docker logs --tail 200 "${NEW_CONTAINER_NAME}" || true
-              echo "🗑️ 신규 컨테이너 정리: ${NEW_CONTAINER_NAME}"
+              m nginx_new_cleanup name="${NEW_CONTAINER_NAME}"
               SUDO docker rm -f "${NEW_CONTAINER_NAME}" || true
               exit 1
             fi
 
-            # 8. nginx config 포트 토글 (proxy_pass 포트 치환)
-            echo "🔧 nginx config 포트 토글: ${ACTIVE_PORT} → ${NEW_PORT}"
+            # 8. Toggle the nginx config port (replace the proxy_pass port)
+            m nginx_toggle old="${ACTIVE_PORT}" new="${NEW_PORT}"
             TMP_FILE="$(mktemp)"
             SUDO awk -v dom="${SERVICE_DOMAIN}" -v new_port="${NEW_PORT}" '
               BEGIN {
@@ -440,97 +470,97 @@ jobs:
               }
             ' "${NGINX_RP_CONF}" > "${TMP_FILE}"
 
-            # 9. nginx 설정 검증 + reload (실패 시 백업 복구)
-            echo "🔧 nginx 설정 적용 및 검증"
+            # 9. Validate the nginx config and reload (restore the backup on failure)
+            m nginx_apply
             SUDO cp "${TMP_FILE}" "${NGINX_RP_CONF}"
             if ! (SUDO nginx -t); then
-              echo "❌ nginx 설정 검증 실패 → 백업 파일로 복구"
+              m nginx_test_fail
               SUDO cp "${BACKUP_FILE}" "${NGINX_RP_CONF}"
               SUDO rm -f "${BACKUP_FILE}"
               rm -f "${TMP_FILE}"
-              echo "🗑️ 신규 컨테이너 정리: ${NEW_CONTAINER_NAME}"
+              m nginx_new_cleanup name="${NEW_CONTAINER_NAME}"
               SUDO docker rm -f "${NEW_CONTAINER_NAME}" || true
               exit 1
             fi
-            echo "✅ nginx 설정 검증 성공"
+            m nginx_test_ok
             rm -f "${TMP_FILE}"
 
             echo "🔄 nginx reload"
             if ! (SUDO systemctl reload nginx); then
-              echo "⚠️ reload 실패 → restart 시도"
+              m nginx_reload_fail
               if ! (SUDO systemctl restart nginx); then
-                echo "❌ nginx reload/restart 실패 → 백업 복구"
+                m nginx_restart_fail
                 SUDO cp "${BACKUP_FILE}" "${NGINX_RP_CONF}"
                 SUDO systemctl restart nginx
                 SUDO rm -f "${BACKUP_FILE}"
-                echo "🗑️ 신규 컨테이너 정리: ${NEW_CONTAINER_NAME}"
+                m nginx_new_cleanup name="${NEW_CONTAINER_NAME}"
                 SUDO docker rm -f "${NEW_CONTAINER_NAME}" || true
                 exit 1
               fi
             fi
 
-            # 10. 도메인 접근 검증
-            echo "🌐 도메인 접근 검증 (${SERVICE_DOMAIN})"
+            # 10. Verify domain access
+            m nginx_domain_check domain="${SERVICE_DOMAIN}"
             DOMAIN_OK=false
             for i in $(seq 1 ${DOMAIN_CHECK_RETRIES}); do
               if curl -fsS "https://${SERVICE_DOMAIN}${HEALTHCHECK_PATH}" >/dev/null 2>&1 || \
                  curl -fsS "https://${SERVICE_DOMAIN}/" >/dev/null 2>&1 ; then
-                echo "✅ 도메인 접근 검증 성공 (시도 ${i})"
+                m nginx_domain_ok i="${i}"
                 DOMAIN_OK=true
                 break
               fi
-              echo "⏳ 도메인 접근 검증 중... (${i}/${DOMAIN_CHECK_RETRIES})"
+              m nginx_domain_progress i="${i}" max="${DOMAIN_CHECK_RETRIES}"
               sleep ${DOMAIN_CHECK_INTERVAL}
             done
 
             if [ "${DOMAIN_OK}" != "true" ]; then
-              echo "⚠️ 도메인 접근 검증 실패: 배포 진행 (DNS 전파 지연 가능성)"
+              m nginx_domain_fail
             fi
 
-            # 11. 이전 컨테이너 제거
-            echo "⏱️ in-flight 요청 처리 대기 (${IN_FLIGHT_WAIT}초)"
+            # 11. Remove the previous container
+            m inflight_wait sec="${IN_FLIGHT_WAIT}"
             sleep ${IN_FLIGHT_WAIT}
 
             if SUDO docker ps -a --format '{{.Names}}' | grep -Eq "^${OLD_CONTAINER_NAME}\$"; then
-              echo "🗑️ old=${OLD_CONTAINER_NAME} 제거"
+              m old_removed name="${OLD_CONTAINER_NAME}"
               SUDO docker rm -f "${OLD_CONTAINER_NAME}" || true
             else
-              echo "ℹ️ old=${OLD_CONTAINER_NAME} 없음 — 정리 생략"
+              m old_absent name="${OLD_CONTAINER_NAME}"
             fi
 
-            # 12. dangling 이미지 정리 + 백업 보존
-            echo "🧹 dangling(<none>) 이미지 정리..."
+            # 12. Clean up dangling images and keep only recent backups
+            m prune_dangling
             SUDO docker image prune -af
 
-            echo "🧹 백업 파일 최신 ${NGINX_BACKUP_KEEP}개 보존"
+            m nginx_backup_keep keep="${NGINX_BACKUP_KEEP}"
             KEEP_PLUS_ONE=$((NGINX_BACKUP_KEEP + 1))
             SUDO /bin/bash -c "ls -1t '${NGINX_BACKUP_DIR}'/server.ReverseProxy.conf.*.bak 2>/dev/null | tail -n +${KEEP_PLUS_ONE} | xargs -r rm -f"
 
             echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-            echo "✅ 무중단 배포 완료. active=${NEW_CONTAINER_NAME} (포트 ${NEW_PORT})"
-            echo "🌐 도메인: https://${SERVICE_DOMAIN}"
+            m nginx_done name="${NEW_CONTAINER_NAME}" port="${NEW_PORT}"
+            m banner_domain domain="https://${SERVICE_DOMAIN}"
             echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
 
-# 사용 방법
+# Usage
 #
-# 1) GitHub Secrets 등록:
+# 1) Register the GitHub Secrets:
 #    APPLICATION_PROD_YML, DOCKERHUB_USERNAME, DOCKERHUB_TOKEN,
 #    SERVER_HOST, SERVER_USER, SERVER_PASSWORD
 #
-# 2) 본 워크플로우의 env 블록에서 프로젝트별 설정 수정:
+# 2) Edit the project-specific settings in this workflow's env block:
 #    - PROJECT_NAME, SERVICE_DOMAIN
 #    - APPLICATION_YML_DIR, CONTAINER_INTERNAL_PORT
-#    - BLUE_PORT, GREEN_PORT (서로 다른 호스트 포트)
+#    - BLUE_PORT, GREEN_PORT (two different host ports)
 #    - NGINX_RP_CONF, NGINX_BACKUP_DIR
 #    - ENABLE_VOLUME_MOUNT, VOLUME_HOST_PATH, VOLUME_CONTAINER_PATH
 #
-# 3) 서버 사전 준비:
-#    - nginx 설치 + sites-enabled config 존재
-#    - 해당 config server 블록에 다음 라인 존재:
+# 3) Server preparation:
+#    - nginx installed and a sites-enabled config present
+#    - the server block of that config contains these lines:
 #        server_name ${SERVICE_DOMAIN};
-#        proxy_pass http://127.0.0.1:${BLUE_PORT};   # 또는 ${GREEN_PORT}
-#    - SSH 사용자가 sudo 로 nginx -t / reload, docker 명령 실행 가능
+#        proxy_pass http://127.0.0.1:${BLUE_PORT};   # or ${GREEN_PORT}
+#    - the SSH user can run nginx -t / reload and docker commands via sudo
 #
-# 4) 본 워크플로우로 전환:
-#    - 본 파일의 push.branches 주석 해제
-#    - PROJECT-SPRING-SIMPLE-CICD.yaml 의 push 트리거 주석 처리
+# 4) Switch to this workflow:
+#    - uncomment push.branches in this file
+#    - comment out the push trigger in PROJECT-SPRING-SIMPLE-CICD.yaml