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 = 'your-eks-cluster-name'  // 请替换为实际的 EKS 集群名称
        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
        BUILD_VERSION = "${env.BUILD_NUMBER}"
        DOCKER_TAG = "${BUILD_VERSION}-${env.GIT_COMMIT.substring(0, 7)}"
    }

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

    stages {
        stage('Checkout') {
            steps {
                checkout scm
                script {
                    currentBuild.displayName = "#${BUILD_VERSION} - ${env.GIT_BRANCH}"
                    currentBuild.description = "Commit: ${env.GIT_COMMIT}"
                }
            }
        }

        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 "Setting up AWS and Kubernetes environment"
                            aws --version
                            kubectl version --client
                            
                            # Configure AWS CLI
                            aws configure set region ${AWS_REGION}
                            aws configure set output json
                            
                            # Update kubeconfig for EKS cluster
                            aws eks update-kubeconfig --region ${AWS_REGION} --name ${EKS_CLUSTER_NAME}
                            
                            # Verify cluster access
                            kubectl cluster-info
                            kubectl get nodes
                        '''
                    }
                }
            }
        }

        stage('Build Microservices') {
            parallel {
                stage('Build User Service') {
                    steps {
                        dir('microservices/user-service') {
                            sh """
                                echo "Building User Service..."
                                ./gradlew clean build -x test
                            """
                        }
                    }
                }
                stage('Build Product Service') {
                    steps {
                        dir('microservices/product-service') {
                            sh """
                                echo "Building Product Service..."
                                ./gradlew clean build -x test
                            """
                        }
                    }
                }
                stage('Build Order Service') {
                    steps {
                        dir('microservices/order-service') {
                            sh """
                                echo "Building Order Service..."
                                ./gradlew clean build -x test
                            """
                        }
                    }
                }
                stage('Build Payment Service') {
                    steps {
                        dir('microservices/payment-service') {
                            sh """
                                echo "Building Payment Service..."
                                ./gradlew clean build -x test
                            """
                        }
                    }
                }
                stage('Build Inventory Service') {
                    steps {
                        dir('microservices/inventory-service') {
                            sh """
                                echo "Building Inventory Service..."
                                ./gradlew clean build -x test
                            """
                        }
                    }
                }
                stage('Build Notification Service') {
                    steps {
                        dir('microservices/notification-service') {
                            sh """
                                echo "Building Notification Service..."
                                ./gradlew clean build -x test
                            """
                        }
                    }
                }
            }
        }

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

        stage('Docker Build & Push') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        // Login to ECR
                        sh """
                            aws ecr get-login-password --region ${AWS_REGION} | docker login --username AWS --password-stdin ${DOCKER_REGISTRY}
                        """

                        // Create ECR repositories if they don't exist
                        def services = [
                            'frontend', 'user-service', 'product-service', 
                            'order-service', 'payment-service', 'inventory-service', 
                            'notification-service'
                        ]
                        
                        services.each { service ->
                            sh """
                                # Create ECR repository if it doesn't exist
                                aws ecr describe-repositories --repository-names ${PROJECT_NAME}-${service} || \
                                aws ecr create-repository --repository-name ${PROJECT_NAME}-${service} --image-scanning-configuration scanOnPush=true
                            """
                        }

                        // Build and push images in parallel
                        parallel {
                            stage('Build Frontend Image') {
                                steps {
                                    dir('frontend') {
                                        sh """
                                            docker build -t ${FRONTEND_IMAGE}:${DOCKER_TAG} .
                                            docker push ${FRONTEND_IMAGE}:${DOCKER_TAG}
                                            docker tag ${FRONTEND_IMAGE}:${DOCKER_TAG} ${FRONTEND_IMAGE}:latest
                                            docker push ${FRONTEND_IMAGE}:latest
                                        """
                                    }
                                }
                            }
                            stage('Build User Service Image') {
                                steps {
                                    dir('microservices/user-service') {
                                        sh """
                                            docker build -t ${USER_SERVICE_IMAGE}:${DOCKER_TAG} .
                                            docker push ${USER_SERVICE_IMAGE}:${DOCKER_TAG}
                                            docker tag ${USER_SERVICE_IMAGE}:${DOCKER_TAG} ${USER_SERVICE_IMAGE}:latest
                                            docker push ${USER_SERVICE_IMAGE}:latest
                                        """
                                    }
                                }
                            }
                            stage('Build Product Service Image') {
                                steps {
                                    dir('microservices/product-service') {
                                        sh """
                                            docker build -t ${PRODUCT_SERVICE_IMAGE}:${DOCKER_TAG} .
                                            docker push ${PRODUCT_SERVICE_IMAGE}:${DOCKER_TAG}
                                            docker tag ${PRODUCT_SERVICE_IMAGE}:${DOCKER_TAG} ${PRODUCT_SERVICE_IMAGE}:latest
                                            docker push ${PRODUCT_SERVICE_IMAGE}:latest
                                        """
                                    }
                                }
                            }
                            stage('Build Order Service Image') {
                                steps {
                                    dir('microservices/order-service') {
                                        sh """
                                            docker build -t ${ORDER_SERVICE_IMAGE}:${DOCKER_TAG} .
                                            docker push ${ORDER_SERVICE_IMAGE}:${DOCKER_TAG}
                                            docker tag ${ORDER_SERVICE_IMAGE}:${DOCKER_TAG} ${ORDER_SERVICE_IMAGE}:latest
                                            docker push ${ORDER_SERVICE_IMAGE}:latest
                                        """
                                    }
                                }
                            }
                            stage('Build Payment Service Image') {
                                steps {
                                    dir('microservices/payment-service') {
                                        sh """
                                            docker build -t ${PAYMENT_SERVICE_IMAGE}:${DOCKER_TAG} .
                                            docker push ${PAYMENT_SERVICE_IMAGE}:${DOCKER_TAG}
                                            docker tag ${PAYMENT_SERVICE_IMAGE}:${DOCKER_TAG} ${PAYMENT_SERVICE_IMAGE}:latest
                                            docker push ${PAYMENT_SERVICE_IMAGE}:latest
                                        """
                                    }
                                }
                            }
                            stage('Build Inventory Service Image') {
                                steps {
                                    dir('microservices/inventory-service') {
                                        sh """
                                            docker build -t ${INVENTORY_SERVICE_IMAGE}:${DOCKER_TAG} .
                                            docker push ${INVENTORY_SERVICE_IMAGE}:${DOCKER_TAG}
                                            docker tag ${INVENTORY_SERVICE_IMAGE}:${DOCKER_TAG} ${INVENTORY_SERVICE_IMAGE}:latest
                                            docker push ${INVENTORY_SERVICE_IMAGE}:latest
                                        """
                                    }
                                }
                            }
                            stage('Build Notification Service Image') {
                                steps {
                                    dir('microservices/notification-service') {
                                        sh """
                                            docker build -t ${NOTIFICATION_SERVICE_IMAGE}:${DOCKER_TAG} .
                                            docker push ${NOTIFICATION_SERVICE_IMAGE}:${DOCKER_TAG}
                                            docker tag ${NOTIFICATION_SERVICE_IMAGE}:${DOCKER_TAG} ${NOTIFICATION_SERVICE_IMAGE}:latest
                                            docker push ${NOTIFICATION_SERVICE_IMAGE}:latest
                                        """
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        stage('Deploy to EKS') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        // Update kubeconfig
                        sh """
                            aws eks update-kubeconfig --region ${AWS_REGION} --name ${EKS_CLUSTER_NAME}
                        """

                        // Create namespace if it doesn't exist
                        sh """
                            kubectl get namespace ${NAMESPACE} || kubectl create namespace ${NAMESPACE}
                        """

                        // Deploy databases first
                        sh """
                            echo "Deploying databases..."
                            kubectl apply -f kubernetes/databases/postgresql/ -n ${NAMESPACE}
                            kubectl apply -f kubernetes/databases/mongodb/ -n ${NAMESPACE}
                            kubectl apply -f kubernetes/databases/redis/ -n ${NAMESPACE}
                        """

                        // Wait for databases to be ready
                        sh """
                            echo "Waiting for databases to be ready..."
                            kubectl wait --for=condition=ready pod -l app=postgresql -n ${NAMESPACE} --timeout=300s
                            kubectl wait --for=condition=ready pod -l app=mongodb -n ${NAMESPACE} --timeout=300s
                            kubectl wait --for=condition=ready pod -l app=redis -n ${NAMESPACE} --timeout=300s
                        """

                        // Deploy message queue
                        sh """
                            echo "Deploying RabbitMQ..."
                            kubectl apply -f kubernetes/message-queue/rabbitmq/ -n ${NAMESPACE}
                            kubectl wait --for=condition=ready pod -l app=rabbitmq -n ${NAMESPACE} --timeout=300s
                        """

                        // Update Kubernetes manifests with new image tags
                        sh """
                            # Update frontend deployment with new image
                            sed -i 's|your-registry/frontend:latest|${FRONTEND_IMAGE}:${DOCKER_TAG}|g' kubernetes/frontend/deployment.yaml
                            
                            # Update microservices deployments with new images
                            sed -i 's|your-registry/user-service:latest|${USER_SERVICE_IMAGE}:${DOCKER_TAG}|g' kubernetes/microservices/user-service/deployment.yaml
                            sed -i 's|your-registry/product-service:latest|${PRODUCT_SERVICE_IMAGE}:${DOCKER_TAG}|g' kubernetes/microservices/product-service/deployment.yaml
                            sed -i 's|your-registry/order-service:latest|${ORDER_SERVICE_IMAGE}:${DOCKER_TAG}|g' kubernetes/microservices/order-service/deployment.yaml
                            sed -i 's|your-registry/payment-service:latest|${PAYMENT_SERVICE_IMAGE}:${DOCKER_TAG}|g' kubernetes/microservices/payment-service/deployment.yaml
                            sed -i 's|your-registry/inventory-service:latest|${INVENTORY_SERVICE_IMAGE}:${DOCKER_TAG}|g' kubernetes/microservices/inventory-service/deployment.yaml
                            sed -i 's|your-registry/notification-service:latest|${NOTIFICATION_SERVICE_IMAGE}:${DOCKER_TAG}|g' kubernetes/microservices/notification-service/deployment.yaml
                        """

                        // Deploy microservices
                        sh """
                            echo "Deploying microservices..."
                            kubectl apply -f kubernetes/microservices/user-service/ -n ${NAMESPACE}
                            kubectl apply -f kubernetes/microservices/product-service/ -n ${NAMESPACE}
                            kubectl apply -f kubernetes/microservices/order-service/ -n ${NAMESPACE}
                            kubectl apply -f kubernetes/microservices/payment-service/ -n ${NAMESPACE}
                            kubectl apply -f kubernetes/microservices/inventory-service/ -n ${NAMESPACE}
                            kubectl apply -f kubernetes/microservices/notification-service/ -n ${NAMESPACE}
                        """

                        // Wait for microservices to be ready
                        sh """
                            echo "Waiting for microservices to be ready..."
                            kubectl wait --for=condition=ready pod -l app=user-service -n ${NAMESPACE} --timeout=300s
                            kubectl wait --for=condition=ready pod -l app=product-service -n ${NAMESPACE} --timeout=300s
                            kubectl wait --for=condition=ready pod -l app=order-service -n ${NAMESPACE} --timeout=300s
                            kubectl wait --for=condition=ready pod -l app=payment-service -n ${NAMESPACE} --timeout=300s
                            kubectl wait --for=condition=ready pod -l app=inventory-service -n ${NAMESPACE} --timeout=300s
                            kubectl wait --for=condition=ready pod -l app=notification-service -n ${NAMESPACE} --timeout=300s
                        """

                        // Deploy frontend
                        sh """
                            echo "Deploying frontend..."
                            kubectl apply -f kubernetes/frontend/ -n ${NAMESPACE}
                            kubectl wait --for=condition=ready pod -l app=frontend -n ${NAMESPACE} --timeout=300s
                        """

                        // Deploy networking
                        sh """
                            echo "Deploying networking configuration..."
                            kubectl apply -f kubernetes/networking/ -n ${NAMESPACE}
                        """

                        // Wait for ALB to be provisioned
                        sh """
                            echo "Waiting for ALB to be provisioned..."
                            timeout 300s bash -c 'until kubectl get ingress -n ${NAMESPACE} frontend-ingress -o jsonpath="{.status.loadBalancer.ingress[0].hostname}" | grep -q .; do sleep 10; done'
                        """
                    }
                }
            }
        }

        stage('Health Check') {
            steps {
                script {
                    // Get ALB endpoint
                    def ALB_ENDPOINT = sh(
                        script: "kubectl get ingress -n ${NAMESPACE} frontend-ingress -o jsonpath='{.status.loadBalancer.ingress[0].hostname}'",
                        returnStdout: true
                    ).trim()

                    echo "ALB Endpoint: ${ALB_ENDPOINT}"

                    // Perform health checks
                    sh """
                        echo "Performing health checks..."
                        # Wait for services to be fully ready
                        sleep 30
                        
                        # Test frontend health
                        curl -f http://${ALB_ENDPOINT}/health || exit 1
                        
                        # Test API health (if API Gateway is deployed)
                        curl -f http://${ALB_ENDPOINT}/api/users/actuator/health || echo "API health check skipped"
                    """
                }
            }
        }
    }

    post {
        always {
            script {
                // Cleanup
                sh '''
                    docker system prune -f || true
                '''
                
                // Archive artifacts
                archiveArtifacts artifacts: '**/build/libs/*.jar', fingerprint: true
                
                // Save build info
                currentBuild.description = "Version: ${DOCKER_TAG}"
            }
        }
        success {
            script {
                def ALB_ENDPOINT = sh(
                    script: "kubectl get ingress -n ${NAMESPACE} frontend-ingress -o jsonpath='{.status.loadBalancer.ingress[0].hostname}'",
                    returnStdout: true
                ).trim()
                
                emailext (
                    subject: "SUCCESS: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]'",
                    body: """
                    The build #${env.BUILD_NUMBER} of job ${env.JOB_NAME} was successful!
                    
                    Application URL: https://${ALB_ENDPOINT}
                    Build Version: ${DOCKER_TAG}
                    Commit: ${env.GIT_COMMIT}
                    """,
                    to: 'dev-team@yourcompany.com'
                )
            }
        }
        failure {
            emailext (
                subject: "FAILED: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]'",
                body: """
                The build #${env.BUILD_NUMBER} of job ${env.JOB_NAME} failed!
                
                Please check the build logs for details.
                Build URL: ${env.BUILD_URL}
                """,
                to: 'dev-team@yourcompany.com'
            )
        }
        unstable {
            emailext (
                subject: "UNSTABLE: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]'",
                body: """
                The build #${env.BUILD_NUMBER} of job ${env.JOB_NAME} is unstable!
                
                Please check the build logs for details.
                Build URL: ${env.BUILD_URL}
                """,
                to: 'dev-team@yourcompany.com'
            )
        }
    }
}