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 -Deployments mithilfe der leistungsstarken CI/CD-Plattform von GitHub ab.

Voraussetzungen

Bevor Sie die GitHub Aktionen-Integration einrichten, stellen Sie sicher, dass Sie haben:

• Eine GitHub-Repository mit der Quelle Ihres Apps code
• Eine Capgo-Konto mit einer konfigurierten App
• Node.js und npm/yarn in Ihrem Projekt konfiguriert
• GitHub-Aktionen aktiviert für Ihr Repository

Einstellungen für GitHub-Geheimnisse

Schritt 1: Konfigurieren Sie Repository-Geheimnisse

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

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

Geheimer Name	Wert
CAPGO_TOKEN	Ihr Capgo API-Token

Hinweis

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

Einfache Produktionsbereitstellung

Beginnen Sie mit dieser grundlegenden Konfiguration, die auf jeden Push an die Hauptzweig in die Produktion bereitstellt:

# 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

Feature-Zweig-Bereitstellung

Feature-Zweige in temporären Kanälen für die Testung bereitstellen:

# 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

Verschlüsselung verwenden

If Sie __CAPGO_KEEP_0__’s Verschlüsselungsfunktion verwenden Capgo’s encryption featureNachdem

Sie die Verschlüsselungsschlüssel lokal eingerichtet haben fügen Sie Ihren privaten Schlüssel zu __CAPGO_KEEP_0__-Geheimnissen hinzu: locally, add your private key to GitHub secrets:

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

in Ihre __CAPGO_KEEP_0__-Repository-Geheimnisse ein, dann verwenden Sie es in Workflows: CAPGO_PRIVATE_KEY in your GitHub repository secrets, then use it 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:

• Kommitte das .capgo_key_v2 Datei nicht in die Versionskontrolle
• Speichere den privaten Schlüssel nur in einer sicheren CI/CD-Schlüsselverwaltung
• Verwende unterschiedliche Schlüssel für unterschiedliche Umgebungen

Multi-Channel-Konfiguration

Für umfassende Informationen zum Einrichten und Verwalten 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

Tip

Mit Kanälen testen: Nach dem Bereitstellen in einem PR- oder Entwicklungs-Kanal kannst du die Aktualisierung in deiner App testen, indem du sie auf diesen spezifischen Kanal einrichtest. Erfahre mehr über die Kanäle in deiner App einrichten.

Funktionalkanäle bereinigen

Automatisch Funktionalkanäle bereinigen, 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-Schutz-Regeln

Konfigurieren Sie Regeln zum Umgebungschutz in GitHub:

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

Sichere Geheimnisse-Verwaltung

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

Ü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

Benachrichtigungen an Discord senden:

- 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

Fügen Sie Schritte zum Debugging hinzu, um Probleme zu lösen:

- 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 fehlt 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 }}

Keine Build-Artikel 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 um verschiedene Bereitstellungsumgebungen zu verwalten
• Entdecken Benutzerdefinierte Speicherung für fortgeschrittene Bereitstellungsanforderungen
• Einrichten Verschlüsselung für sichere Bereitstellungen
• Konfigurieren Aktualisierungsverhalten um die Anwendung von Updates anzupassen

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.

Fortsetzen von GitHub Actions Integration

Wenn Sie CI/CD-Automatisierung verwenden GitHub Aktionen-Integration mit __CAPGO_KEEP_0__ CI/CD verbinden Capgo CI/CD für den Produktworkflow in Capgo CI/CD Capgo Native Builds für den Produktworkflow in Capgo Native Builds Capgo Integrations für den Produktworkflow in Capgo Integrations CI/CD-Integration für die Implementierungsdetails in CI/CD-Integration GitLab CI/CD-Integration für die Implementierungsdetails in der GitLab CI/CD-Integration.