Comprehensive comparison for DevOps technology in Software Development applications

# Bamboo Build Specification for a Node.js Microservice with Docker
# This example demonstrates a complete CI/CD pipeline for a production REST API

---
version: 2

plan:
  project-key: PROD
  key: APISERVICE
  name: Product API Service - Build and Deploy

variables:
  dockerRegistry: registry.company.com
  dockerImage: product-api
  kubernetesNamespace: production
  nodeVersion: 18
  sonarProjectKey: product-api-service

stages:
  - Build and Test:
      manual: false
      final: false
      jobs:
        - Build:
            key: BUILD
            tasks:
              # Checkout source code from repository
              - checkout:
                  force-clean-build: true
                  description: Checkout source code
              
              # Setup Node.js environment
              - script:
                  interpreter: SHELL
                  scripts:
                    - |
                      echo "Setting up Node.js ${bamboo.nodeVersion}"
                      nvm install ${bamboo.nodeVersion}
                      nvm use ${bamboo.nodeVersion}
                      node --version
                      npm --version
                  description: Setup Node.js environment
              
              # Install dependencies with caching
              - script:
                  interpreter: SHELL
                  scripts:
                    - |
                      if [ -d "node_modules" ]; then
                        echo "Using cached node_modules"
                      fi
                      npm ci --prefer-offline
                  description: Install dependencies
              
              # Run linting
              - script:
                  interpreter: SHELL
                  scripts:
                    - |
                      npm run lint
                      if [ $? -ne 0 ]; then
                        echo "Linting failed"
                        exit 1
                      fi
                  description: Run ESLint
              
              # Run unit tests with coverage
              - script:
                  interpreter: SHELL
                  scripts:
                    - |
                      npm run test:coverage
                      if [ $? -ne 0 ]; then
                        echo "Tests failed"
                        exit 1
                      fi
                  description: Run unit tests
              
              # Parse test results
              - test-parser:
                  type: junit
                  test-results: test-results/**/*.xml
                  description: Parse test results
              
              # SonarQube code quality analysis
              - script:
                  interpreter: SHELL
                  scripts:
                    - |
                      sonar-scanner \
                        -Dsonar.projectKey=${bamboo.sonarProjectKey} \
                        -Dsonar.sources=src \
                        -Dsonar.tests=test \
                        -Dsonar.javascript.lcov.reportPaths=coverage/lcov.info \
                        -Dsonar.host.url=${bamboo.sonarUrl} \
                        -Dsonar.login=${bamboo.sonarToken}
                  description: SonarQube Analysis
              
              # Build Docker image
              - script:
                  interpreter: SHELL
                  scripts:
                    - |
                      export IMAGE_TAG="${bamboo.dockerRegistry}/${bamboo.dockerImage}:${bamboo.buildNumber}"
                      export LATEST_TAG="${bamboo.dockerRegistry}/${bamboo.dockerImage}:latest"
                      
                      docker build \
                        --build-arg NODE_VERSION=${bamboo.nodeVersion} \
                        --build-arg BUILD_NUMBER=${bamboo.buildNumber} \
                        --build-arg COMMIT_HASH=${bamboo.repository.revision.number} \
                        -t $IMAGE_TAG \
                        -t $LATEST_TAG \
                        -f Dockerfile .
                      
                      if [ $? -ne 0 ]; then
                        echo "Docker build failed"
                        exit 1
                      fi
                      
                      echo "Built image: $IMAGE_TAG"
                  description: Build Docker image
              
              # Security scan with Trivy
              - script:
                  interpreter: SHELL
                  scripts:
                    - |
                      export IMAGE_TAG="${bamboo.dockerRegistry}/${bamboo.dockerImage}:${bamboo.buildNumber}"
                      
                      trivy image \
                        --severity HIGH,CRITICAL \
                        --exit-code 1 \
                        --format json \
                        --output trivy-report.json \
                        $IMAGE_TAG
                      
                      if [ $? -ne 0 ]; then
                        echo "Security vulnerabilities found"
                        cat trivy-report.json
                        exit 1
                      fi
                  description: Security scan
              
              # Push Docker image to registry
              - script:
                  interpreter: SHELL
                  scripts:
                    - |
                      echo "Logging into Docker registry"
                      echo ${bamboo.dockerPassword} | docker login ${bamboo.dockerRegistry} -u ${bamboo.dockerUsername} --password-stdin
                      
                      export IMAGE_TAG="${bamboo.dockerRegistry}/${bamboo.dockerImage}:${bamboo.buildNumber}"
                      export LATEST_TAG="${bamboo.dockerRegistry}/${bamboo.dockerImage}:latest"
                      
                      docker push $IMAGE_TAG
                      docker push $LATEST_TAG
                      
                      echo "Successfully pushed images"
                      docker logout ${bamboo.dockerRegistry}
                  description: Push to registry
            
            artifacts:
              - name: test-results
                pattern: test-results/**
                shared: true
              - name: coverage-report
                pattern: coverage/**
                shared: true
              - name: trivy-report
                pattern: trivy-report.json
                shared: true
            
            requirements:
              - docker
              - nodejs

  - Deploy to Staging:
      manual: false
      final: false
      jobs:
        - Deploy:
            key: DEPLOY_STAGING
            tasks:
              - script:
                  interpreter: SHELL
                  scripts:
                    - |
                      export IMAGE_TAG="${bamboo.dockerRegistry}/${bamboo.dockerImage}:${bamboo.buildNumber}"
                      
                      kubectl config use-context staging
                      
                      kubectl set image deployment/product-api \
                        product-api=$IMAGE_TAG \
                        -n staging \
                        --record
                      
                      kubectl rollout status deployment/product-api -n staging --timeout=5m
                      
                      if [ $? -ne 0 ]; then
                        echo "Deployment failed, rolling back"
                        kubectl rollout undo deployment/product-api -n staging
                        exit 1
                      fi
                      
                      echo "Deployment successful"
                  description: Deploy to Kubernetes staging
              
              # Run smoke tests
              - script:
                  interpreter: SHELL
                  scripts:
                    - |
                      sleep 30
                      export API_URL="https://staging.api.company.com"
                      
                      response=$(curl -s -o /dev/null -w "%{http_code}" $API_URL/health)
                      
                      if [ $response -ne 200 ]; then
                        echo "Health check failed with status: $response"
                        exit 1
                      fi
                      
                      echo "Smoke tests passed"
                  description: Run smoke tests

  - Deploy to Production:
      manual: true
      final: true
      jobs:
        - Deploy:
            key: DEPLOY_PROD
            tasks:
              - script:
                  interpreter: SHELL
                  scripts:
                    - |
                      export IMAGE_TAG="${bamboo.dockerRegistry}/${bamboo.dockerImage}:${bamboo.buildNumber}"
                      
                      kubectl config use-context production
                      
                      kubectl set image deployment/product-api \
                        product-api=$IMAGE_TAG \
                        -n ${bamboo.kubernetesNamespace} \
                        --record
                      
                      kubectl rollout status deployment/product-api -n ${bamboo.kubernetesNamespace} --timeout=10m
                      
                      if [ $? -ne 0 ]; then
                        echo "Production deployment failed"
                        kubectl rollout undo deployment/product-api -n ${bamboo.kubernetesNamespace}
                        exit 1
                      fi
                      
                      echo "Production deployment successful"
                  description: Deploy to Kubernetes production

notifications:
  - events:
      - plan-completed
      - plan-failed
    recipients:
      - email: [email protected]
      - slack: "#deployments"

branches:
  create: for-pull-request
  delete:
    after-deleted-days: 7
    after-inactive-days: 30

triggers:
  - polling:
      period: 180
  - remote:
      ip-addresses: 192.168.1.0/24