GitHub Aktionen-Integration

Integriere Capgo Live Updates mit GitHub Aktionen, um deine App-Updates automatisch zu deployen, sobald du code Änderungen pushst. Diese Anleitung deckt die Einrichtung von automatischen Builds, Tests und Bereitstellungsworkflows mit GitHub’s leistungsstarker CI/CD-Plattform ab.

Voraussetzungen

Bevor du die GitHub Actions-Integration einrichtest, stelle sicher, dass du hast:

• A GitHub repository with your app’s source code
• Einen Capgo-Account mit einer konfigurierten App
• Node.js und npm/yarn in deinem Projekt konfiguriert
• GitHub Actions für dein Repository aktiviert

Einstellungen für GitHub Geheimnisse

Schritt 1: Repository-Geheimnisse konfigurieren

Konfigurieren Sie die erforderlichen Geheimnisse in Ihrem GitHub-Repository:

1. Navigieren Sie zu Ihrem GitHub-Repository
2. Zum Einstellungen → Geheimnisse und Variablen → Aktionen
3. Klicken Sie Neues Repository-Geheimnis und fügen Sie folgendes hinzu:

Geheimnisname	Wert
CAPGO_TOKEN	Ihr Capgo-API-Token

Tip

Erhalte Ihren Capgo API-Token von console.capgo.app/apikeysIhr App-ID ist bereits in Ihrem capacitor.config.ts Datei.

Einfache Produktionsbereitstellung

Beginnen Sie mit dieser grundlegenden Konfiguration, die auf jede Push-Operation auf der Hauptzweig in die Produktion deployt:

# 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 Multi-Kanal-Konfiguration

Feature Branch Deployments

Deployen Sie Feature Branches in temporäre Kanäle 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 die Verschlüsselungsfunktion von __CAPGO_KEEP_0__ verwenden Capgo’s encryption featureNachdem Sie die Verschlüsselungsschlüssel lokal eingerichtet haben, fügen Sie Ihren privaten Schlüssel den __CAPGO_KEEP_0__-Geheimnissen hinzu:

Wenn Sie die Verschlüsselungsfunktion von __CAPGO_KEEP_0__ 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 den GitHub-Geheimnissen hinzu:

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

Fügen Sie diesen Inhalt als CAPGO_PRIVATE_KEY in Ihrem GitHub-Repository-Schlüssel, dann verwenden Sie ihn 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

Vorsicht

Sicherheitsbest Practices:

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

Multi-Channel-Konfiguration

Für umfassende Informationen zur Einrichtung und Verwaltung mehrerer Bereitstellungskanäle, siehe die Dokumentation zu den Kanälen.

Vollständiger 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

Tipps

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.

Funktion zur Bereinigung von Feature-Kanälen

Automatisch bereinigen Sie Funktionenkanäle, wenn Zweige gelöscht werden:

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

Umgebungs-Schutzregeln

Konfigurieren Sie Umgebungs-Schutzregeln in GitHub:

1. Zu Einstellungen → Umgebungen in Ihrem Repository
2. Umgebungen erstellen: development, staging, production
3. Für die Produktionsumgebung fügen Sie hinzu:
   • Erforderliche Rezensionen: Fügen Sie Teammitglieder hinzu, die die Bereitstellung genehmigen müssen
   • Wartezeit: Fügen Sie eine Verzögerung vor der Bereitstellung hinzu (optional)
   • Bereitstellungsbranchen: Beschränken Sie sich auf main Branch nur

Sichere Geheimnisse verwalten

Verwenden Sie umgebungsabhängige 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

Überwachung und Benachrichtigungen

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

E-Mail-Benachrichtigungen konfigurieren:

- 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

Fehlerbehebungs-Schritte zum Auflösen von Problemen 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

Der 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 zwischen Projekten:

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

• Erfahren Sie mehr über Kanäle zur Verwaltung verschiedener Bereitstellungsumgebungen
• Erkunden Sie Benutzerdefinierte Speicherung für fortgeschrittene Bereitstellungsszenarien
• Konfigurieren Sie Verschlüsselung für sichere Bereitstellungen
• Konfigurieren Aktualisierungsverhalten anpassen um zu bestimmen, wie Aktualisierungen angewendet werden

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