klz-cables.com/.gitea/workflows/deploy.yml

name: Build & Deploy KLZ Cables

on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: docker

    steps:
      - name: Checkout repo
        uses: actions/checkout@v3

      - name: Install tools
        run: |
          apt-get update
          apt-get install -y \
            docker.io \
            openssh-client \
            rsync

      - name: Login to registry
        env:
          REGISTRY_USER: ${{ secrets.REGISTRY_USER }}
          REGISTRY_PASS: ${{ secrets.REGISTRY_PASS }}
        run: |
          echo "$REGISTRY_PASS" | DOCKER_API_VERSION=1.44 docker login registry.infra.mintel.me -u "$REGISTRY_USER" --password-stdin

      - name: Build image
        run: |
          DOCKER_API_VERSION=1.44 docker build \
            --pull \
            --build-arg NEXT_PUBLIC_UMAMI_WEBSITE_ID=${{ secrets.NEXT_PUBLIC_UMAMI_WEBSITE_ID }} \
            --build-arg NEXT_PUBLIC_UMAMI_SCRIPT_URL=${{ secrets.NEXT_PUBLIC_UMAMI_SCRIPT_URL }} \
            --build-arg NEXT_PUBLIC_SENTRY_DSN=${{ secrets.SENTRY_DSN }} \
            -t registry.infra.mintel.me/mintel/klz-cables.com:latest .

      - name: Push image
        run: DOCKER_API_VERSION=1.44 docker push registry.infra.mintel.me/mintel/klz-cables.com:latest

      - name: Setup SSH
        run: |
          mkdir -p ~/.ssh
          printf "%s\n" "${{ secrets.ALPHA_SSH_KEY }}" > ~/.ssh/id_ed25519
          chmod 600 ~/.ssh/id_ed25519
          ssh-keyscan -H alpha.mintel.me >> ~/.ssh/known_hosts

      - name: Sync docker-compose file to server
        run: |
          echo "Checking for docker-compose file..."

          COMPOSE_FILE=""
          if [ -f "docker-compose.yml" ]; then
            COMPOSE_FILE="docker-compose.yml"
          elif [ -f "docker-compose.yaml" ]; then
            COMPOSE_FILE="docker-compose.yaml"
          else
            echo "ERROR: Keine docker-compose.yml oder .yaml gefunden!"
            exit 1
          fi

          echo "Found and syncing: $COMPOSE_FILE"

          # Create a temporary directory for files to sync
          mkdir -p /tmp/klz-deploy
          cp "$COMPOSE_FILE" /tmp/klz-deploy/
          
          # Check if varnish directory exists and copy it
          if [ -d "varnish" ]; then
            echo "Syncing varnish directory..."
            cp -r varnish /tmp/klz-deploy/
          fi

          # Use tar to bundle files and send them via SSH in a single connection
          tar czf - -C /tmp/klz-deploy . | \
          ssh -i ~/.ssh/id_ed25519 -o StrictHostKeyChecking=no -o IPQoS=0x00 deploy@alpha.mintel.me \
          "mkdir -p /home/deploy/sites/klz-cables.com/ && tar xzf - -C /home/deploy/sites/klz-cables.com/ && echo 'Files synced successfully' && ls -la /home/deploy/sites/klz-cables.com/"
          
          echo "File sync completed"

      - name: Deploy on server
        env:
          REGISTRY_USER: ${{ secrets.REGISTRY_USER }}
          REGISTRY_PASS: ${{ secrets.REGISTRY_PASS }}
          NEXT_PUBLIC_UMAMI_WEBSITE_ID: ${{ secrets.NEXT_PUBLIC_UMAMI_WEBSITE_ID }}
          NEXT_PUBLIC_UMAMI_SCRIPT_URL: ${{ secrets.NEXT_PUBLIC_UMAMI_SCRIPT_URL }}
          SENTRY_DSN: ${{ secrets.SENTRY_DSN }}
          REDIS_URL: ${{ secrets.REDIS_URL }}
          REDIS_KEY_PREFIX: ${{ secrets.REDIS_KEY_PREFIX }}
        run: |
          echo "Starting deployment on server..."
          
          # Create environment file for deployment
          cat > /tmp/deploy.env << EOF
          export REGISTRY_USER='${REGISTRY_USER}'
          export REGISTRY_PASS='${REGISTRY_PASS}'
          export NEXT_PUBLIC_UMAMI_WEBSITE_ID='${NEXT_PUBLIC_UMAMI_WEBSITE_ID}'
          export NEXT_PUBLIC_UMAMI_SCRIPT_URL='${NEXT_PUBLIC_UMAMI_SCRIPT_URL}'
          export SENTRY_DSN='${SENTRY_DSN}'
          export REDIS_URL='${REDIS_URL}'
          export REDIS_KEY_PREFIX='${REDIS_KEY_PREFIX}'
          EOF

          # Create deployment script
          cat > /tmp/deploy.sh << 'DEPLOY_EOF'
          #!/bin/bash
          set -e
          
          # Load environment variables
          source /tmp/deploy.env
          
          echo '=== Starting deployment ==='
          cd /home/deploy/sites/klz-cables.com
          
          echo '=== Creating .env ==='
          cat > .env << EOF
          NEXT_PUBLIC_UMAMI_WEBSITE_ID=${NEXT_PUBLIC_UMAMI_WEBSITE_ID}
          NEXT_PUBLIC_UMAMI_SCRIPT_URL=${NEXT_PUBLIC_UMAMI_SCRIPT_URL}
          SENTRY_DSN=${SENTRY_DSN}
          REDIS_URL=${REDIS_URL}
          REDIS_KEY_PREFIX=${REDIS_KEY_PREFIX}
          EOF
          
          echo '=== Logging into Docker registry ==='
          echo "${REGISTRY_PASS}" | docker login registry.infra.mintel.me -u "${REGISTRY_USER}" --password-stdin
          
          echo '=== Checking if infra network exists ==='
          if ! docker network inspect infra >/dev/null 2>&1; then
            echo 'Creating infra network...'
            docker network create infra || true
          fi
          
          echo '=== Checking current containers ==='
          docker compose ps

          echo '=== Removing local image to force fresh pull ==='
          docker rmi registry.infra.mintel.me/mintel/klz-cables.com:latest || true

          echo '=== Pulling latest image ==='
          docker compose pull
          
          echo '=== Stopping all containers ==='
          docker compose down
          
          echo '=== Starting all containers ==='
          docker compose up -d
          
          echo '=== Waiting for containers to be ready (30 seconds) ==='
          sleep 30
          
          echo '=== Verifying deployment status ==='
          docker compose ps
          
          echo '=== Verifying application health ==='
          # Wait a bit more for the app to be fully ready
          sleep 15
          if curl -f -s http://localhost:80/health > /dev/null 2>&1; then
            echo '✓ Application health check passed'
          else
            echo '✗ Application health check failed - checking app logs'
            docker compose logs --tail=50 app
            exit 1
          fi

          echo '=== Cleaning up old images ==='
          docker image prune -f --filter 'until=24h'

          echo '=== Deployment completed successfully ==='
          DEPLOY_EOF
          
          # Make script executable
          chmod +x /tmp/deploy.sh
          
          # SSH options for reliability
          SSH_OPTS="-i ~/.ssh/id_ed25519 -o StrictHostKeyChecking=no -o ConnectTimeout=30 -o ServerAliveInterval=30 -o ServerAliveCountMax=3 -o BatchMode=yes"

          # Copy files to server
          scp $SSH_OPTS /tmp/deploy.sh /tmp/deploy.env deploy@alpha.mintel.me:/tmp/
          
          # Execute deployment script on server with retry mechanism
          MAX_RETRIES=3
          RETRY_COUNT=0
          SUCCESS=false

          while [ $RETRY_COUNT -lt $MAX_RETRIES ]; do
            RETRY_COUNT=$((RETRY_COUNT + 1))
            echo "Deployment attempt $RETRY_COUNT of $MAX_RETRIES..."
            
            if ssh $SSH_OPTS deploy@alpha.mintel.me "bash /tmp/deploy.sh"; then
              echo "✓ Deployment successful!"
              SUCCESS=true
              break
            else
              echo "✗ Deployment attempt $RETRY_COUNT failed."
              if [ $RETRY_COUNT -lt $MAX_RETRIES ]; then
                echo "Retrying in 10 seconds..."
                sleep 10
              fi
            fi
          done

          if [ "$SUCCESS" = false ]; then
            echo "All deployment attempts failed."
            exit 1
          fi
          
          echo "Deployment completed"