Intégration GitHub Actions

Intégrez Capgo Live Updates avec GitHub Actions pour déployer automatiquement les mises à jour de votre app dès que vous pushez des code changements. Ce guide couvre la configuration des builds automatisés, des tests et des workflows de déploiement via la puissante plateforme CI/CD de GitHub.

Prerequisites

Avant de configurer l'intégration GitHub Actions, assurez-vous d'avoir :

• Un dépôt GitHub contenant le code source code de votre app
• Un compte Capgo avec une app configurée
• Node.js et npm/yarn configurés dans votre projet
• GitHub Actions activé pour votre dépôt

Configuration des secrets GitHub

Étape 1 : Configurer les secrets du dépôt

Configurez les secrets nécessaires dans votre dépôt GitHub :

1. Accédez à votre dépôt GitHub
2. Allez dans Paramètres → Secrets et variables → Actions
3. Cliquez sur Nouveau secret de repository et ajoutez les éléments suivants :

Nom du secret	Valeur
CAPGO_TOKEN	Votre token Capgo API

Astuce

Récupérez votre token Capgo API sur console.capgo.app/apikeys. Votre app ID est déjà configuré dans votre capacitor.config.ts fichier.

Déploiement simple en production

Commencez par cette configuration de base qui déploie en production à chaque push sur la branche main :

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

Configuration multi-canaux avancée

Déploiements de branches feature

Déployez des branches feature sur des canaux temporaires pour les tests :

# 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 add $CHANNEL_NAME --apikey ${{ secrets.CAPGO_TOKEN }} || true
                     npx @capgo/cli bundle upload --apikey ${{ secrets.CAPGO_TOKEN }} --channel $CHANNEL_NAME

Utilisation du chiffrement

Si vous utilisez la fonctionnalité de chiffrement de Capgo, vous devrez stocker votre clé privée de manière sécurisée dans votre environnement CI/CD.

Après la configuration des clés de chiffrement localement, ajoutez votre clé privée aux secrets GitHub :

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

Ajoutez ce contenu en tant que CAPGO_PRIVATE_KEY dans les secrets de votre repository GitHub, puis utilisez-le dans vos 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

Attention

Bonnes pratiques de sécurité :

• Ne commitez jamais le .capgo_key_v2 fichier dans le gestionnaire de versions
• Stockez la clé privée uniquement dans un gestionnaire de secrets CI/CD sécurisé
• Utilisez des clés différentes pour chaque environnement

Configuration multi-canaux

Pour plus d'informations sur la configuration et la gestion de plusieurs canaux de déploiement, consultez la documentation des canaux.

Workflow complet avec développement, pull requests et déploiements en production :

# 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 add $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

Astuce

Tester avec les canaux: Après avoir déployé sur un canal de PR ou de développement, vous pouvez tester la mise à jour dans votre application en la configurant pour utiliser ce canal spécifique. En savoir plus sur la configuration des canaux dans votre application.

Nettoyage des canaux de fonctionnalités

Nettoyez automatiquement les canaux de fonctionnalités lorsque les branches sont supprimées :

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

Sécurité et bonnes pratiques

Règles de protection des environnements

Configurez les règles de protection des environnements dans GitHub :

1. Accéder à Paramètres → Environnements dans votre dépôt
2. Créer des environnements : development, staging, production
3. Pour l'environnement de production, ajoutez :
   • Reviewers requisAjouter des membres de l'équipe devant approuver les déploiements
   • Délai d'attente: Ajoutez un délai avant le déploiement (optionnel)
   • Branches de déploiement: Restreindre à main branch only

Gestion sécurisée des secrets

Use environment-specific secrets:

# 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 et notifications

Intégration Slack

Ajoutez des notifications Slack à votre 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 }}

Intégration Discord

Envoyez des notifications sur 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 }}

Notifications par e-mail

Configurez les notifications par e-mail :

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

Troubleshooting

Déboguer le workflow

Ajoutez des étapes de débogage pour résoudre les problèmes :

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

Problèmes courants et solutions

Le workflow échoue avec l'erreur « CAPGO_TOKEN not found » :

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

Les artefacts de build sont introuvables :

- 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

Problèmes de connectivité réseau :

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

Workflows réutilisables

Créez des workflows réutilisables pour garder vos projets cohérents :

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

Utilisez le workflow réutilisable :

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

Étapes suivantes

• En savoir plus sur Canaux pour gérer différents environnements de déploiement
• Explorer Stockage personnalisé pour des scénarios de déploiement avancés
• Configuration Chiffrement pour des déploiements sécurisés
• Configurer Comportement de mise à jour pour personnaliser l'application des mises à jour

Avec l'intégration GitHub Actions, profitez de la puissante plateforme CI/CD de GitHub pour créer des workflows de déploiement sophistiqués avec sécurité, monitoring et collaboration intégrés pour vos Capgo Live Updates.

Continuer après l'intégration GitHub Actions

Si vous utilisez Intégration GitHub Actions pour planifier l'automatisation CI/CD, connectez-l’à Capgo CI/CD pour le workflow produit dans Capgo CI/CD, Capgo Native Builds pour le workflow produit dans Capgo Native Builds, Intégrations Capgo pour le workflow produit dans les intégrations Capgo, Intégration CI/CD pour les détails d'implémentation de l'intégration CI/CD, et Intégration GitLab CI/CD pour les détails d'implémentation de l'intégration GitLab CI/CD.