Construction automatique de l'application Android Capacitor avec les actions GitHub

La configuration de la CI/CD pour les applications Capacitor peut être complexe et chronophage. Voici ce que vous devez savoir :

Recommandé pour les nouvelles constructions : Utilisez la construction Capgo

Nous recommandons désormais l'utilisation de la construction Capgo avec le Capgo CLI For les builds natifs Capacitor. Cette guide Fastlane est conservée pour les équipes qui maintiennent des pipelines d'actions GitHub existants, mais les nouvelles builds Android doivent utiliser le Capgo CLI afin que vous ne deviez pas maintenir Fastlane, les exécutants Gradle, les clés de stockage et les scripts d'envoi vous-même.

Prérequis

Avant de commencer, vous aurez besoin de configurer :

• Un compte GitHub avec accès administrateur
• Votre application déjà publiée sur Google Play Store avec une signature appropriée
• Clé de signature Android et fichiers de clés de stockage
• Projet Google Cloud Console avec le API Play Store activé
• Compte de service avec les permissions appropriées
• Compréhension des workflows d'actions GitHub
• Connaissance de la configuration Fastlane
• Temps pour maintenir et déboguer le pipeline

Capgo Construire pour CI/CD par Capgo

Sauter la maintenance de Fastlane, Gradle runner, clé de stockage et script d'envoi. Capgo Construire exécute des builds natifs Android signés à partir de votre pipeline CI/CD existant :

• Fonctionne avec votre pipeline : Déclencher Capgo Construire à partir d'GitHub Actions, GitLab CI, Jenkins ou scripts locaux après votre build web et npx cap sync.
• Signature à partir de secrets CI : Conserver les clés de stockage Android, les alias de clés, les mots de passe et le JSON de compte de service de Console Google Play dans vos propres secrets CI.
• Pas de maintenance de l'exécuteur natif : Capgo Construire fournit des environnements de build Android maintenus, vous n'avez donc pas à gérer les images SDK, les problèmes de cache Gradle ou les voies de Fastlane.
• Artéfacts et soumission : Télécharger les artéfacts signés pour les tests de qualité ou soumettre les builds de version à travers le Capgo CLI.

Tarifs

• Capgo plans commencent à 12 $/mois
• Inclut les mises à jour OTA et environ 15 constructions natives par mois
• Les minutes de construction supplémentaires sont facturées par minute par crédit

Configurer Capgo Build dans CI/CD

Guide de configuration manuelle

Voici ce que vous devez faire :

GitHub Actions Tarifs

GitHub Actions offre des minutes gratuites en fonction du type de votre dépôt :

• Dépôts publics : 2 000 minutes/mois
• Dépôts privés : 2 000 minutes/mois (exécutants Linux)

For les projets privés, les coûts sont d'environ 0,008 $/minute. Une construction typique prend 3-5 minutes.

Étapes de configuration manuelle

1. Créer un clé de stockage Android
2. Configurer le compte de service Google Play
3. Configurer les secrets __CAPGO_KEEP_0__
4. Créer le flux de travail d'actions GitHub
5. Create GitHub Actions workflow

Avant de pouvoir signer et publier votre application Android, vous devez créer un fichier de clé de stockage. Il s'agit d'une configuration unique.

Générer clé de stockage avec keytool

Exécutez cette commande dans votre terminal :

Vous serez invité à fournir :

keytool -genkey -v -keystore my-release-key.keystore -alias my-key-alias -keyalg RSA -keysize 2048 -validity 10000

]}

• Mot de passe du coffre-fort : Choisissez un mot de passe fort (vous en aurez besoin comme KEYSTORE_STORE_PASSWORD)
• Mot de passe de la clé : Choisissez un mot de passe fort (vous en aurez besoin comme KEYSTORE_KEY_PASSWORD)
• Votre nom, organisation, etc. : Remplissez vos informations

Notes importantes

• Sauvegardez ces valeurs de manière sécurisée:

  • Emplacement du fichier coffre-fort (par exemple, my-release-key.keystore)
  • Alias de la clé (par exemple, my-key-alias ) - vous en aurez besoin comme KEYSTORE_KEY_ALIAS
  • Mot de passe du coffre-fort - vous en aurez besoin comme KEYSTORE_STORE_PASSWORD
  • Mot de passe clé - vous en aurez besoin pour cela KEYSTORE_KEY_PASSWORD

• Sauvegardez le fichier de clé de stockageSi vous le perdez, vous ne pourrez pas mettre à jour votre application publiée

• Gardez-le secretNe le commettez jamais dans git

• Stockez-le en lieu sûrGardez plusieurs copies dans des emplacements sécurisés

Alternative : Utilisez une clé de stockage existante

Si vous avez déjà publié votre application, vous devez utiliser la même clé de stockage que vous avez utilisée initialement. Vous pouvez la trouver :

• Sur votre machine locale où vous avez construit l'application pour la première fois
• Dans votre Console de Play → Paramètres → Signature de l'application (si vous utilisez Google Play App Signing)

2. Configurez le compte de service Google Play

Pour permettre aux GitHub Actions de télécharger des builds sur Google Play, vous avez besoin d'un compte de service.

Étape 2.1 : Créer un projet Google Cloud

1. Allez à Console de Google Cloud
2. Créer un nouveau projet ou sélectionner un projet existant
3. Notez l'ID du projet

Étape 2.2 : Activer le développeur Google Play API

1. Dans la Console de Google Cloud, allez à APIs & Services → Bibliothèque
2. Recherchez “développeur Android Google Play API”
3. Cliquez Activer

Étape 2.3 : Créer un Compte de Service

1. Allez à IAM & Admin → Comptes de Service
2. Cliquez Créer un Compte de Service
3. Entrer les détails :
   • Nom : github-actions-uploader
   • Description : « Compte de service pour les GitHub Actions pour télécharger les builds »
4. Cliquez Créer et Continuer
5. Passer la mise en place de rôle pour l'instant (cliquez Continuer, puis Terminé)

Étape 2.4 : Créer la clé de compte de service

1. Cliquez sur le nouveau compte de service créé
2. Allez à Clés onglet
3. Cliquez Ajouter une clé → Créer une nouvelle clé
4. Sélectionnez format JSON Cliquez
5. Créer Un fichier JSON téléchargera -
6. sauvegardez cela en toute sécurité Vous en aurez besoin plus tardÉtape 2.5 : Accorder l'accès dans Play Console

Allez à

1. Google Play Console Allez à
2. Sélectionnez Configuration → API accès
3. Sous Comptes de service, cliquez Accordez l'accès pour votre compte de service
4. Sur la Permissions de l'application rubrique, ajoutez votre application
5. Sur la Permissions de compte Cliquez sur l'option de permission :
   • Afficher les informations de l'application et télécharger des rapports de masse (lecture seule)
   • Créer, modifier et supprimer des applications de brouillon
   • Lancer les applications sur les trajectoires de test
   • Lancer les applications sur la production, les exclure et les autres trajectoires
6. Cliquez Inviter un utilisateur
7. Cliquez Envoyer l'invitation

Étape 2.6 : Vérifiez la clé JSON

Le fichier JSON téléchargé devrait ressembler à ceci :

{
  "type": "service_account",
  "project_id": "your-project-id",
  "private_key_id": "...",
  "private_key": "-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n",
  "client_email": "github-actions-uploader@your-project-id.iam.gserviceaccount.com",
  "client_id": "...",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "..."
}

Vous convertirez cela en base64 dans l'étape de configuration des secrets GitHub.

3. Mettre en place Fastlane

Créer un fastlane dossier à la racine de votre projet et y ajouter un Fastfile contenant ce contenu :

default_platform(:android)

KEYSTORE_KEY_ALIAS = ENV["KEYSTORE_KEY_ALIAS"]
KEYSTORE_KEY_PASSWORD = ENV["KEYSTORE_KEY_PASSWORD"]
KEYSTORE_STORE_PASSWORD = ENV["KEYSTORE_STORE_PASSWORD"]

platform :android do
    desc "Deploy a beta version to the Google Play"
    private_lane :verify_changelog_exists do |version_code: |
      changelog_path = "android/metadata/en-US/changelogs/#{version_code}.txt"
      UI.user_error!("Missing changelog file at #{changelog_path}") unless File.exist?(changelog_path)
      UI.message("Changelog exists for version code #{version_code}")
    end

    private_lane :verify_upload_to_staging do |version_name: |
      UI.message "Skipping staging verification step"
    end
    
    lane :beta do
        keystore_path = "#{Dir.tmpdir}/build_keystore.keystore"
        File.write(keystore_path, Base64.decode64(ENV['ANDROID_KEYSTORE_FILE']))
        json_key_data = Base64.decode64(ENV['PLAY_CONFIG_JSON'])
        
        # Get previous build number and increment
        previous_build_number = google_play_track_version_codes(
            package_name: ENV['DEVELOPER_PACKAGE_NAME'],
            track: "internal",
            json_key_data: json_key_data,
        )[0]
        current_build_number = previous_build_number + 1
        sh("export NEW_BUILD_NUMBER=#{current_build_number}")
        
        # Build the app
        gradle(
          task: "clean bundleRelease",
          project_dir: 'android/',
          print_command: false,
          properties: {
            "android.injected.signing.store.file" => "#{keystore_path}",
            "android.injected.signing.store.password" => "#{KEYSTORE_STORE_PASSWORD}",
            "android.injected.signing.key.alias" => "#{KEYSTORE_KEY_ALIAS}",
            "android.injected.signing.key.password" => "#{KEYSTORE_KEY_PASSWORD}",
            'versionCode' => current_build_number
          })
        
        # Upload to Play Store
        upload_to_play_store(
            package_name: ENV['DEVELOPER_PACKAGE_NAME'],
            json_key_data: json_key_data,
            track: 'internal',
            release_status: 'completed',
            skip_upload_metadata: true,
            skip_upload_changelogs: true,
            skip_upload_images: true,
            skip_upload_screenshots: true,
        )
    end
end

4. Configurer les secrets GitHub

Maintenant que vous avez votre clé de stockage et votre fichier JSON de compte de service, vous devez les stocker de manière sécurisée dans GitHub.

Étape 4.1 : Accéder aux secrets GitHub

1. Allez sur votre dépôt sur GitHub
2. Cliquez Paramètres → Secrets et variables → Actions
3. Cliquez Nouveau secret de dépôt

Étape 4.2 : Ajouter les secrets requis

Ajoutez chaque de ces secrets un par un :

PLAY_CONFIG_JSON

1. Prenez le fichier JSON de compte de service que vous avez téléchargé à l'étape 2.4
2. Convertissez-le en base64 :

Sur macOS/Linux :

base64 service_account_key.json | pbcopy

Sur Windows (PowerShell) :

[Convert]::ToBase64String([IO.File]::ReadAllBytes("service_account_key.json")) | Set-Clipboard

3. Créez un nouveau secret nommé PLAY_CONFIG_JSON et collez la chaîne base64

Fichier clé Android KeyStore

1. Convertissez votre clé de stockage en base64 :

Sur macOS/Linux :

base64 my-release-key.keystore | pbcopy

Sur Windows (PowerShell) :

[Convert]::ToBase64String([IO.File]::ReadAllBytes("my-release-key.keystore")) | Set-Clipboard

2. Créez un nouveau secret nommé ANDROID_KEYSTORE_FILE et collez la chaîne base64

CLÉ D'ALIASE DE STOCKAGE

Créez un nouveau secret avec l'alias de clé que vous avez utilisé lors de la génération de la clé de stockage (par exemple, my-key-alias)

CLÉ DE MOT DE Passe DE STOCKAGE

Créez un nouveau secret avec le mot de passe de clé que vous avez défini lors de la génération de la clé de stockage

CLÉ DE MOT DE Passe DE STOCKAGE

Créez un nouveau secret avec le mot de passe de clé que vous avez défini lors de la génération de la clé de stockage

NOM DU PAQUETAGE DU DÉVELOPPEUR

Créez un nouveau secret avec le nom de package de votre application (par exemple, com.example.app)

Vous pouvez trouver votre nom de package dans android/app/build.gradle sous applicationId

Étape 4.3 : Vérifiez tous les secrets

Assurez-vous d'avoir ces 6 secrets configurés :

• ✅ PLAY_CONFIG_JSON
• ✅ FICHIER KEYS ANDROID
• ✅ ALIAS DE LA CLÉ DE KEYS
• ✅ MOT DE PASSE DE LA CLÉ DE KEYS
• ✅ MOT DE PASSE DU MAGASIN DE KEYS
• ✅ NOM DE PACKAGE DU DÉVELOPPEUR

5. Créez GitHub Workflow d'actions

Créez .github/workflows/build-upload-android.yml:

name: Build and Deploy Android App

on:
  push:
    tags:
      - '*'

jobs:
  build_android:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      
      - name: Setup Node.js
        uses: actions/setup-node@v6
        with:
          node-version: 24
          cache: npm
          
      - name: Install dependencies
        run: npm ci
        
      - name: Cache Gradle
        uses: actions/cache@v5
        with:
          path: |
            ~/.gradle/caches
            ~/.gradle/wrapper
          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
          restore-keys: |
            ${{ runner.os }}-gradle-
            
      - name: Build app
        run: npm run build
        
      - name: Sync Capacitor
        run: npx cap sync
        
      - name: Setup Java
        uses: actions/setup-node@v5
        with:
            distribution: 'zulu'
            java-version: '17'
            
      - name: Setup Ruby
        uses: ruby/setup-ruby@v1
        with:
          ruby-version: '3.0'
          bundler-cache: true
          
      - name: Run Fastlane
        uses: maierj/fastlane-action@v3.1.0
        env:
          PLAY_CONFIG_JSON: ${{ secrets.PLAY_CONFIG_JSON }}
          ANDROID_KEYSTORE_FILE: ${{ secrets.ANDROID_KEYSTORE_FILE }}
          DEVELOPER_PACKAGE_NAME: ${{ secrets.DEVELOPER_PACKAGE_NAME }}
          KEYSTORE_KEY_ALIAS: ${{ secrets.KEYSTORE_KEY_ALIAS }}
          KEYSTORE_KEY_PASSWORD: ${{ secrets.KEYSTORE_KEY_PASSWORD }}
          KEYSTORE_STORE_PASSWORD: ${{ secrets.KEYSTORE_STORE_PASSWORD }}
        with:
          lane: android beta
          
      - name: Upload artifact
        uses: actions/upload-artifact@v2
        with:
          name: android-release
          path: ./android/app/build/outputs/bundle/release/app-release.aab
          retention-days: 10

Comment ça marche

1. Créez une étiquette Git pour déclencher le flux de travail
2. GitHub Actions construit votre application
3. Fastlane la télécharge sur le canal beta Google Play
4. Votre application est automatiquement mise à jour

Temps de construction et coûts

• Temps de construction : 3-5 minutes
• Coût pour les dépôts privés : ~$0.04 par build
• Gratuit pour les projets open-source

Articles liés

Guides de configuration CI/CD

• Construction automatique de l'Capacitor iOS avec des GitHub Actions - Configuration complète de CI/CD pour iOS
• Construction automatique et mise en production avec des GitHub Actions - Guide complet de la chaîne de CI/CD
• Gestion des builds Dev et Prod avec des GitHub Actions - Gestion des environnements

Autres plateformes de CI/CD

• Construction avec GitLab CI - Alternative de GitLab pour Android
• Construction avec CodeMagic - Guide de configuration de CodeMagic

Mises à jour en temps réel et déploiement

• Capgo Live Updates Documentation - Ajoutez des mises à jour OTA à votre application
• Intégration CI/CD avec Capgo - Intégrez les mises à jour en temps réel dans votre pipeline

Ressources

• GitHub Actions Documentation
• Documentation Fastlane

Continuez avec la construction automatique d'Capacitor Android avec les actions GitHub

Si vous utilisez La construction automatique d'Capacitor Android avec les actions GitHub pour planifier l'automatisation CI/CD, connectez-le avec Capgo CI/CD pour le flux de travail du produit dans Capgo CI/CD, Capgo Bâtiments natifs pour le flux de travail du produit dans Capgo Bâtiments natifs, Capgo Intégrations pour le flux de travail du produit dans Capgo Intégrations, Intégration CI/CD pour le détail d'implémentation dans Intégration CI/CD, et GitHub Intégration d'actions for the implementation detail in GitHub Actions Integration.