Intégrations GitHub d'Actions

Intégrez les mises à jour en temps réel de Capgo avec les GitHub Actions pour déployer automatiquement vos mises à jour d'application chaque fois que vous poussez des code modifications. Ce guide couvre la mise en place de builds automatisés, de tests et de flux de déploiement en utilisant la plateforme CI/CD puissante de GitHub.

Prérequis

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

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

Paramétrage des secrets GitHub

Étape 1 : Configuration des secrets du dépôt

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

1. Naviguez vers votre dépôt GitHub
2. Allez à Paramètres → Secrets et variables → Actions
3. Cliquez Nouveau secret de répertoire Ajoutez les éléments suivants :

Nom du secret	Valeur
CAPGO_TOKEN	Votre jeton Capgo API

Conseil

Obtenez votre jeton Capgo API à partir de console.capgo.app/apikeys. Votre ID d'application est déjà configuré dans votre capacitor.config.ts fichier.

Déploiement de Production Simple

Commencez par cette configuration de base qui déploie en production à chaque push vers la branche 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 }}"

Configuration Avancée Multi-Canal

Déploiements de Branches de Fonctionnalité

Déployez les branches de fonctionnalité dans 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 create $CHANNEL_NAME --apikey ${{ secrets.CAPGO_TOKEN }} || true
                     npx @capgo/cli bundle upload --apikey ${{ secrets.CAPGO_TOKEN }} --channel $CHANNEL_NAME

Utilisation de l'Encryption

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

Après la mise en place des clés d'encryption locale, ajoutez votre clé privée aux secrets de GitHub :

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

Ajoutez ce contenu sous la forme de 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

Meilleures pratiques de sécurité :

• N'ajoutez jamais le .capgo_key_v2 fichier à la gestion de version
• Stockez la clé privée uniquement dans une gestion sécurisée de secrets de CI/CD
• Utilisez des clés différentes pour différents environnements

Configuration de plusieurs canaux

Pour obtenir des informations complètes sur la mise en place et la gestion de plusieurs canaux de déploiement, consultez la documentation des canaux.

Flux complet avec développement, demandes de tirage et déploiements de 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 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

Conseil

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

Nettoyage des canaux de fonctionnalités

Nettoyer 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 Meilleures Pratiques

Règles de protection de l'environnement

Configurez les règles de protection de l'environnement dans GitHub :

1. Allez à Paramètres → Environnements dans votre dépôt
2. Créez des environnements : development, staging, production
3. Pour l'environnement de production, ajoutez :
   • Reviens obligatoires: Ajoutez des membres d'équipe qui doivent approuver les déploiements
   • Délai d'attente: Ajoutez un délai avant le déploiement (facultatif)
   • Branches de déploiement: Restrict to main seulement sur la branch

Gestion sécurisée des secrets

Utilisez des secrets spécifiques à l'environnement :

# 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

Surveillance 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

Envoyer des notifications à 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 courriel

Configurer les notifications par courriel :

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

Résolution des problèmes

Débogage du 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 flux de travail échoue avec « CAPGO_TOKEN non trouvé » :

- 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 construction non trouvés :

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

Flux de travail réutilisable

Créez des flux réutilisables pour une cohérence dans les projets :

github/flux/reutilisables-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 flux réutilisable :

github/flux/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 Titre de la section « Canaux » (nom de la fonctionnalité de gestion de canaux de mise à jour de Capgo). Page/zone : page de marketing de solutions de Capgo. Rôle : étiquette de navigation ou élément de menu court. Voir dans : page solutions/white-label.astro. Message clé `solutions_white_label_visual_cell2_value` (Valeur de la cellule visuelle de l'étiquette blanche de solutions).
• Découvrez Stockage personnalisé pour des scénarios de déploiement avancés
• Configurer Chiffrement pour des déploiements sécurisés
• Configurer Comportement de mise à jour pour personnaliser la façon dont les mises à jour sont appliquées

Avec l'intégration d'actions GitHub, vous pouvez tirer parti de la plateforme CI/CD puissante de GitHub pour créer des workflows de déploiement sophistiqués avec des fonctionnalités de sécurité, de surveillance et de collaboration intégrées pour vos mises à jour Live de Capgo.

Continuez d'ici l'intégration d'actions GitHub

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