Administrator / spring-boot-microservices-onlineshooping-fullstack · Files

pipeline {
    agent {
        label 'jenkins-agent'
    }

    environment {
        // AWS Configuration
        AWS_ACCOUNT_ID = '319998871902'
        AWS_REGION = 'us-east-1'
        EKS_CLUSTER_NAME = 'comic-website-prod'
        DOCKER_REGISTRY = "${AWS_ACCOUNT_ID}.dkr.ecr.${AWS_REGION}.amazonaws.com"
        
        // Project Configuration
        PROJECT_NAME = 'ecommerce'
        NAMESPACE = 'ecommerce'
        
        // Docker Images
        FRONTEND_IMAGE = "${DOCKER_REGISTRY}/${PROJECT_NAME}-frontend"
        USER_SERVICE_IMAGE = "${DOCKER_REGISTRY}/${PROJECT_NAME}-user-service"
        PRODUCT_SERVICE_IMAGE = "${DOCKER_REGISTRY}/${PROJECT_NAME}-product-service"
        ORDER_SERVICE_IMAGE = "${DOCKER_REGISTRY}/${PROJECT_NAME}-order-service"
        PAYMENT_SERVICE_IMAGE = "${DOCKER_REGISTRY}/${PROJECT_NAME}-payment-service"
        INVENTORY_SERVICE_IMAGE = "${DOCKER_REGISTRY}/${PROJECT_NAME}-inventory-service"
        NOTIFICATION_SERVICE_IMAGE = "${DOCKER_REGISTRY}/${PROJECT_NAME}-notification-service"
        
        // Versioning - 现在从versions.yaml读取
        BUILD_VERSION = "${env.BUILD_NUMBER}"
        GIT_COMMIT_SHORT = "${env.GIT_COMMIT?.substring(0, 7) ?: 'unknown'}"
        
        // Java Configuration
        JAVA_HOME = "/opt/java/openjdk"
        
        // Version Control Configuration
        VERSION_FILE = 'versions.yaml'
        VERSION_CONFIGMAP_FILE = 'version-configmap.yaml'
    }

    options {
        buildDiscarder(logRotator(numToKeepStr: '10'))
        timeout(time: 60, unit: 'MINUTES')
        disableConcurrentBuilds()
    }

    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }

        stage('Setup Environment') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        sh """
                            echo "=== Environment Setup ==="
                            echo "Build Version: ${BUILD_VERSION}"
                            echo "Git Commit: ${env.GIT_COMMIT}"
                            echo "Java Home: \$JAVA_HOME"
                            echo "Java Version:"
                            java -version
                            echo "Gradle Version:"
                            gradle --version
                            echo "Node Version:"
                            node --version || echo "Node.js not installed"
                            
                            # Configure AWS and EKS
                            aws configure set region ${AWS_REGION}
                            aws configure set output json
                            aws eks update-kubeconfig --region ${AWS_REGION} --name ${EKS_CLUSTER_NAME}
                            
                            echo "Kubernetes cluster info:"
                            kubectl cluster-info
                            
                            echo "Available disk space:"
                            df -h
                            
                            echo "=== Environment setup completed ==="
                        """
                    }
                }
            }
        }

        stage('Version Control') {
            steps {
                script {
                    try {
                        loadVersionConfig()
                        generateVersionConfigMap()
                        
                        // 设置构建显示名称和描述
                        currentBuild.displayName = "#${BUILD_VERSION}-${APPLICATION_VERSION}"
                        currentBuild.description = "Version: ${APPLICATION_VERSION} | Commit: ${env.GIT_COMMIT}"
                        
                        echo "✅ Version control completed successfully"
                    } catch (Exception e) {
                        echo "❌ Version control failed: ${e.getMessage()}"
                        error "Version control failed: ${e.getMessage()}"
                    }
                }
            }
        }

        stage('Terraform Create ECR') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        sh """
                            echo "🚀 Starting Terraform ECR creation..."
                            cd terraform/ecr
                            
                            # Initialize Terraform
                            echo "Initializing Terraform..."
                            terraform init -input=false
                            
                            # Validate Terraform configuration
                            echo "Validating Terraform configuration..."
                            terraform validate
                            
                            # Plan Terraform changes
                            echo "Planning Terraform changes..."
                            terraform plan -out=tfplan -input=false
                            
                            # Apply Terraform changes
                            echo "Applying Terraform changes to create ECR repositories..."
                            terraform apply -input=false -auto-approve tfplan
                            
                            echo "✅ Terraform ECR creation completed successfully"
                            
                            # Display created ECR repositories
                            echo "Created ECR repositories:"
                            aws ecr describe-repositories --region ${AWS_REGION} --query "repositories[?contains(repositoryName, 'ecommerce')].repositoryName" --output table
                        """
                    }
                }
            }
        }

        stage('Build User Service') {
            steps {
                script {
                    buildServiceSequential('user-service')
                }
            }
        }

        stage('Build Product Service') {
            steps {
                script {
                    buildServiceSequential('product-service')
                }
            }
        }

        stage('Build Order Service') {
            steps {
                script {
                    buildServiceSequential('order-service')
                }
            }
        }

        stage('Build Payment Service') {
            steps {
                script {
                    buildServiceSequential('payment-service')
                }
            }
        }

        stage('Build Inventory Service') {
            steps {
                script {
                    buildServiceSequential('inventory-service')
                }
            }
        }

        stage('Build Notification Service') {
            steps {
                script {
                    buildServiceSequential('notification-service')
                }
            }
        }

        stage('Build Frontend') {
            steps {
                dir('frontend') {
                    sh '''
                        echo "Building Frontend..."
                        npm ci
                        npm run build
                        echo "Frontend build completed"
                    '''
                }
            }
        }

        stage('ECR Login') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        sh """
                            echo "Logging into ECR..."
                            aws ecr get-login-password --region ${AWS_REGION} | docker login --username AWS --password-stdin ${DOCKER_REGISTRY}
                            echo "✅ ECR login successful"
                        """
                    }
                }
            }
        }

        stage('Docker Build Frontend') {
            steps {
                script {
                    dockerBuildPushSequential('frontend', "${FRONTEND_IMAGE}")
                }
            }
        }

        stage('Docker Build User Service') {
            steps {
                script {
                    dockerBuildPushSequential('user-service', "${USER_SERVICE_IMAGE}")
                }
            }
        }

        stage('Docker Build Product Service') {
            steps {
                script {
                    dockerBuildPushSequential('product-service', "${PRODUCT_SERVICE_IMAGE}")
                }
            }
        }

        stage('Docker Build Order Service') {
            steps {
                script {
                    dockerBuildPushSequential('order-service', "${ORDER_SERVICE_IMAGE}")
                }
            }
        }

        stage('Docker Build Payment Service') {
            steps {
                script {
                    dockerBuildPushSequential('payment-service', "${PAYMENT_SERVICE_IMAGE}")
                }
            }
        }

        stage('Docker Build Inventory Service') {
            steps {
                script {
                    dockerBuildPushSequential('inventory-service', "${INVENTORY_SERVICE_IMAGE}")
                }
            }
        }

        stage('Docker Build Notification Service') {
            steps {
                script {
                    dockerBuildPushSequential('notification-service', "${NOTIFICATION_SERVICE_IMAGE}")
                }
            }
        }

        stage('Create Namespace') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        sh """
                            echo "🏗️ Creating namespace if not exists..."
                            
                            # 创建命名空间（如果不存在）
                            kubectl create namespace ${NAMESPACE} --dry-run=client -o yaml | kubectl apply -f -
                            
                            echo "✅ Namespace ${NAMESPACE} created/verified"
                        """
                    }
                }
            }
        }

        stage('Create Image Pull Secret') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        sh '''
                            echo "🔑 Creating ECR image pull secret..."
                            
                            # 获取 ECR 登录密码
                            ECR_PASSWORD=$(aws ecr get-login-password --region us-east-1)
                            
                            # 创建或更新镜像拉取 Secret
                            kubectl create secret docker-registry regcred \\
                              --docker-server=319998871902.dkr.ecr.us-east-1.amazonaws.com \\
                              --docker-username=AWS \\
                              --docker-password="$ECR_PASSWORD" \\
                              --namespace ecommerce --dry-run=client -o yaml | kubectl apply -f -
                            
                            echo "✅ ECR image pull secret created/updated successfully"
                        '''
                    }
                }
            }
        }

        stage('Update Deployment Versions') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        sh """
                            echo "🔧 Updating deployment versions to: ${DEPLOYMENT_VERSION}"
                            
                            # Update kubeconfig
                            aws eks update-kubeconfig --region ${AWS_REGION} --name ${EKS_CLUSTER_NAME}
                            
                            # 智能部署函数 - 检查 deployment 是否存在，不存在则从文件创建
                            deployService() {
                                local service_name="\\$1"
                                local image_name="\\$2"
                                local deployment_file="kubernetes/microservices/\\$service_name/deployment.yaml"
                                
                                echo "Processing \\$service_name..."
                                
                                # 检查 deployment 是否已经存在
                                if kubectl get deployment "\\$service_name" -n ${NAMESPACE} &> /dev/null; then
                                    echo "✅ \\$service_name deployment exists, updating image..."
                                    kubectl set image deployment/\\$service_name \\$service_name=\\$image_name:${DEPLOYMENT_VERSION} -n ${NAMESPACE}
                                else
                                    echo "⚠️ \\$service_name deployment not found, creating from file..."
                                    
                                    if [ -f "\\$deployment_file" ]; then
                                        # 更新 deployment 文件中的镜像版本
                                        cp "\\$deployment_file" "\\$deployment_file.bak"
                                        sed -i "s|image:.*|\\$image_name:${DEPLOYMENT_VERSION}|g" "\\$deployment_file"
                                        
                                        # 应用 deployment
                                        kubectl apply -f "\\$deployment_file" -n ${NAMESPACE}
                                        
                                        # 恢复原文件
                                        mv "\\$deployment_file.bak" "\\$deployment_file"
                                        
                                        echo "✅ \\$service_name deployment created from file"
                                    else
                                        echo "❌ Deployment file not found: \\$deployment_file"
                                    fi
                                fi
                            }
                            
                            # 部署所有微服务
                            deployService "user-service" "${USER_SERVICE_IMAGE}"
                            deployService "product-service" "${PRODUCT_SERVICE_IMAGE}"
                            deployService "order-service" "${ORDER_SERVICE_IMAGE}"
                            deployService "payment-service" "${PAYMENT_SERVICE_IMAGE}"
                            deployService "inventory-service" "${INVENTORY_SERVICE_IMAGE}"
                            deployService "notification-service" "${NOTIFICATION_SERVICE_IMAGE}"
                            
                            # 特殊处理 frontend（路径可能不同）
                            echo "Processing frontend..."
                            if kubectl get deployment frontend -n ${NAMESPACE} &> /dev/null; then
                                kubectl set image deployment/frontend frontend=${FRONTEND_IMAGE}:${DEPLOYMENT_VERSION} -n ${NAMESPACE}
                            else
                                frontend_file="kubernetes/frontend/deployment.yaml"
                                if [ -f "\\$frontend_file" ]; then
                                    cp "\\$frontend_file" "\\$frontend_file.bak"
                                    sed -i "s|image:.*|${FRONTEND_IMAGE}:${DEPLOYMENT_VERSION}|g" "\\$frontend_file"
                                    kubectl apply -f "\\$frontend_file" -n ${NAMESPACE}
                                    mv "\\$frontend_file.bak" "\\$frontend_file"
                                else
                                    echo "❌ Frontend deployment file not found: \\$frontend_file"
                                fi
                            fi
                            
                            echo "✅ All deployments updated to version: ${DEPLOYMENT_VERSION}"
                        """
                    }
                }
            }
        }

        stage('Apply Version ConfigMap') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        sh """
                            echo "📝 Applying version ConfigMap to Kubernetes..."
                            
                            # Update kubeconfig
                            aws eks update-kubeconfig --region ${AWS_REGION} --name ${EKS_CLUSTER_NAME}
                            
                            # Apply the generated version ConfigMap
                            kubectl apply -f ${VERSION_CONFIGMAP_FILE} -n ${NAMESPACE}
                            
                            echo "✅ Version ConfigMap applied successfully"
                        """
                    }
                }
            }
        }

        stage('Record Version Info') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        sh """
                            echo "📝 Recording version information..."
                            
                            # Create version info ConfigMap
                            kubectl create configmap version-info \\
                              --from-literal=build-number=${BUILD_VERSION} \\
                              --from-literal=git-commit=${env.GIT_COMMIT} \\
                              --from-literal=git-commit-short=${GIT_COMMIT_SHORT} \\
                              --from-literal=docker-tag=${DOCKER_TAG} \\
                              --from-literal=deployment-version=${DEPLOYMENT_VERSION} \\
                              --from-literal=application-version=${APPLICATION_VERSION} \\
                              --from-literal=build-time=\\$(date -u +"%Y-%m-%dT%H:%M:%SZ") \\
                              --from-literal=deploy-time=\\$(date -u +"%Y-%m-%dT%H:%M:%SZ") \\
                              -n ${NAMESPACE} --dry-run=client -o yaml | kubectl apply -f -
                              
                            echo "✅ Version information recorded"
                        """
                    }
                }
            }
        }

        stage('Deploy to EKS') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        sh """
                            echo "🚀 Starting deployment to EKS..."
                            echo "Application Version: ${APPLICATION_VERSION}"
                            echo "Deployment Version: ${DEPLOYMENT_VERSION}"
                            
                            # Update kubeconfig
                            aws eks update-kubeconfig --region ${AWS_REGION} --name ${EKS_CLUSTER_NAME}
                            
                            # Step 1: 应用其他 Kubernetes 资源（deployments 已经在上一阶段应用了）
                            echo "=== Applying other Kubernetes resources ==="
                            
                            # 应用所有服务的 configmaps, services 等
                            applyServiceResources() {
                                local service_name="\\$1"
                                echo "Applying resources for \\$service_name..."
                                
                                # 应用该服务目录下的所有 yaml 文件（除了 deployment.yaml）
                                find "kubernetes/microservices/\\$service_name" -name "*.yaml" -o -name "*.yml" 2>/dev/null | grep -v deployment.yaml | while read file; do
                                    if [ -f "\\$file" ]; then
                                        echo "Applying: \\$file"
                                        kubectl apply -f "\\$file" -n ${NAMESPACE}
                                    fi
                                done
                            }
                            
                            # 应用所有微服务的资源
                            applyServiceResources "user-service"
                            applyServiceResources "product-service"
                            applyServiceResources "order-service"
                            applyServiceResources "payment-service"
                            applyServiceResources "inventory-service"
                            applyServiceResources "notification-service"
                            
                            # 应用 frontend 资源
                            if [ -d "kubernetes/frontend" ]; then
                                find "kubernetes/frontend" -name "*.yaml" -o -name "*.yml" | grep -v deployment.yaml | while read file; do
                                    kubectl apply -f "\\$file" -n ${NAMESPACE}
                                done
                            fi
                            
                            # 应用基础设施资源
                            echo "=== Applying infrastructure resources ==="
                            if [ -d "kubernetes/databases" ]; then
                                kubectl apply -f kubernetes/databases/ -n ${NAMESPACE} --recursive=true || echo "No databases configuration found or applied"
                            fi
                            
                            if [ -d "kubernetes/message-queue" ]; then
                                kubectl apply -f kubernetes/message-queue/ -n ${NAMESPACE} --recursive=true || echo "No message queue configuration found or applied"
                            fi
                            
                            if [ -d "kubernetes/networking" ]; then
                                kubectl apply -f kubernetes/networking/ -n ${NAMESPACE} --recursive=true || echo "No networking configuration found or applied"
                            fi
                            
                            # 等待部署完成
                            echo "=== Waiting for deployments to be ready ==="
                            kubectl rollout status deployment/user-service -n ${NAMESPACE} --timeout=300s
                            
                            echo "✅ Deployment completed!"
                            
                            # Final status check
                            echo "=== Final Deployment Status ==="
                            echo ""
                            echo "=== Version Information ==="
                            kubectl get configmap version-info -n ${NAMESPACE} -o yaml | grep -v "kubectl.kubernetes.io" || echo "No version-info configmap found"
                            echo ""
                            echo "=== Deployments ==="
                            kubectl get deployments -n ${NAMESPACE} -o wide
                            echo ""
                            echo "=== Pods ==="
                            kubectl get pods -n ${NAMESPACE} --sort-by='.metadata.creationTimestamp' -o wide
                            echo ""
                            echo "=== Services ==="
                            kubectl get services -n ${NAMESPACE}
                            echo ""
                            echo "=== Ingress ==="
                            kubectl get ingress -n ${NAMESPACE} || echo "No ingress resources found"
                        """
                    }
                }
            }
        }
    }

    post {
        always {
            // Archive build artifacts
            archiveArtifacts artifacts: '**/build/libs/*.jar', fingerprint: true
            
            // Clean up Docker to free space
            sh '''
                echo "Cleaning up Docker resources..."
                docker system prune -f || true
                echo "Cleanup completed"
            '''
            
            // Log disk space after build
            sh '''
                echo "Disk space after build:"
                df -h
            '''
        }
        success {
            echo "🎉 Build and deployment successful!"
            script {
                sh '''
                    echo "✅ All tasks completed successfully"
                    echo "📊 Build Information:"
                    echo "   Application Version: '${APPLICATION_VERSION}'"
                    echo "   Build Number: '${BUILD_VERSION}'"
                    echo "   Docker Tag: '${DOCKER_TAG}'"
                    echo "   Deployment Version: '${DEPLOYMENT_VERSION}'"
                    echo "   Git Commit: '${GIT_COMMIT}'"
                    echo "📊 Final resource usage:"
                    df -h
                    echo "🚀 Application deployed successfully!"
                '''
            }
        }
        failure {
            echo "❌ Build failed! Check the logs for details."
            sh '''
                echo "💡 Troubleshooting tips:"
                echo "1. Check disk space: df -h"
                echo "2. Check Docker: docker system df"
                echo "3. Check Gradle cache: du -sh ~/.gradle/"
                echo "4. Check Kubernetes resources: kubectl get pods -n ecommerce"
                echo "5. Check ECR repositories: aws ecr describe-repositories --region us-east-1"
                echo "6. Check specific service logs: kubectl logs -n ecommerce <pod-name>"
                echo "7. Check deployment status: kubectl get deployments -n ecommerce"
                echo "8. Check version info: kubectl get configmap version-info -n ecommerce -o yaml"
            '''
        }
    }
}

// 串行构建微服务的函数
def buildServiceSequential(serviceName) {
    echo "🔨 Building ${serviceName}..."
    dir("microservices/${serviceName}") {
        // 添加重试机制和资源监控
        retry(2) {
            sh """
                echo "=== Starting Gradle build for ${serviceName} ==="
                echo "Current directory: \$(pwd)"
                echo "Java version:"
                java -version
                echo "Gradle version:"
                gradle --version
                
                # 清理 Gradle 缓存以防万一
                echo "Cleaning project..."
                gradle clean --no-daemon
                
                # 构建项目（跳过测试以减少资源使用）
                echo "Building project..."
                gradle build -x test --no-daemon --stacktrace
                
                echo "✅ ${serviceName} build completed"
                echo "Build artifacts:"
                ls -la build/libs/
            """
        }
    }
    echo "✅ ${serviceName} build completed successfully"
}

// 串行构建和推送 Docker 镜像的函数 - 现在使用语义化版本号
def dockerBuildPushSequential(serviceDir, imageName) {
    echo "🐳 Building and pushing Docker image for ${serviceDir}..."
    
    def contextDir = serviceDir == 'frontend' ? 'frontend' : "microservices/${serviceDir}"
    def serviceVersion = env."${serviceDir.toUpperCase().replace('-', '_')}_VERSION"
    
    dir(contextDir) {
        retry(2) {
            sh """
                echo "=== Building Docker image for ${serviceDir} ==="
                echo "Image: ${imageName}"
                echo "Service Version: ${serviceVersion}"
                echo "Build context: \$(pwd)"
                
                # 检查 Dockerfile 是否存在
                echo "Checking for Dockerfile..."
                ls -la Dockerfile || echo "Dockerfile not found, listing all files:"
                ls -la
                
                # 构建 Docker 镜像 - 使用语义化版本号
                echo "Building Docker image with semantic versioning..."
                docker build -t ${imageName}:${serviceVersion} -t ${imageName}:latest .
                
                # 推送版本标签到 ECR
                echo "Pushing version tag: ${serviceVersion}"
                docker push ${imageName}:${serviceVersion}
                
                echo "Pushing latest tag"
                docker push ${imageName}:latest
                
                echo "✅ ${serviceDir} Docker images pushed successfully"
                echo "   - ${imageName}:${serviceVersion}"
                echo "   - ${imageName}:latest"
                
                # 清理本地镜像以节省空间
                echo "Cleaning up local Docker images..."
                docker rmi ${imageName}:${serviceVersion} || true
                docker rmi ${imageName}:latest || true
                
                echo "=== ${serviceDir} Docker build completed ==="
            """
        }
    }
}

// 版本控制相关函数
def loadVersionConfig() {
    echo "📖 Loading version configuration from ${VERSION_FILE}"
    
    if (!fileExists(VERSION_FILE)) {
        error "Version file ${VERSION_FILE} not found!"
    }
    
    // 读取版本文件内容
    def versionContent = readYaml file: VERSION_FILE
    
    // 设置全局版本信息
    env.APPLICATION_VERSION = "${versionContent.versions.application.major}.${versionContent.versions.application.minor}.${versionContent.versions.application.patch}"
    env.APPLICATION_NAME = versionContent.versions.application.name
    env.APPLICATION_DESCRIPTION = versionContent.versions.application.description
    
    // 设置服务版本信息
    versionContent.versions.services.each { serviceName, serviceConfig ->
        def envVarName = serviceName.toUpperCase().replace('-', '_') + "_VERSION"
        env."${envVarName}" = serviceConfig.version
        echo "Set ${envVarName} = ${serviceConfig.version}"
    }
    
    // 设置基础设施版本
    versionContent.versions.infrastructure.each { infraName, infraConfig ->
        env."${infraName.toUpperCase()}_VERSION" = infraConfig.version
    }
    
    // 设置Docker标签和部署版本 - 现在使用语义化版本号
    env.DOCKER_TAG = "${env.APPLICATION_VERSION}-${env.GIT_COMMIT_SHORT}"
    env.DEPLOYMENT_VERSION = env.APPLICATION_VERSION
    
    echo "✅ Version configuration loaded:"
    echo "   Application: ${env.APPLICATION_VERSION} - ${env.APPLICATION_NAME}"
    echo "   Docker Tag: ${env.DOCKER_TAG}"
    echo "   Deployment Version: ${env.DEPLOYMENT_VERSION}"
    versionContent.versions.services.each { serviceName, serviceConfig ->
        echo "   ${serviceName}: ${serviceConfig.version}"
    }
}

def generateVersionConfigMap() {
    echo "📝 Generating version ConfigMap"
    
    try {
        def versionContent = readYaml file: VERSION_FILE
        
        // 使用shell命令直接生成ConfigMap文件，避免writeYaml的问题
        sh """
            cat > ${VERSION_CONFIGMAP_FILE} << EOF
apiVersion: v1
kind: ConfigMap
metadata:
  name: ecommerce-version-info
  namespace: ${NAMESPACE}
data:
  application.version: "${APPLICATION_VERSION}"
  application.name: "${APPLICATION_NAME}"
  application.description: "${APPLICATION_DESCRIPTION}"
  build.timestamp: "`date -u +"%Y-%m-%dT%H:%M:%SZ"`"
  build.number: "${BUILD_VERSION}"
  build.commit: "${env.GIT_COMMIT}"
  build.commit.short: "${GIT_COMMIT_SHORT}"
  build.branch: "${env.BRANCH_NAME}"
  docker.tag: "${DOCKER_TAG}"
  deployment.version: "${DEPLOYMENT_VERSION}"
  build.java.version: "${versionContent.versions.build.java_version}"
  build.node.version: "${versionContent.versions.build.node_version}"
  build.gradle.version: "${versionContent.versions.build.gradle_version}"
EOF
        """
        
        // 添加服务版本信息
        versionContent.versions.services.each { serviceName, serviceConfig ->
            def serviceKey = serviceName.replace('-', '.').toLowerCase()
            sh """
                echo "  service.${serviceKey}.version: \\\"${serviceConfig.version}\\\"" >> ${VERSION_CONFIGMAP_FILE}
                echo "  service.${serviceKey}.description: \\\"${serviceConfig.description}\\\"" >> ${VERSION_CONFIGMAP_FILE}
                echo "  service.${serviceKey}.component: \\\"${serviceConfig.component}\\\"" >> ${VERSION_CONFIGMAP_FILE}
                echo "  service.${serviceKey}.team: \\\"${serviceConfig.team}\\\"" >> ${VERSION_CONFIGMAP_FILE}
            """
        }
        
        // 添加基础设施版本信息
        versionContent.versions.infrastructure.each { infraName, infraConfig ->
            sh """
                echo "  infrastructure.${infraName}.version: \\\"${infraConfig.version}\\\"" >> ${VERSION_CONFIGMAP_FILE}
                echo "  infrastructure.${infraName}.description: \\\"${infraConfig.description}\\\"" >> ${VERSION_CONFIGMAP_FILE}
            """
        }
        
        echo "✅ Version ConfigMap generated: ${VERSION_CONFIGMAP_FILE}"
        sh "cat ${VERSION_CONFIGMAP_FILE}"
        
    } catch (Exception e) {
        echo "❌ Failed to generate version ConfigMap: ${e.getMessage()}"
        throw e
    }
}