CI/CD Integration

name: Docker CI/CD

on:
  push:
    branches: [ main ]
    # სურვილისამებრ, გაეშვას თეგებზე release-ებისთვის
    tags: [ 'v*.*.*' ]
  pull_request:
    branches: [ main ]

jobs:
  build-and-push:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v3
        with:
            # სრული ისტორიის გადმოწერა სწორი ვერსიონირებისთვის
          fetch-depth: 0

      # Docker-ის მეტამონაცემების ამოღება
      - name: Extract Docker metadata
        id: meta
        uses: docker/metadata-action@v4
        with:
          images: username/app
            # თეგების გენერირება branch-ის, git თეგის და commit SHA-ს მიხედვით
          tags: |
            type=ref,event=branch
            type=ref,event=pr
            type=semver,pattern={{version}}
            type=semver,pattern={{major}}.{{minor}}
            type=sha,format=short

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v2
        with:
            # პარალელური აწყობისთვის რამდენიმე კვანძის გამოყენება
          driver-opts: network=host

      - name: Login to DockerHub
        # ეს ნაბიჯი გაეშვება მხოლოდ რეესტრში ატვირთვისას (არა pull request-ებზე)
        if: github.event_name != 'pull_request'
        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}
          # Optionally add logout: true for security

      # Docker-ის ფენების კეშირება build-ების დასაჩქარებლად
      - name: Cache Docker layers
        uses: actions/cache@v3
        with:
          path: /tmp/.buildx-cache
          key: ${{ runner.os }}-buildx-${{ github.sha }}
          restore-keys: |
            ${{ runner.os }}-buildx-

      # სურვილისამებრ: ტესტების გაშვება აწყობამდე
      - name: Run tests
        run: |
          docker build -t username/app:test --target test .
          docker run username/app:test

      # მოწყვლადობების სკანირება ატვირთვამდე
      - name: Run Trivy vulnerability scanner
        uses: aquasecurity/trivy-action@master
        with:
          image-ref: 'username/app:test'
          format: 'table'
          exit-code: '1'
          ignore-unfixed: true
          severity: 'CRITICAL,HIGH'

      - name: Build and push
        uses: docker/build-push-action@v4
        with:
          context: .
            # ატვირთვა მხოლოდ იმ შემთხვევაში, თუ არ არის PR და ტესტები/სკანირება წარმატებულია
          push: ${{ github.event_name != 'pull_request' }}
            # მეტამონაცემების გამოყენება ჭკვიანი თეგირებისთვის
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
            # რეესტრის კეშის გამოყენება ეფექტური build-ებისთვის
          cache-from: type=registry,ref=username/app:buildcache
          cache-to: type=registry,ref=username/app:buildcache,mode=max
            # Build არგუმენტები საჭიროების შემთხვევაში
          build-args: |
            BUILD_VERSION=${{ github.ref_name }}
            BUILD_DATE=$(date -u +'%Y-%m-%dT%H:%M:%SZ')
            # BuildKit-ის ეფექტური build შესაძლებლობების გამოყენება
          platforms: linux/amd64,linux/arm64
            # წარმომავლობის დადასტურების დამატება
          provenance: true
            # Image-ის ხელმოწერა უსაფრთხოებისთვის (თუ კონფიგურირებულია)
            # ხელმოწერის ჩართვა: true

      # Deployment-ი staging გარემოში წარმატებული build/push-ის შემდეგ
      - name: Deploy to staging
        if: github.event_name != 'pull_request' && github.ref == 'refs/heads/main'
        run: |
          echo "Deployment-ი staging გარემოში"
          # გამოიყენეთ kubectl, helm, ან სხვა deployment-ის ხელსაწყოები
          # kubectl set image deployment/app-deployment app=username/app:${{ github.sha }}

# პროცესის ყველა ეტაპის განსაზღვრა
stages:
  - build
  - test
  - security
  - deploy
  - verify

# გლობალური ცვლადები, რომლებიც გამოიყენება job-ებში
variables:
  # Commit SHA-ს გამოყენება უნიკალური image-ის თეგირებისთვის
  DOCKER_IMAGE: $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA
  # თეგის მინიჭება semver-ით, თუ თეგი აიტვირთება
  RELEASE_IMAGE: $CI_REGISTRY_IMAGE:$CI_COMMIT_TAG
  # გამოიყენეთ Docker Hub-ის სარკე სიჩქარის ლიმიტების თავიდან ასაცილებლად
  DOCKER_HUB_MIRROR: https://mirror.gcr.io
  # Docker BuildKit-ის კონფიგურაცია ეფექტური build-ებისთვის
  DOCKER_BUILDKIT: 1
  # მორგებული build არგუმენტები
  BUILD_ARGS: "--build-arg BUILD_DATE=$(date -u +'%Y-%m-%dT%H:%M:%SZ') --build-arg VCS_REF=$CI_COMMIT_SHORT_SHA"

# Build ეტაპი: აპლიკაციის კომპილაცია და შეფუთვა
build:
  stage: build
  # გამოიყენეთ Docker-in-Docker image-ების ასაწყობად
  image: docker:20.10.16
  services:
    - docker:20.10.16-dind
  before_script:
    # საჭიროების შემთხვევაში დააინსტალირეთ დამოკიდებულებები
    - apk add --no-cache git curl jq
    # Docker BuildX-ის კონფიგურაცია მრავალპლატფორმიანი build-ებისთვის
    - docker buildx create --use
    # GitLab კონტეინერების რეესტრში ავტორიზაცია
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
  script:
    # წინა build-ებიდან კეშირება
    - |
      CACHE_FROM=""
      if docker pull $CI_REGISTRY_IMAGE:latest &>/dev/null; then
        CACHE_FROM="--cache-from $CI_REGISTRY_IMAGE:latest"
      fi
    # აპლიკაციის image-ის აწყობა მეტამონაცემებით
    - >
      docker build
      $CACHE_FROM
      $BUILD_ARGS
      --build-arg CI_PIPELINE_ID=$CI_PIPELINE_ID
      --label org.opencontainers.image.created="$(date -u +'%Y-%m-%dT%H:%M:%SZ')"
      --label org.opencontainers.image.revision="$CI_COMMIT_SHA"
      --label org.opencontainers.image.version="${CI_COMMIT_TAG:-$CI_COMMIT_SHORT_SHA}"
      -t $DOCKER_IMAGE
      -t $CI_REGISTRY_IMAGE:latest
      .
    # ორივე თეგის რეესტრში ატვირთვა
    - docker push $DOCKER_IMAGE
    - docker push $CI_REGISTRY_IMAGE:latest
    # ვერსიის თეგის მინიჭება, თუ ეს თეგით build-ია
    - |
      if [ -n "$CI_COMMIT_TAG" ]; then
        docker tag $DOCKER_IMAGE $RELEASE_IMAGE
        docker push $RELEASE_IMAGE
      fi
  # არტეფაქტების შექმნა შემდეგი ეტაპებისთვის
  artifacts:
    paths:
      - docker-image-info.json
    expire_in: 1 week
  # დამოკიდებულებების კეშირება მომავალი build-ების დასაჩქარებლად
  cache:
    key: ${CI_COMMIT_REF_SLUG}
    paths:
      - node_modules/
      - .npm/
  only:
    - main
    - tags
    - merge_requests

# ტესტირების ეტაპი: ავტომატური ტესტების გაშვება
test:
  stage: test
  image: $DOCKER_IMAGE
  # სატესტო გარემოს ცვლადების განსაზღვრა
  variables:
    NODE_ENV: test
    # გამოიყენეთ in-memory მონაცემთა ბაზა ტესტებისთვის
    DATABASE_URL: "sqlite://:memory:"
  before_script:
    # Prepare test environment
    - echo "Setting up test environment"
    - npm install --only=dev
  script:
    # Run unit tests
    - npm run test:unit
    # Run integration tests
    - npm run test:integration
    # Run end-to-end tests if not a merge request (for speed)
    - '[ "$CI_PIPELINE_SOURCE" = "merge_request_event" ] || npm run test:e2e'
    # Generate code coverage report
    - npm run coverage
  # ტესტის რეპორტების გამოქვეყნება არტეფაქტებად
  artifacts:
    reports:
      junit: junit-*.xml
      coverage_report:
        coverage_format: cobertura
        path: coverage/cobertura-coverage.xml
    paths:
      - coverage/
  coverage: '/Statements\s+:\s+(\d+.?\d*)%/'
  only:
    - main
    - tags
    - merge_requests

# უსაფრთხოების სკანირების ეტაპი
security:
  stage: security
  image:
    name: aquasec/trivy:latest
    entrypoint: [""]
  variables:
    # პროცესის შეწყვეტა კრიტიკულ მოწყვლადობებზე
    TRIVY_EXIT_CODE: 1
    TRIVY_FORMAT: json
    TRIVY_OUTPUT: trivy-results.json
    # dev დამოკიდებულებების გამოტოვება
    TRIVY_SEVERITY: CRITICAL,HIGH
  script:
    # დასასკანერებელი image-ის გადმოწერა
    - docker pull $DOCKER_IMAGE
    # Image-ის სკანირება მოწყვლადობებზე
    - trivy image --format $TRIVY_FORMAT --output $TRIVY_OUTPUT --exit-code $TRIVY_EXIT_CODE $DOCKER_IMAGE
  # უსაფრთხოების რეპორტის გენერირება
  artifacts:
    paths:
      - trivy-results.json
    reports:
      container_scanning: trivy-results.json
  allow_failure: true
  only:
    - main
    - tags

# Deployment-ის ეტაპი
deploy:
  stage: deploy
  image: docker:20.10.16
  services:
    - docker:20.10.16-dind
  before_script:
    # Deployment-ის ხელსაწყოების ინსტალაცია
    - apk add --no-cache curl bash
    # რეესტრში ავტორიზაცია
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
  script:
    # Deployment-ისთვის image-ის გადმოწერა
    - docker pull $DOCKER_IMAGE
    # Production release-ებისთვის გამოიყენეთ ვერსიის თეგი
    - |
      if [ -n "$CI_COMMIT_TAG" ]; then
        docker tag $DOCKER_IMAGE $CI_REGISTRY_IMAGE:stable
        docker push $CI_REGISTRY_IMAGE:stable
        DEPLOY_ENV="production"
      else
        DEPLOY_ENV="staging"
      fi
    # Deployment-ი შესაბამის გარემოში
    - echo "Deploying to $DEPLOY_ENV environment"
    # მაგალითი docker-compose-ის ან kubectl-ის გამოყენებით
    - |
      if [ "$DEPLOY_ENV" = "production" ]; then
        echo "Production deployment-ის შესრულება"
        # kubectl set image deployment/app app=$DOCKER_IMAGE
      else
        echo "Performing staging deployment"
        # docker-compose -f docker-compose.staging.yml up -d
      fi
  environment:
    name: $DEPLOY_ENV
    url: https://$DEPLOY_ENV.example.com
  only:
    - main
    - tags

# ვერიფიკაციის ეტაპი
verify:
  stage: verify
  image: curlimages/curl
  script:
    # დაელოდეთ deployment-ის დასტაბილურებას
    - sleep 30
    # სიჯანსაღის შემოწმება
    - curl -f https://$DEPLOY_ENV.example.com/health || exit 1
    # Smoke ტესტების გაშვება
    - curl -f https://$DEPLOY_ENV.example.com/api/status | grep -q "OK"
  environment:
    name: $DEPLOY_ENV
    url: https://$DEPLOY_ENV.example.com
  only:
    - main
    - tags

version: 2.1

# ხელახლა გამოსაყენებელი ბრძანებების განსაზღვრა
commands:
  docker_build:
    description: "Docker-ის იმიჯის აგება და თეგირება"
    parameters:
      image_name:
        type: string
        default: "myapp"
      dockerfile:
        type: string
        default: "Dockerfile"
      build_args:
        type: string
        default: ""
    steps:
      - run:
          name: Docker-ის იმიჯის აგება
          command: |
            # თეგების გამოთვლა
            COMMIT_TAG=${CIRCLE_SHA1:0:8}
            VERSION_TAG=${CIRCLE_TAG:-$COMMIT_TAG}

            # გამოიყენეთ კეში წინა build-ებიდან, თუ ხელმისაწვდომია
            CACHE_FROM=""
            if docker pull $DOCKERHUB_USERNAME/<< parameters.image_name >>:latest &>/dev/null; then
              CACHE_FROM="--cache-from $DOCKERHUB_USERNAME/<< parameters.image_name >>:latest"
            fi

            # აწყობა შესაბამისი თეგებითა და ლეიბლებით
            docker build \
              $CACHE_FROM \
              -f << parameters.dockerfile >> \
              --build-arg BUILDKIT_INLINE_CACHE=1 \
              --build-arg BUILD_DATE=$(date -u +'%Y-%m-%dT%H:%M:%SZ') \
              --build-arg VCS_REF=${CIRCLE_SHA1} \
              --build-arg VERSION=${VERSION_TAG} \
              << parameters.build_args >> \
              -t << parameters.image_name >>:${COMMIT_TAG} \
              -t << parameters.image_name >>:latest \
              -t $DOCKERHUB_USERNAME/<< parameters.image_name >>:${COMMIT_TAG} \
              -t $DOCKERHUB_USERNAME/<< parameters.image_name >>:latest \
              .

            # ვერსიის თეგის მინიჭება, თუ ეს თეგით build-ია
            if [ -n "${CIRCLE_TAG}" ]; then
              docker tag << parameters.image_name >>:${COMMIT_TAG} $DOCKERHUB_USERNAME/<< parameters.image_name >>:${CIRCLE_TAG}
            fi

# შემსრულებლის გარემოების განსაზღვრა
executors:
  docker-builder:
    docker:
      - image: cimg/base:2023.03
    resource_class: medium+

# Job-ების განსაზღვრა
jobs:
  build:
    executor: docker-builder
    steps:
      - checkout
      - setup_remote_docker:
          version: 20.10.14
          docker_layer_caching: true
      - docker_build:
          image_name: myapp
          build_args: "--build-arg NODE_ENV=production"
      - run:
          name: იმიჯის შენახვა შემდგომი job-ებისთვის
          command: |
            COMMIT_TAG=${CIRCLE_SHA1:0:8}
            mkdir -p /tmp/workspace
            docker save myapp:${COMMIT_TAG} | gzip > /tmp/workspace/myapp-image.tar.gz
      - persist_to_workspace:
          root: /tmp/workspace
          paths:
            - myapp-image.tar.gz

  test:
    docker:
      - image: cimg/base:2023.03
    steps:
      - setup_remote_docker:
          version: 20.10.14
      - attach_workspace:
          at: /tmp/workspace
      - run:
          name: Docker-ის იმიჯის ჩატვირთვა
          command: |
            docker load < /tmp/workspace/myapp-image.tar.gz
      - run:
          name: Unit ტესტების გაშვება
          command: |
            COMMIT_TAG=${CIRCLE_SHA1:0:8}
            docker run --rm myapp:${COMMIT_TAG} npm run test:unit
      - run:
          name: ინტეგრაციული ტესტების გაშვება
          command: |
            COMMIT_TAG=${CIRCLE_SHA1:0:8}
            docker run --rm myapp:${COMMIT_TAG} npm run test:integration
      - run:
          name: უსაფრთხოების სკანირების გაშვება
          command: |
            COMMIT_TAG=${CIRCLE_SHA1:0:8}
            docker run --rm -v /var/run/docker.sock:/var/run/docker.sock aquasec/trivy:latest image --severity HIGH,CRITICAL --exit-code 0 myapp:${COMMIT_TAG}

  push:
    executor: docker-builder
    steps:
      - checkout
      - setup_remote_docker:
          version: 20.10.14
      - attach_workspace:
          at: /tmp/workspace
      - run:
          name: Docker-ის იმიჯის ჩატვირთვა
          command: |
            docker load < /tmp/workspace/myapp-image.tar.gz
      - run:
          name: Docker Hub-ზე ატვირთვა
          command: |
            COMMIT_TAG=${CIRCLE_SHA1:0:8}
            echo "$DOCKERHUB_PASSWORD" | docker login -u "$DOCKERHUB_USERNAME" --password-stdin
            docker push $DOCKERHUB_USERNAME/myapp:${COMMIT_TAG}
            docker push $DOCKERHUB_USERNAME/myapp:latest

            # ვერსიის თეგის ატვირთვა, თუ ეს თეგით build-ია
            if [ -n "${CIRCLE_TAG}" ]; then
              docker push $DOCKERHUB_USERNAME/myapp:${CIRCLE_TAG}
            fi

            # უსაფრთხოებისთვის ყოველთვის გამოდით სისტემიდან
            docker logout

  deploy-staging:
    docker:
      - image: cimg/base:2023.03
    steps:
      - checkout
      - run:
          name: Deployment-ის ხელსაწყოების ინსტალაცია
          command: |
            sudo apt-get update
            sudo apt-get install -y curl jq
            # kubectl-ის ინსტალაცია Kubernetes-ის deployment-ებისთვის
            curl -LO "https://dl.k8s.io/release/v1.26.0/bin/linux/amd64/kubectl"
            chmod +x kubectl
            sudo mv kubectl /usr/local/bin/
      - run:
          name: Staging-ზე დეპლოი
          command: |
            COMMIT_TAG=${CIRCLE_SHA1:0:8}
            echo "Deploying $DOCKERHUB_USERNAME/myapp:${COMMIT_TAG} to staging"
            # Deployment-ის მაგალითი kubectl-ის გამოყენებით
            # kubectl config use-context staging
            # kubectl set image deployment/myapp myapp=$DOCKERHUB_USERNAME/myapp:${COMMIT_TAG} --record
            # kubectl rollout status deployment/myapp

  deploy-production:
    docker:
      - image: cimg/base:2023.03
    steps:
      - checkout
      - run:
          name: Deployment-ის ხელსაწყოების ინსტალაცია
          command: |
            sudo apt-get update
            sudo apt-get install -y curl jq
            curl -LO "https://dl.k8s.io/release/v1.26.0/bin/linux/amd64/kubectl"
            chmod +x kubectl
            sudo mv kubectl /usr/local/bin/
      - run:
          name: Production-ზე დეპლოი
          command: |
            VERSION_TAG=${CIRCLE_TAG}
            echo "Deploying $DOCKERHUB_USERNAME/myapp:${VERSION_TAG} to production"
            # საწარმოო deployment-ის მაგალითი
            # kubectl config use-context production
            # kubectl set image deployment/myapp myapp=$DOCKERHUB_USERNAME/myapp:${VERSION_TAG} --record
            # kubectl rollout status deployment/myapp

# სამუშაო პროცესების ორკესტრირება
workflows:
  version: 2
  build-test-deploy:
    jobs:
      - build:
          filters:
            tags:
              only: /^v.*/
      - test:
          requires:
            - build
          filters:
            tags:
              only: /^v.*/
      - push:
          requires:
            - test
          filters:
            tags:
              only: /^v.*/
            branches:
              only: main
      - deploy-staging:
          requires:
            - push
          filters:
            branches:
              only: main
      - approve-production:
          type: approval
          requires:
            - push
          filters:
            tags:
              only: /^v.*/
            branches:
              ignore: /.*/
      - deploy-production:
          requires:
            - approve-production
          filters:
            tags:
              only: /^v.*/
            branches:
              ignore: /.*/

version: '3.8'
services:
  # მთავარი აპლიკაციის სერვისი
  app:
    build:
      context: .
      dockerfile: Dockerfile
      target: development # გამოიყენეთ განვითარების ეტაპი ტესტირების დამოკიდებულებებით
    depends_on:
      db:
        condition: service_healthy # დაელოდეთ მონაცემთა ბაზის სრულ მზადყოფნას
      redis:
        condition: service_healthy
    environment:
      - NODE_ENV=test
      - DB_HOST=db
      - DB_PORT=5432
      - DB_USER=test
      - DB_PASSWORD=test
      - DB_NAME=test_db
      - REDIS_HOST=redis
      - REDIS_PORT=6379
    # საწყისი კოდის დამაგრება განვითარების დროს hot reloading-ისთვის
    volumes:
      - ./src:/app/src:ro
      - ./test:/app/test:ro
      - node_modules:/app/node_modules
    # პორტის გახსნა debug-ისთვის
    ports:
      - "9229:9229"
    # ჯანმრთელობის შემოწმების დამატება მზადყოფნისთვის
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://localhost:3000/health"]
      interval: 5s
      timeout: 3s
      retries: 5
      start_period: 10s

  # მონაცემთა ბაზის სერვისი ტესტირებისთვის
  db:
    image: postgres:13-alpine
    environment:
      - POSTGRES_USER=test
      - POSTGRES_PASSWORD=test
      - POSTGRES_DB=test_db
    volumes:
      - ./test/fixtures/init.sql:/docker-entrypoint-initdb.d/init.sql:ro
      - postgres-data:/var/lib/postgresql/data
    # ჯანმრთელობის შემოწმება უზრუნველყოფს, რომ მონაცემთა ბაზა მზად არის ტესტების გაშვებამდე
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U test -d test_db"]
      interval: 5s
      timeout: 3s
      retries: 5
      start_period: 10s

  # კეშის სერვისი
  redis:
    image: redis:alpine
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 5

  # Unit ტესტები
  test-unit:
    image: myapp:test
    depends_on:
      app:
        condition: service_healthy
    environment:
      - NODE_ENV=test
      - TEST_TYPE=unit
    volumes:
      - ./test/reports:/app/test/reports
    command: npm run test:unit

  # ინტეგრაციული ტესტები
  test-integration:
    image: myapp:test
    depends_on:
      app:
        condition: service_healthy
      db:
        condition: service_healthy
      redis:
        condition: service_healthy
    environment:
      - NODE_ENV=test
      - TEST_TYPE=integration
      - DB_HOST=db
      - REDIS_HOST=redis
    volumes:
      - ./test/reports:/app/test/reports
    command: npm run test:integration

  # End-to-end ტესტები
  test-e2e:
    image: myapp:test
    depends_on:
      app:
        condition: service_healthy
      db:
        condition: service_healthy
    environment:
      - NODE_ENV=test
      - TEST_TYPE=e2e
      - APP_URL=http://app:3000
    volumes:
      - ./test/reports:/app/test/reports
      - ./test/screenshots:/app/test/screenshots
    command: npm run test:e2e

volumes:
  node_modules:
  postgres-data:

# Example deployment script with advanced environment handling
#!/bin/bash
set -eo pipefail

# Set variables based on environment
case "$ENVIRONMENT" in
  "dev")
    DOCKER_COMPOSE_FILE="docker-compose.dev.yml"
    REPLICAS=1
    RESOURCES="--cpus=0.5 --memory=512m"
    REGISTRY="dev-registry.example.com"
    ;;
  "qa")
    DOCKER_COMPOSE_FILE="docker-compose.qa.yml"
    REPLICAS=2
    RESOURCES="--cpus=1 --memory=1g"
    REGISTRY="qa-registry.example.com"
    ;;
  "staging")
    DOCKER_COMPOSE_FILE="docker-compose.staging.yml"
    REPLICAS=2
    RESOURCES="--cpus=2 --memory=2g"
    REGISTRY="staging-registry.example.com"
    ;;
  "production")
    DOCKER_COMPOSE_FILE="docker-compose.prod.yml"
    REPLICAS=5
    RESOURCES="--cpus=4 --memory=4g"
    REGISTRY="production-registry.example.com"
    # Additional production safeguards
    DEPLOY_TIMEOUT="--timeout 300s"
    HEALTHCHECK="--health-cmd 'curl -f http://localhost/health || exit 1' --health-interval=10s --health-retries=5"
    ;;
  *)
    echo "Unknown environment: $ENVIRONMENT"
    exit 1
    ;;
esac

# Pull the specific image version
IMAGE_TAG=${VERSION:-latest}
docker pull $REGISTRY/myapp:$IMAGE_TAG

# Apply environment-specific configurations
envsubst < ${DOCKER_COMPOSE_FILE}.template > ${DOCKER_COMPOSE_FILE}

# Deploy with environment-specific settings
if [ "$ENVIRONMENT" == "production" ]; then
  # Production uses a more careful deployment strategy
  echo "Deploying to production with rolling update"

  # Verify image security before deployment
  docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
    aquasec/trivy:latest image --severity HIGH,CRITICAL \
    --exit-code 1 $REGISTRY/myapp:$IMAGE_TAG || { echo "Security check failed"; exit 1; }

  # Backup current state
  docker-compose -f docker-compose.prod.yml config > docker-compose.prev.yml

  # Deploy new version
  docker-compose -f $DOCKER_COMPOSE_FILE up -d --remove-orphans $DEPLOY_TIMEOUT

  # Verify deployment health
  timeout 60s bash -c 'until docker-compose -f $DOCKER_COMPOSE_FILE ps | grep -q "(healthy)"; do sleep 2; done'

  # Run smoke tests
  ./run_smoke_tests.sh || {
    echo "Smoke tests failed, rolling back"
    docker-compose -f docker-compose.prev.yml up -d
    exit 1
  }
else
  # Development and staging environments
  echo "Deploying to $ENVIRONMENT"
  docker-compose -f $DOCKER_COMPOSE_FILE up -d --remove-orphans
fi

# Cleanup
if [ "$ENVIRONMENT" != "production" ]; then
  echo "Pruning old images from $ENVIRONMENT"
  docker image prune -a -f --filter "until=24h"
fi

echo "Deployment to $ENVIRONMENT complete"

# Base docker-compose configuration
# docker-compose.base.yml
version: '3.8'
services:
  app:
    image: ${REGISTRY}/myapp:${IMAGE_TAG:-latest}
    restart: unless-stopped
    environment:
      - NODE_ENV=${ENVIRONMENT}
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 10s
      timeout: 5s
      retries: 3
      start_period: 30s
    deploy:
      resources:
        limits:
          cpus: "${CPU_LIMIT:-0.5}"
          memory: "${MEMORY_LIMIT:-512M}"

# Development-specific overrides
# docker-compose.dev.yml
version: '3.8'
services:
  app:
    extends:
      file: docker-compose.base.yml
      service: app
    environment:
      - NODE_ENV=development
      - DEBUG=app:*
      - LOG_LEVEL=debug
    volumes:
      - ./src:/app/src:ro
      - ./config:/app/config:ro
    ports:
      - "3000:3000"
      - "9229:9229" # Debug port
    command: ["npm", "run", "dev"]

# Production-specific overrides
# docker-compose.prod.yml
version: '3.8'
services:
  app:
    extends:
      file: docker-compose.base.yml
      service: app
    environment:
      - NODE_ENV=production
      - LOG_LEVEL=info
    secrets:
      - app_config
      - db_credentials
    deploy:
      replicas: 5
      update_config:
        order: start-first
        failure_action: rollback
        delay: 10s
      restart_policy:
        condition: any
        delay: 5s
        max_attempts: 3
        window: 120s
      resources:
        limits:
          cpus: '4'
          memory: 4G
        reservations:
          cpus: '2'
          memory: 2G

secrets:
  app_config:
    external: true
  db_credentials:
    external: true