GitHub Aktionen-Integration

Integriere Capgo Live Updates mit GitHub Aktionen, um Ihre App-Updates automatisch zu deployen, sobald Sie code Änderungen pushen. Diese Anleitung deckt die Einrichtung von automatischen Builds, Tests und Bereitstellungsvorgängen mit GitHub’s leistungsstarker CI/CD-Plattform ab.

Voraussetzungen

Stellen Sie vor der Einrichtung der GitHub-Aktionen-Integration sicher, dass Sie Folgendes haben:

• A GitHub repository with your app’s source code
• Ein Capgo-Konto mit einer konfigurierten App
• Node.js und npm/yarn in Ihrem Projekt konfiguriert
• GitHub-Aktionen für Ihr Repository aktiviert

Einrichten von GitHub-Geheimnissen

Schritt 1: Konfigurieren von Repository-Geheimnissen

Stellen Sie die erforderlichen Geheimnisse in Ihrem GitHub-Repository ein:

1. Navigieren Sie zu Ihrem GitHub-Repository
2. Gehe zu Einstellungen → Geheimnisse und Variablen → Aktionen
3. Klicken Neuer Repository-Schlüssel und fügen Sie folgendes hinzu:

Geheimnisname	Wert
CAPGO_TOKEN	Ihr Capgo API-Token

Tipp

Holen Sie sich Ihr Capgo API-Token von console.capgo.app/apikeysIhre App-ID ist bereits in Ihrem capacitor.config.ts Datei.

Einfache Produktionsbereitstellung

Mit dieser grundlegenden Konfiguration wird auf jeden Push in die Hauptzweig in die Produktion bereitgestellt:

# Simple GitHub Actions Workflow for Capgo Live Updates
name: Deploy to Capgo

on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v6

      - name: Setup Node.js
        uses: actions/setup-node@v6
        with:
          node-version: '24'
          cache: 'npm'

      - name: Install, test and build
        run: |
          npm ci
          npm run test
          npm run build

      - name: Deploy to Capgo
         run: |
           npm install -g @capgo/cli
           npx @capgo/cli bundle upload --channel production
          env:
            CAPGO_TOKEN: ${{ secrets.CAPGO_TOKEN }}
           # For encrypted uploads, add: --key-data-v2 "${{ secrets.CAPGO_PRIVATE_KEY }}"

Erweiterte Mehrkanal-Konfiguration

Funktionszweig-Bereitstellung

Bereitstellen Sie Funktionszweige in temporären Kanälen für die Testung:

# Feature branch deployment
name: Deploy Feature Branch to Capgo

on:
  push:
    branches:
      - 'feature/**'

jobs:
  deploy-feature:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      - uses: actions/setup-node@v6
        with:
          node-version: '24'
          cache: 'npm'

      - run: |
          npm ci
          npm run test
          npm run build

      - name: Deploy to feature channel
        run: |
          CHANNEL_NAME=$(echo "${{ github.ref_name }}" | sed 's/[^a-zA-Z0-9]/-/g' | tr '[:upper:]' '[:lower:]')
          npm install -g @capgo/cli
          npx @capgo/cli channel create $CHANNEL_NAME --apikey ${{ secrets.CAPGO_TOKEN }} || true
                     npx @capgo/cli bundle upload --apikey ${{ secrets.CAPGO_TOKEN }} --channel $CHANNEL_NAME

Mit Verschlüsselung

Wenn Sie Capgo's Verschlüsselungsfunktion verwenden, müssen Sie Ihren privaten Schlüssel sicher in Ihrem CI/CD-Umgebung speichern.

Nachdem Sie die Verschlüsselungsschlüssel lokal eingerichtet haben fügen Sie Ihren privaten Schlüssel zu GitHub-Geheimnissen hinzu:

# Display your private key content (copy this output)
cat .capgo_key_v2

Fügen Sie diesen Inhalt hinzu: CAPGO_PRIVATE_KEY In Ihrem GitHub-Repository-Schlüssel, dann verwenden Sie es in Workflows:

# Deploy with encryption
- name: Deploy to Capgo with Encryption
  run: |
    npm install -g @capgo/cli
    npx @capgo/cli bundle upload --apikey ${{ secrets.CAPGO_TOKEN }} --key-data-v2 "${{ secrets.CAPGO_PRIVATE_KEY }}" --channel production

Achtung

Security Best Practices:

• Nie den .capgo_key_v2 Datei in die Versionskontrolle committen
• Speichern Sie den privaten Schlüssel nur in sicheren CI/CD-Schlüsselmanagement
• Verwenden Sie unterschiedliche Schlüssel für unterschiedliche Umgebungen

Multi-Channel-Konfiguration

Für umfassende Informationen zum Einrichten und Verwalten mehrerer Bereitstellungskanäle, sehen Sie sich die Kanäle-Dokumentation.

Erfassen Sie den gesamten Workflow mit Entwicklung, Pull-Anforderungen und Produktionsbereitstellungen:

# Complete multi-environment workflow
name: Deploy to Capgo

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

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      - uses: actions/setup-node@v6
        with:
          node-version: '24'
          cache: 'npm'

      - run: |
          npm ci
          npm run test
          npm run build

      - uses: actions/upload-artifact@v6
        with:
          name: dist
          path: dist/

  deploy-development:
    if: github.ref == 'refs/heads/develop'
    needs: build
    runs-on: ubuntu-latest
    environment: development
    steps:
      - uses: actions/setup-node@v6
        with:
          node-version: '24'

      - uses: actions/download-artifact@v4
        with:
          name: dist
          path: dist/

      - run: |
          npm install -g @capgo/cli
          npx @capgo/cli bundle upload --apikey ${{ secrets.CAPGO_TOKEN }} --channel development

  deploy-pr:
    if: github.event_name == 'pull_request'
    needs: build
    runs-on: ubuntu-latest
    steps:
      - uses: actions/setup-node@v6
        with:
          node-version: '24'

      - uses: actions/download-artifact@v4
        with:
          name: dist
          path: dist/

      - name: Deploy to PR channel
        run: |
          CHANNEL_NAME="pr-${{ github.event.number }}"
          npm install -g @capgo/cli
          npx @capgo/cli channel create $CHANNEL_NAME --apikey ${{ secrets.CAPGO_TOKEN }} || true
          npx @capgo/cli bundle upload --apikey ${{ secrets.CAPGO_TOKEN }} --channel $CHANNEL_NAME

      - name: Comment PR
        uses: actions/github-script@v7
        with:
          script: |
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: `🚀 This PR has been deployed to Capgo channel: \`pr-${{ github.event.number }}\`\n\nTo test this update in your app, configure it to use this channel. [Learn how to configure channels →](/docs/live-updates/channels/#configuring-the-channel-in-your-app)`
            })

  deploy-production:
    if: github.ref == 'refs/heads/main'
    needs: build
    runs-on: ubuntu-latest
    environment: production
    steps:
      - uses: actions/setup-node@v6
        with:
          node-version: '24'

      - uses: actions/download-artifact@v4
        with:
          name: dist
          path: dist/

      - run: |
          npm install -g @capgo/cli
          npx @capgo/cli bundle upload --apikey ${{ secrets.CAPGO_TOKEN }} --channel production

Tipp

Testen mit Kanälen: Nach der Bereitstellung in einem PR- oder Entwicklungs-Kanal können Sie die Aktualisierung in Ihrer App testen, indem Sie sie auf diesen spezifischen Kanal konfigurieren. Erfahren Sie mehr über die Konfiguration von Kanälen in Ihrer App Feature-Kanäle bereinigen.

Abschnitt mit dem Titel “Feature-Kanäle bereinigen”

Zwischenablage kopieren

name: Cleanup Feature Channels

on:
  delete:

jobs:
  cleanup:
    runs-on: ubuntu-latest
    if: github.event.ref_type == 'branch' && startsWith(github.event.ref, 'feature/')
    steps:
      - uses: actions/setup-node@v6
        with:
          node-version: '24'

      - name: Delete Capgo channel
        run: |
          CHANNEL_NAME=$(echo "${{ github.event.ref }}" | sed 's/[^a-zA-Z0-9]/-/g' | tr '[:upper:]' '[:lower:]')
          npm install -g @capgo/cli
          npx @capgo/cli channel delete $CHANNEL_NAME --apikey ${{ secrets.CAPGO_TOKEN }} || true

Sicherheit und Best Practices

Schutzregeln für die Umgebung

Stellen Sie Schutzregeln für die Umgebung in GitHub ein:

1. Gehe zu Einstellungen → Umgebungen in Ihrem Repository
2. Erstellen Sie Umgebungen: development, staging, production
3. Für die Produktionsumgebung fügen Sie hinzu:
   • Berechtigte Rezensenten erforderlich: Hinzufügen Sie Teammitglieder, die die Bereitstellung genehmigen müssen
   • Wartezeit: Hinzufügen Sie eine Verzögerung vor der Bereitstellung (optional)
   • Bereitstellungszweige: Einschränken Sie auf main Zweig nur

Secure Secrets Management

Verwenden Sie umgebungsspezifische Geheimnisse:

# Use different secrets per environment
deploy-production:
  environment: production
  steps:
    - name: Deploy to Production
      run: |
        npx @capgo/cli bundle upload \
          --apikey ${{ secrets.CAPGO_PROD_TOKEN }} \
          --app ${{ secrets.CAPGO_PROD_APP_ID }} \
          --channel production

Monitoring and Notifications

Slack-Integration

Fügen Sie Slack-Benachrichtigungen Ihrem Workflow hinzu:

name: Deploy with Notifications

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      # ... deployment steps

      - name: Notify Slack on Success
        if: success()
        uses: 8398a7/action-slack@v3
        with:
          status: success
          text: '✅ Capgo deployment successful!'
          fields: repo,message,commit,author,action,eventName,ref,workflow
        env:
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}

      - name: Notify Slack on Failure
        if: failure()
        uses: 8398a7/action-slack@v3
        with:
          status: failure
          text: '❌ Capgo deployment failed!'
          fields: repo,message,commit,author,action,eventName,ref,workflow
        env:
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}

Discord-Integration

Senden Sie Benachrichtigungen an Discord:

- name: Discord notification
  if: always()
  uses: Ilshidur/action-discord@master
  with:
    args: |
      Capgo deployment ${{ job.status }}!
      App: ${{ secrets.CAPGO_APP_ID }}
      Channel: ${{ github.ref_name }}
      Commit: ${{ github.sha }}
  env:
    DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }}

E-Mail-Benachrichtigungen

Konfigurieren Sie E-Mail-Benachrichtigungen:

- name: Send email notification
  if: failure()
  uses: dawidd6/action-send-mail@v3
  with:
    server_address: smtp.gmail.com
    server_port: 465
    username: ${{ secrets.EMAIL_USERNAME }}
    password: ${{ secrets.EMAIL_PASSWORD }}
    subject: 'Capgo Deployment Failed - ${{ github.repository }}'
    to: team@yourcompany.com
    from: ci-cd@yourcompany.com
    body: |
      Deployment failed for ${{ github.repository }}
      Branch: ${{ github.ref_name }}
      Commit: ${{ github.sha }}
      Workflow: ${{ github.workflow }}

Fehlersuche

Debug-Workflow

Schritte zur Fehlersuche hinzufügen:

- name: Debug environment
  run: |
    echo "Node version: $(node --version)"
    echo "NPM version: $(npm --version)"
    echo "Working directory: $(pwd)"
    echo "Files in dist/: $(ls -la dist/ || echo 'No dist directory')"
    echo "Environment variables:"
    env | grep -E "(GITHUB_|CAPGO_)" | sort

- name: Test Capgo CLI
  run: |
    npx @capgo/cli --version
    npx @capgo/cli app debug --apikey ${{ secrets.CAPGO_TOKEN }} --app ${{ secrets.CAPGO_APP_ID }}

Häufige Probleme und Lösungen

Workflow fehlschlägt mit „CAPGO_TOKEN nicht gefunden“:

- name: Verify secrets
  run: |
    if [ -z "${{ secrets.CAPGO_TOKEN }}" ]; then
      echo "ERROR: CAPGO_TOKEN secret is not set"
      exit 1
    fi
    echo "CAPGO_TOKEN is set (length: ${#CAPGO_TOKEN})"
  env:
    CAPGO_TOKEN: ${{ secrets.CAPGO_TOKEN }}

Build-Artikel nicht gefunden:

- name: Debug artifacts
  run: |
    echo "Checking for build artifacts..."
    ls -la dist/ || echo "No dist directory found"
    find . -name "*.js" -o -name "*.html" | head -10

Netzwerkverbindungsprobleme:

- name: Test connectivity
  run: |
    ping -c 3 api.capgo.io || echo "Ping failed"
    curl -I https://api.capgo.io/health || echo "Health check failed"

Wiederverwendbare Workflows

Erstellen Sie wiederverwendbare Workflows für Konsistenz über Projekte hinweg:

.github/workflows/reusable-capgo-deploy.yml

name: Reusable Capgo Deploy

on:
  workflow_call:
    inputs:
      environment:
        required: true
        type: string
      channel:
        required: true
        type: string
    secrets:
      CAPGO_TOKEN:
        required: true
      CAPGO_APP_ID:
        required: true

jobs:
  deploy:
    runs-on: ubuntu-latest
    environment: ${{ inputs.environment }}
    steps:
      - uses: actions/checkout@v6

      - name: Setup Node.js
        uses: actions/setup-node@v6
        with:
          node-version: '24'
          cache: 'npm'

      - name: Install and build
        run: |
          npm ci
          npm run build

      - name: Deploy to Capgo
        run: |
          npm install -g @capgo/cli
          npx @capgo/cli bundle upload \
            --apikey ${{ secrets.CAPGO_TOKEN }} \
            --app ${{ secrets.CAPGO_APP_ID }} \
            --channel ${{ inputs.channel }}

Verwenden Sie den wiederverwendbaren Workflow:

.github/workflows/deploy.yml

name: Deploy App

on:
  push:
    branches: [main, develop]

jobs:
  deploy-dev:
    if: github.ref == 'refs/heads/develop'
    uses: ./.github/workflows/reusable-capgo-deploy.yml
    with:
      environment: development
      channel: development
    secrets:
      CAPGO_TOKEN: ${{ secrets.CAPGO_TOKEN }}
      CAPGO_APP_ID: ${{ secrets.CAPGO_APP_ID }}

  deploy-prod:
    if: github.ref == 'refs/heads/main'
    uses: ./.github/workflows/reusable-capgo-deploy.yml
    with:
      environment: production
      channel: production
    secrets:
      CAPGO_TOKEN: ${{ secrets.CAPGO_TOKEN }}
      CAPGO_APP_ID: ${{ secrets.CAPGO_APP_ID }}

Nächste Schritte

• Erhalten Sie Informationen über Kanäle um verschiedene Bereitstellungsumgebungen zu verwalten
• Entdecken Sie Benutzerdefinierte Speicherung zur Unterstützung von fortgeschrittenen Bereitstellungs-Szenarien
• Einstellen Sie Verschlüsselung zur Sicherstellung von Bereitstellungen
• Konfigurieren Sie Update-Verhalten um die Anwendung von Updates anzuordnen

Mit der GitHub-Actions-Integration können Sie die leistungsstarke CI/CD-Plattform von GitHub nutzen, um komplexe Bereitstellungsworkflows mit integrierten Sicherheits-, Überwachungs- und Collaboration-Funktionen für Ihre Capgo-Live-Updates zu erstellen.

Weitermachen Sie mit der GitHub-Actions-Integration

Wenn Sie __CAPGO_KEEP_0__-Actions-Integration verwenden GitHub-Actions-Integration um die CI/CD-Automatisierung zu planen, verbinden Sie es mit Capgo-CI/CD für das Produktworkflow in Capgo-CI/CD Capgo-Native-Builds für das Produktworkflow in Capgo-Native-Builds Capgo-Integrations für das Produktworkflow in Capgo-Integrations CI/CD Integration für die Implementierungsdetails in der CI/CD Integration, und GitLab CI/CD Integration für die Implementierungsdetails in der GitLab CI/CD Integration.