GitHub Integración de Acciones

Integra Capgo Actualizaciones en vivo con GitHub Acciones para que se desplieguen automáticamente las actualizaciones de tu aplicación cada vez que envíes code cambios. Esta guía cubre la configuración de compilaciones automatizadas, pruebas y flujos de trabajo de despliegue utilizando la plataforma de CI/CD poderosa de GitHub.

Requisitos previos

Antes de configurar la integración de GitHub Acciones, asegúrate de tener:

• Un repositorio GitHub con el código fuente de tu aplicación code
• Una cuenta Capgo con una aplicación configurada
• Node.js y npm/yarn configurados en tu proyecto
• GitHub Actions habilitados para tu repositorio

Configuración de GitHub Secrets

Paso 1: Configura secretos de repositorio

Configura los secretos necesarios en tu GitHub repositorio:

1. Navega a tu GitHub repositorio
2. Ir a Configuración → Secretos y variables → Actions
3. Haz clic Nueva clave de repositorio secreta y agrega lo siguiente:

Nombre de la clave secreta	Valor
CAPGO_TOKEN	Tu Capgo API token

Consejo

Obtén tu Capgo API token desde console.capgo.app/apikeys. Tu ID de aplicación ya está configurado en tu capacitor.config.ts archivo.

Implementación de Producción Simple

Comience con esta configuración básica que despliega a producción en cada empuje a la rama principal:

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

Configuración Avanzada de Múltiples Canales

Implementaciones de Rama de Características

Despliegue de rama de características a canales temporales para pruebas:

# 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

Uso de la Cifrado

Si estás utilizando Capgo's característica de cifrado, necesitarás almacenar tu clave privada de manera segura en tu entorno de CI/CD.

Después de configurar las claves de cifrado localmente, agrega tu clave privada a los secretos de GitHub:

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

Agrega este contenido como CAPGO_PRIVATE_KEY en los secretos de GitHub de tu repositorio, luego úsalo en flujos de trabajo:

# 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

Cuidado

Prácticas de seguridad:

• Nunca comitas el .capgo_key_v2 archivo a control de versiones
• Almacena la clave privada solo en la gestión de secretos de CI/CD segura
• Utiliza claves diferentes para diferentes entornos

Configuración de múltiples canales

Para obtener información completa sobre la configuración y gestión de múltiples canales de despliegue, consulte la documentación de canales.

Flujo completo de desarrollo, solicitudes de extracción y despliegues de producción:

# 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

Consejo

Prueba con canales: Después de desplegar a una PR o canal de desarrollo, puedes probar la actualización en tu aplicación configurándola para utilizar ese canal específico. Aprende más sobre configurando canales en tu aplicación.

Eliminar características de los canales

Automáticamente elimina los canales de características cuando se eliminan ramas:

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

Seguridad y mejores prácticas

Reglas de protección del entorno

Configura reglas de protección del entorno en GitHub:

1. Ir a Configuración → Entornos en tu repositorio
2. Crear entornos: development, staging, production
3. Para el entorno de producción, agrega:
   • Revisores requeridos: Agrega miembros del equipo que deben aprobar los despliegues
   • : Agrega un retraso antes del despliegue (opcional)Reglas de protección del entorno
   • Ramas de despliegue: Restringir a main solo rama

Gestión de secretos seguros

Utilice secretos específicos del entorno:

# 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

Monitoreo y Notificaciones

Integración de Slack

Agregar notificaciones de Slack a tu flujo de trabajo:

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

Integración de Discord

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

Notificaciones por correo electrónico

Configurar notificaciones por correo electrónico:

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

Solución de problemas

Flujo de trabajo de depuración

Agregar pasos de depuración para resolver problemas:

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

Problemas comunes y soluciones

El flujo de trabajo falla con “CAPGO_TOKEN no encontrado”:

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

No se encontraron artefactos de compilación:

- 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

Problemas de conectividad de red:

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

Flujos de trabajo reutilizables

Crear flujos de trabajo reutilizables para la consistencia en proyectos:

github/flujos-de-trabajo/reutilizable-capgo-despliegue.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 }}

Usar el flujo de trabajo reutilizable:

github/flujos-de-trabajo/despliegue.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 }}

Pasos siguientes

• Aprender sobre Canales Para gestionar diferentes entornos de despliegue
• Explora Almacenamiento personalizado para escenarios de despliegue avanzados
• Configura Cifrado para despliegues seguros
• Configura Comportamiento de actualización para personalizar cómo se aplican las actualizaciones

Con la integración de GitHub Actions, puede aprovechar el poderoso plataforma de CI/CD de GitHub para crear flujos de trabajo de despliegue sofisticados con características de seguridad, monitoreo y colaboración integradas para sus Capgo Live Updates.

Sigue adelante desde la integración de GitHub Actions

If you are using GitHub Acciones de Integración para planificar la automatización de CI/CD, conecta con Capgo CI/CD para el flujo de trabajo del producto en Capgo CI/CD, Capgo Compilaciones Nativas para el flujo de trabajo del producto en Capgo Compilaciones Nativas, Capgo Integraciones para el flujo de trabajo del producto en Capgo Integraciones, Integración de CI/CD para el detalle de implementación en Integración de CI/CD, y Integración de CI/CD de GitLab para los detalles de implementación en la integración de GitLab CI/CD.