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
        BUILD_VERSION = "${env.BUILD_NUMBER}"
        GIT_COMMIT_SHORT = "${env.GIT_COMMIT?.substring(0, 7) ?: 'unknown'}"
        
        // Configuration Files
        VERSION_FILE = 'versions.yaml'
        VERSION_CONFIGMAP_FILE = 'version-configmap.yaml'
        TF_API_GATEWAY_DIR = 'terraform/aws-api-gateway'
    }

    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 """
                            aws configure set region ${AWS_REGION}
                            aws configure set output json
                            aws eks update-kubeconfig --region ${AWS_REGION} --name ${EKS_CLUSTER_NAME}
                        """
                    }
                }
            }
        }

        stage('Version Control') {
            steps {
                script {
                    loadVersionConfig()
                    generateVersionConfigMap()
                    currentBuild.displayName = "#${BUILD_VERSION}-${APPLICATION_VERSION}"
                }
            }
        }

        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 """
                            cd terraform/ecr
                            terraform init -input=false
                            terraform validate
                            terraform plan -out=tfplan -input=false
                            terraform apply -input=false -auto-approve tfplan
                        """
                    }
                }
            }
        }

        stage('Build Microservices') {
            steps {
                script {
                    buildServiceSequential('user-service')
                    buildServiceSequential('product-service')
                    buildServiceSequential('order-service')
                    buildServiceSequential('payment-service')
                    buildServiceSequential('inventory-service')
                    buildServiceSequential('notification-service')
                }
            }
        }

        stage('Build Frontend') {
            steps {
                dir('frontend') {
                    sh '''
                        rm -rf node_modules/ dist/ build/
                        npm ci
                        npm run build
                    '''
                }
            }
        }

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

        stage('Docker Build and Push') {
            steps {
                script {
                    dockerBuildPush('frontend', "${FRONTEND_IMAGE}")
                    dockerBuildPush('user-service', "${USER_SERVICE_IMAGE}")
                    dockerBuildPush('product-service', "${PRODUCT_SERVICE_IMAGE}")
                    dockerBuildPush('order-service', "${ORDER_SERVICE_IMAGE}")
                    dockerBuildPush('payment-service', "${PAYMENT_SERVICE_IMAGE}")
                    dockerBuildPush('inventory-service', "${INVENTORY_SERVICE_IMAGE}")
                    dockerBuildPush('notification-service', "${NOTIFICATION_SERVICE_IMAGE}")
                }
            }
        }

        stage('Kubernetes Setup') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        sh """
                            kubectl create namespace ${NAMESPACE} --dry-run=client -o yaml | kubectl apply -f -
                            
                            ECR_PASSWORD=\$(aws ecr get-login-password --region ${AWS_REGION})
                            kubectl create secret docker-registry regcred \\
                                --docker-server=${DOCKER_REGISTRY} \\
                                --docker-username=AWS \\
                                --docker-password="\$ECR_PASSWORD" \\
                                --namespace ${NAMESPACE} --dry-run=client -o yaml | kubectl apply -f -
                        """
                    }
                }
            }
        }

        stage('Generate Kubernetes Manifests') {
            steps {
                script {
                    generateAppVersionConfigMap()
                    generateJWTSecret()
                    updateDeploymentVersions()
                }
            }
        }

        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 """
                            # Apply all Kubernetes resources
                            kubectl apply -f kubernetes/app-version-configmap.yaml -n ${NAMESPACE}
                            kubectl apply -f kubernetes/jwt-secret.yaml -n ${NAMESPACE}
                            
                            if [ -d "kubernetes/networking" ]; then
                                kubectl apply -f kubernetes/networking/ -n ${NAMESPACE} --recursive=true
                                sleep 30
                            fi
                            
                            if [ -d "kubernetes/databases" ]; then
                                kubectl apply -f kubernetes/databases/ -n ${NAMESPACE} --recursive=true
                            fi
                            
                            if [ -d "kubernetes/message-queue" ]; then
                                kubectl apply -f kubernetes/message-queue/ -n ${NAMESPACE} --recursive=true
                            fi
                            
                            # Apply microservices
                            for service in user-service product-service order-service payment-service inventory-service notification-service; do
                                if [ -d "kubernetes/microservices/\$service" ]; then
                                    kubectl apply -f kubernetes/microservices/\$service/ -n ${NAMESPACE} --recursive=true
                                fi
                            done
                            
                            # Apply frontend
                            if [ -d "kubernetes/frontend" ]; then
                                kubectl apply -f kubernetes/frontend/ -n ${NAMESPACE} --recursive=true
                            fi
                            
                            # Wait for deployments
                            sleep 60
                            kubectl rollout status deployment/frontend -n ${NAMESPACE} --timeout=300s
                            kubectl rollout status deployment/user-service -n ${NAMESPACE} --timeout=300s
                            kubectl rollout status deployment/product-service -n ${NAMESPACE} --timeout=300s
                        """
                    }
                }
            }
        }

        stage('Terraform API Gateway') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        sh """
                            cd ${TF_API_GATEWAY_DIR}
                            terraform init -input=false
                            terraform validate
                            terraform plan -out=tfplan-api-gateway -input=false
                            terraform apply -input=false -auto-approve tfplan-api-gateway
                        """
                    }
                }
            }
        }
    }

    post {
        always {
            sh '''
                docker system prune -f || true
                df -h
            '''
        }
        success {
            echo "🎉 Build and deployment successful!"
        }
        failure {
            echo "❌ Build failed! Check the logs for details."
        }
    }
}

// Functions
def buildServiceSequential(serviceName) {
    dir("microservices/${serviceName}") {
        sh """
            gradle clean build -x test --no-daemon
        """
    }
}

def dockerBuildPush(serviceDir, imageName) {
    def contextDir = serviceDir == 'frontend' ? 'frontend' : "microservices/${serviceDir}"
    def serviceVersion = env."${serviceDir.toUpperCase().replace('-', '_')}_VERSION}"
    
    dir(contextDir) {
        sh """
            docker build --no-cache -t ${imageName}:${serviceVersion} -t ${imageName}:latest .
            docker push ${imageName}:${serviceVersion}
            docker push ${imageName}:latest
            docker rmi ${imageName}:${serviceVersion} || true
            docker rmi ${imageName}:latest || true
        """
    }
}

def loadVersionConfig() {
    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
    }
    
    env.DEPLOYMENT_VERSION = env.APPLICATION_VERSION
}

def generateVersionConfigMap() {
    def versionContent = readYaml file: VERSION_FILE
    
    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}"
  deployment.version: "${DEPLOYMENT_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}
        """
    }
    
    sh "kubectl apply -f ${VERSION_CONFIGMAP_FILE} -n ${NAMESPACE}"
}

def generateAppVersionConfigMap() {
    def configMapContent = """
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-version-info
  namespace: ${NAMESPACE}
data:
  application.version: "${APPLICATION_VERSION}"
  application.name: "${APPLICATION_NAME}"
  build.number: "${BUILD_VERSION}"
  build.commit: "${env.GIT_COMMIT}"
"""
    
    writeFile file: 'kubernetes/app-version-configmap.yaml', text: configMapContent
}

def generateJWTSecret() {
    def jwtKey = "ecommerce-jwt-${APPLICATION_VERSION}-${BUILD_VERSION}-${System.currentTimeMillis()}"
    sh """
        echo -n "${jwtKey}" | base64 > /tmp/jwt-key.txt
    """
    def encodedJwtKey = readFile('/tmp/jwt-key.txt').trim()
    
    def jwtSecretContent = """
apiVersion: v1
kind: Secret
metadata:
  name: jwt-secret
  namespace: ${NAMESPACE}
type: Opaque
data:
  secret: ${encodedJwtKey}
"""
    
    writeFile file: 'kubernetes/jwt-secret.yaml', text: jwtSecretContent
    sh "rm -f /tmp/jwt-key.txt"
}

def updateDeploymentVersions() {
    sh """
        # Update microservices deployment files
        for service in user-service product-service order-service payment-service inventory-service notification-service; do
            deployment_file="kubernetes/microservices/\$service/deployment.yaml"
            if [ -f "\$deployment_file" ]; then
                case "\$service" in
                    "user-service") image_name="${USER_SERVICE_IMAGE}" ;;
                    "product-service") image_name="${PRODUCT_SERVICE_IMAGE}" ;;
                    "order-service") image_name="${ORDER_SERVICE_IMAGE}" ;;
                    "payment-service") image_name="${PAYMENT_SERVICE_IMAGE}" ;;
                    "inventory-service") image_name="${INVENTORY_SERVICE_IMAGE}" ;;
                    "notification-service") image_name="${NOTIFICATION_SERVICE_IMAGE}" ;;
                esac
                
                temp_file=\$(mktemp)
                sed -e "s|319998871902.dkr.ecr.us-east-1.amazonaws.com/ecommerce-\$service:.*|\${image_name}:${DEPLOYMENT_VERSION}|g" \\
                    "\$deployment_file" > "\$temp_file"
                mv "\$temp_file" "\$deployment_file"
            fi
        done
        
        # Update frontend deployment file
        frontend_file="kubernetes/frontend/deployment.yaml"
        if [ -f "\$frontend_file" ]; then
            temp_file=\$(mktemp)
            sed -e "s|319998871902.dkr.ecr.us-east-1.amazonaws.com/ecommerce-frontend:.*|${FRONTEND_IMAGE}:${DEPLOYMENT_VERSION}|g" \\
                "\$frontend_file" > "\$temp_file"
            mv "\$temp_file" "\$frontend_file"
        fi
    """
}