Deployment mit KI: Automatisierte Bereitstellung & CI/CD¶

# .github/workflows/ci-cd.yml
name: CI/CD Pipeline

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

jobs:
  build-and-test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        node-version: [18.x, 20.x]

    steps:
    - uses: actions/checkout@v4

    - name: Use Node.js ${{ matrix.node-version }}
      uses: actions/setup-node@v4
      with:
        node-version: ${{ matrix.node-version }}
        cache: 'npm'

    - name: Install dependencies
      run: npm ci

    - name: Run ESLint
      run: npx eslint .

    - name: Run tests
      run: npm test

    - name: Build
      run: npm run build

    - name: Upload artifact
      uses: actions/upload-artifact@v3
      with:
        name: production-build
        path: dist/

# .github/workflows/ai-optimized.yml
name: KI-Optimierte CI/CD

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  # KI-gestützte Abhängigkeitsanalyse
  dependency-analysis:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4

    - name: Snyk Security Scan
      uses: snyk/actions/node@master
      with:
        args: --severity-threshold=high
      env:
        SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}

    - name: KI-gestützte Abhängigkeits-Optimierung
      uses: actionshq/actions-dependency-review-action@v1
      with:
        config-file: '.github/dependency-review.yml'

  # KI-gestützte Testauswahl
  smart-testing:
    needs: dependency-analysis
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4

    - name: Setup Node.js
      uses: actions/setup-node@v4
      with:
        node-version: 20

    - name: Install dependencies
      run: npm ci

    - name: KI-gestützte Testauswahl
      uses: microsoft/vsts-test-selector-action@v1
      with:
        test-runner: 'jest'
        test-command: 'npm test'

    - name: Run selected tests
      run: npm test

  # KI-gestützte Performance-Tests
  performance-testing:
    needs: smart-testing
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4

    - name: Setup Node.js
      uses: actions/setup-node@v4
      with:
        node-version: 20

    - name: Install dependencies
      run: npm ci

    - name: Run Lighthouse
      uses: treosh/lighthouse-ci-action@v11
      with:
        urls: |
          https://meine-website.de
        uploadArtifact: true
        temporaryPublicStorage: true

  # Deployment mit KI
  deploy:
    needs: performance-testing
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'

    steps:
    - uses: actions/checkout@v4

    - name: Download artifact
      uses: actions/download-artifact@v3
      with:
        name: production-build

    - name: KI-gestützte Deployment-Entscheidung
      id: deployment-decision
      run: |
        # KI prüft, ob Deployment sinnvoll ist
        # (z. B. basierend auf Test-Ergebnissen, Performance-Metriken)
        echo "deploy=$(node ./scripts/check-deployment.js)" >> $GITHUB_OUTPUT

    - name: Deploy to Production
      if: steps.deployment-decision.outputs.deploy == 'true'
      uses: actions-hub/gcloud@master
      with:
        args: gcloud app deploy --version=${{ github.sha }} --quiet
      env:
        GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}

# .gitlab-ci.yml
stages:
  - analyze
  - test
  - build
  - deploy

# KI-gestützte Code-Analyse
code_analysis:
  stage: analyze
  image: node:20
  script:
    - npm install
    - npm run lint
    - npm audit --audit-level=moderate
    - echo "Running KI-based code analysis..."
    # KI-Tool hier einfügen
  artifacts:
    paths:
      - reports/

# KI-gestützte Testauswahl
smart_tests:
  stage: test
  image: node:20
  script:
    - npm install
    # KI wählt nur geänderte/betroffene Tests aus
    - npm run test:smart
  needs: [code_analysis]

# Build
build:
  stage: build
  image: node:20
  script:
    - npm ci
    - npm run build
  artifacts:
    paths:
      - dist/
  needs: [smart_tests]

# KI-gestütztes Deployment
deploy_production:
  stage: deploy
  image: google/cloud-sdk:alpine
  script:
    # KI prüft Bereitstellungsbedingungen
    - if [ "$(node check-conditions.js)" = "true" ]; then
        gcloud app deploy --version=$CI_COMMIT_SHA --quiet
      else
        echo "Deployment conditions not met"
        exit 1
      fi
  environment:
    name: production
    url: https://meine-website.de
  only:
    - main
  needs: [build]

# .github/workflows/blue-green.yml
name: Blue-Green Deployment

on:
  push:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - run: npm ci && npm run build
    - uses: actions/upload-artifact@v3
      with:
        name: app-build
        path: dist/

  # Green-Umgebung vorbereiten
  prepare-green:
    needs: build
    runs-on: ubuntu-latest
    steps:
    - uses: actions/download-artifact@v3
      with:
        name: app-build

    - name: Deploy to Green
      run: |
        # Green-Umgebung deployen
        gcloud app deploy --version=green-${{ github.sha }} --no-promote

    - name: Gesundheitsprüfung
      id: health-check
      run: |
        # KI-gestützte Gesundheitsprüfung
        HEALTH_URL="https://green-${{ github.sha }}.uc.r.appspot.com/health"
        echo "Health check URL: $HEALTH_URL"

        # 10 Versuche mit 30s Pause
        for i in {1..10}; do
          if curl -s --head --request GET $HEALTH_URL | grep "200"; then
            echo "✅ Green-Umgebung ist gesund"
            echo "healthy=true" >> $GITHUB_OUTPUT
            break
          fi
          sleep 30
        done

        # Wenn nicht gesund, Rollback auslösen
        if [ "$healthy" != "true" ]; then
          echo "❌ Green-Umgebung ist nicht gesund"
          echo "healthy=false" >> $GITHUB_OUTPUT
          # Rollback auslösen
          gcloud app deploy --version=blue-${{ github.sha }} --promote
        fi

  # Verkehr umleiten (KI-gestützt)
  switch-traffic:
    needs: prepare-green
    if: needs.prepare-green.outputs.healthy == 'true'
    runs-on: ubuntu-latest
    steps:
    - name: KI-gestützte Entscheidung
      id: decision
      run: |
        # KI analysiert Metriken und entscheidet
        # 1. Performance der Green-Umgebung
        # 2. Fehlerrate
        # 3. Response-Zeiten
        # 4. Benutzer-Feedback

        # Vereinfachtes Beispiel
        GREEN_METRICS=$(curl -s https://monitoring.example.com/metrics/green-${{ github.sha }})

        # Prüfen, ob Green besser als Blue ist
        if [ "$(echo $GREEN_METRICS | jq '.error_rate')" -lt "$(curl -s https://monitoring.example.com/metrics/blue | jq '.error_rate')" ]; then
          echo "switch=true" >> $GITHUB_OUTPUT
        else
          echo "switch=false" >> $GITHUB_OUTPUT
        fi

    - name: Switch Traffic
      if: steps.decision.outputs.switch == 'true'
      run: |
        echo "✅ Umschalten auf Green-Umgebung"
        gcloud app services set-traffic --splits green-${{ github.sha }}=1.0
        # Alte Version löschen
        gcloud app versions delete blue-${{ github.sha }} --quiet
        # Neue Version als Blue markieren
        gcloud app deploy --version=blue-${{ github.sha }} --no-promote

# .github/workflows/canary.yml
name: Canary Deployment

on:
  push:
    branches: [ main ]

jobs:
  canary-deployment:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - run: npm ci && npm run build

    - name: Deploy Canary Version
      run: |
        # Canary-Version deployen (10% Verkehr)
        gcloud app deploy --version=canary-${{ github.sha }} --no-promote
        gcloud app services set-traffic --splits canary-${{ github.sha }}=0.1,stable=0.9

    - name: KI-gestütztes Monitoring
      id: monitoring
      run: |
        # 30 Minuten warten und Metriken sammeln
        sleep 1800

        # Metriken abrufen
        CANARY_METRICS=$(curl -s https://monitoring.example.com/metrics/canary-${{ github.sha }})
        STABLE_METRICS=$(curl -s https://monitoring.example.com/metrics/stable)

        # KI analysiert Metriken
        # 1. Fehlerrate vergleichen
        # 2. Performance vergleichen
        # 3. Benutzer-Feedback

        CANARY_ERROR_RATE=$(echo $CANARY_METRICS | jq '.error_rate')
        STABLE_ERROR_RATE=$(echo $STABLE_METRICS | jq '.error_rate')

        CANARY_LATENCY=$(echo $CANARY_METRICS | jq '.avg_latency')
        STABLE_LATENCY=$(echo $STABLE_METRICS | jq '.avg_latency')

        # Entscheidung treffen
        if [ "$(echo "$CANARY_ERROR_RATE < $STABLE_ERROR_RATE" | bc)" -eq 1 ] && \
           [ "$(echo "$CANARY_LATENCY < $STABLE_LATENCY" | bc)" -eq 1 ]; then
          echo "✅ Canary ist besser als Stable"
          echo "promote=true" >> $GITHUB_OUTPUT
        else
          echo "❌ Canary ist nicht besser als Stable"
          echo "promote=false" >> $GITHUB_OUTPUT
        fi

    - name: Promote Canary
      if: steps.monitoring.outputs.promote == 'true'
      run: |
        echo "✅ Canary wird zur neuen Stable-Version"
        # Verkehr vollständig umleiten
        gcloud app services set-traffic --splits canary-${{ github.sha }}=1.0
        # Alte Stable-Version löschen
        gcloud app versions delete stable --quiet
        # Canary als Stable markieren
        gcloud app deploy --version=stable --promote

    - name: Rollback Canary
      if: steps.monitoring.outputs.promote == 'false'
      run: |
        echo "❌ Canary wird zurückgesetzt"
        # Verkehr zurück zu Stable
        gcloud app services set-traffic --splits canary-${{ github.sha }}=0,stable=1.0
        # Canary-Version löschen
        gcloud app versions delete canary-${{ github.sha }} --quiet