GitHub Azioni di Integrazione

Integra le Capgo Aggiornamenti in tempo reale con GitHub Azioni per automatizzare i tuoi aggiornamenti dell'app ogni volta che puoi code modifiche. Questa guida copre la configurazione delle build automatizzate, dei test e dei flussi di lavoro di distribuzione utilizzando la potente piattaforma CI/CD di GitHub.

Requisiti

Prima di configurare l'integrazione GitHub Azioni, assicurati di avere:

• Un repository GitHub con il codice sorgente della tua app code
• Un account Capgo con un'app configurata
• Node.js e npm/yarn configurati nel tuo progetto
• GitHub Actions abilitati per il tuo repository

Configurazione dei segreti di GitHub

Passo 1: Configurazione dei segreti del repository

Configura i segreti necessari nel tuo repository GitHub:

1. Naviga nel tuo repository GitHub
2. Vai a Impostazioni → Segreti e variabili → Flussi di lavoro
3. Clicca Nuova chiave segreta repository e aggiungi il seguente:

Nome chiave segreta	Valore
CAPGO_TOKEN	La tua Capgo API chiave segreta

Consiglio

Ottieni la tua Capgo API chiave segreta da console.capgo.app/apikeys. La tua ID app è già configurata nel tuo capacitor.config.ts file.

Deployamento di Produzione semplice

Inizia con questa configurazione base che distribuisce in produzione con ogni push al ramo principale:

# 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 }}"

Configurazione avanzata di canali multipli

Deployamenti di ramo di feature

Distribuisci i ramo di feature in canali temporanei per le prove:

# 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

Utilizzo della crittografia

If stai utilizzando la funzione di crittografia di Capgo, dovrai memorizzare la tua chiave privata in modo sicuro nel tuo ambiente CI/CD.

Dopo aver configurato le chiavi di crittografia localmente, aggiungi la tua chiave privata ai segreti di GitHub:

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

Aggiungi questo contenuto come CAPGO_PRIVATE_KEY in segreti del tuo repository GitHub, quindi utilizzalo nelle workflow:

# 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

Attenzione

Pratiche di sicurezza migliori:

• Non commettere mai il .capgo_key_v2 file nel controllo delle versioni
• Memorizza la chiave privata solo nella gestione dei segreti di CI/CD sicura
• Utilizza chiavi diverse per ambienti diversi

Configurazione Multi-Canale

Per informazioni complete sulla configurazione e gestione di più canali di distribuzione, consulta la documentazione sui canali.

Flusso completo con sviluppo, richieste di pull e distribuzioni di produzione:

# 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

Consiglio

Testare con i canali: Dopo aver distribuito su una PR o un canale di sviluppo, puoi testare l'aggiornamento nell'applicazione configurandola per utilizzare quel canale specifico. Scopri di più su configurare i canali nell'applicazione.

Pulizia dei canali dei feature

Pulire automaticamente i canali dei feature quando vengono eliminate le branch:

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

Sicurezza e Pratiche Migliori

Regole di Protezione dell'ambiente

Configura le regole di protezione dell'ambiente in GitHub:

1. Vai a Impostazioni → Ambienti nel tuo repository
2. Crea ambienti: development, staging, production
3. Per l'ambiente di produzione, aggiungi:
   • Richiedi revisione: Aggiungi membri del team che devono approvare i deployment
   • Timer di attesa: Aggiungi un ritardo prima del deployment (facoltativo)
   • Ramo di distribuzione: Limita a main ramo solo

Gestione segreti sicura

Usa segreti specifici per ambiente:

# 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

Monitoraggio e Notifiche

Integrazione Slack

Aggiungi notifiche Slack al tuo workflow:

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

Integrazione Discord

Inviare notifiche a 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 }}

Notifiche via Email

Configura le notifiche via email:

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

Risoluzione dei Problemi

Flusso di Debug

Aggiungi passaggi di debug per risolvere i problemi:

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

Problemi comuni e soluzioni

Il flusso di lavoro fallisce con “CAPGO_TOKEN non trovato”:

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

Non trovati gli artefatti di costruzione:

- 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

Il problema di connettività di rete:

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

Flussi di lavoro riutilizzabili

Creare flussi di lavoro riciclabili per una maggiore coerenza tra i progetti:

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

Usa il flusso di lavoro riciclabile:

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

Passaggi successivi

• Scopri Canali Per gestire diversi ambienti di distribuzione
• Esegui una ricerca Storage personalizzato per scenari di distribuzione avanzati
• Configura Crittografia per distribuzioni sicure
• Configura Comportamento dell'aggiornamento per personalizzare come vengono applicate le aggiornamenti

Con l'integrazione di GitHub Actions, puoi sfruttare le potenti funzionalità di CI/CD di GitHub per creare workflow di distribuzione sofisticati con funzionalità di sicurezza, monitoraggio e collaborazione integrate per le tue Capgo Aggiornamenti in tempo reale.

Continua da qui dall'integrazione di GitHub Actions

If stai utilizzando GitHub Integrazione Actions per pianificare l'automazione del flusso di lavoro CI/CD, collega Capgo CI/CD per il flusso di lavoro del prodotto in Capgo CI/CD, Capgo Costruzioni native per il flusso di lavoro del prodotto in Capgo Costruzioni native, Capgo Integrazioni for the product workflow in Capgo Integrations, per il flusso di lavoro del prodotto in __CAPGO_KEEP_0__ Integrazioni, Integrazione CI/CD context: Pagina del prodotto Capgo Builder / costruzione cloud nativa. Ruolo: Etichetta di navigazione breve o elemento UI. Chiave di messaggio `native_build_feature_ci_cd` (Caratteristica di costruzione nativa Ci Cd). Integrazione CI/CD per i dettagli di implementazione, e Integrazione CI/CD GitLab per i dettagli di implementazione nella integrazione di GitLab CI/CD.