Build automatique Android Capacitor avec des actions GitHub

Configurer la CI/CD pour les applications Capacitor peut être complexe et chronophage. Voici ce dont vous avez besoin de savoir :

Recommandé pour les nouvelles constructions : Utilisez Capgo Build

Nous recommandons désormais d'utiliser Capgo Build avec le Capgo CLI pour les constructions natives Capacitor. Cette guide Fastlane est conservé pour les équipes qui maintiennent des pipelines d'actions GitHub existants, mais les nouvelles constructions Android devraient utiliser le Capgo CLI afin que vous ne deviez pas maintenir Fastlane, les exécutants Gradle, les clés de chiffrement et les scripts d'envoi vous-même.

Prérequis

Avant de commencer, vous devrez configurer :

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

Capgo Build pour CI/CD par Capgo

Évitez la maintenance de Fastlane, du runner Gradle, du keystore et de l'upload-script. Capgo Build exécute des builds Android signés natifs à partir de votre pipeline CI/CD existant :

Fonctionne avec votre pipeline: Déclenchez Capgo Build à partir d'Actions GitHub, de GitLab CI, de Jenkins ou de scripts locaux après votre build web et npx cap sync.
Signature à partir de secrets CI: Gardez les clés de store Android, les alias de clés, les mots de passe et le JSON du compte de service de la console Google Play dans vos propres secrets CI.
Pas de maintenance de l'exécuteur natif: Capgo La fourniture de build Android maintenue vous permet d'éviter la gestion des SDK images, des problèmes de cache Gradle et des voies de Fastlane.
Artéfacts et soumission: Téléchargez les artefacts signés pour la QA ou soumettez les builds de version à travers le Capgo CLI.

Tarifs

Capgo plans commencent à 12 $/mois
Inclut les mises à jour OTA et environ 15 builds natifs par mois
Les minutes de build supplémentaires sont facturées par minute par crédits

Configurez Capgo Build dans CI/CD

Guide de configuration manuel

Voici ce que vous devez faire :

GitHub Actions Tarifs

Prix GitHub Action

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)

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

Étapes de configuration manuelle

Créer un clé de stockage Android
Configurer un compte de service Google Play
Configurer Fastlane
Configurer les secrets GitHub
Créer un flux de travail GitHub Actions

1. Créer une clé de stockage Android

Avant de pouvoir signer et publier votre application Android, vous devez créer un fichier de clé de sécurité.

Générer clé de sécurité avec keytool

Exécutez cette commande dans votre terminal :

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

Vous serez invité à fournir :

Mot de passe de la clé de sécurité: 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, votre organisation, etc.: Remplissez vos informations

Notes importantes

Enregistrez ces valeurs de manière sécurisée:
- Emplacement du fichier de clé de stockage (par exemple, my-release-key.keystore)
- Alias de clé (par exemple, my-key-alias) - vous aurez besoin de cela comme KEYSTORE_KEY_ALIAS
- Mot de passe du fichier de clé de stockage - vous aurez besoin de cela comme KEYSTORE_STORE_PASSWORD
- Mot de passe de clé - vous aurez besoin de cela comme KEYSTORE_KEY_PASSWORD
Sauvegarder le fichier de clé de stockage: Si vous le perdez, vous ne pouvez pas mettre à jour votre application publiée
Le gardez secret: Ne jamais commiter le fichier de clé de stockage dans git
Le stockez en toute sécurité: Gardez plusieurs sauvegardes dans des emplacements sécurisés

Alternative : Utiliser un Fichier de Clé de Stockage Existant

Si vous avez déjà publié votre application, vous devez utiliser le même coffre-fort que celui que vous avez utilisé initialement. Vous pouvez le trouver :

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

2. Configurer le compte de service Google Play

Pour permettre aux GitHub Actions d'envoyer des builds sur Google Play, vous avez besoin d'un compte de service

Étape 2.1 : Créer un projet Google Cloud

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

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

Dans la console de Google Cloud, allez à APIs & Services → Bibliothèque
Recherchez « Développeur Android Google Play API »
Cliquez Activer

Étape 2.3 : Créer un compte d'utilisateur de service

Allez à IAM & Admin → Comptes d'utilisateur de service
Cliquez Créer un compte d'utilisateur de service
Entrer les détails :
- Nom : github-actions-uploader
- Description : « Compte de service pour les GitHub Actions d'upload des builds »
Clicker Créer et Continuer
Passer la mise en relation de rôle pour l'instant (clicker sur Continuer, puis Terminé)

Étape 2.4 : Créer la Clé du Compte de Service

Clicker sur le nouveau compte de service créé
Allez à Clés onglet
Cliquez Ajouter clé → Créer une nouvelle clé
Choisissez format JSON format JSON
Cliquez Créer
Un fichier JSON téléchargera - sauvegardez-le en toute sécurité, vous en aurez besoin plus tard

Étape 2.5 : Accorder l'accès dans le console Play

Allez à Console de jeu Google Play
Allez à Configuration → API accès
Sous Comptes de service, cliquez Accorder l'accès pour votre compte de service
Dans le Permissions d'application onglet, ajoutez votre application
Sur le Permissions de compte onglet, accordez ces permissions:
- 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 dans les trajectoires de test
- Lancer les applications dans les trajectoires de production, exclure et autres trajectoires
Cliquez Inviter un utilisateur
Cliquez Envoyer une invitation

Étape 2.6 : Vérifier 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. Configurer Fastlane

Créez un fastlane dossier à la racine de votre projet et ajoutez un Fastfile avec 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

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

Étape 4.2 : Ajouter les secrets requis

Ajoutez chacun de ces secrets un par un :

PLAY_CONFIG_JSON

Prenez le fichier JSON de compte de service que vous avez téléchargé à l'étape 2.4
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

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

__CAPGO_KEEP_0__

Convertissez votre clé de magasin 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

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

__CAPGO_KEEP_1__

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

Créez un nouveau secret avec le mot de passe de clé de magasin que vous avez utilisé lors de la génération de la clé de magasin (par exemple,

Créez un nouveau secret avec la clé mot de passe que vous avez définie lors de la génération du coffre-fort

KEYSTORE_STORE_PASSWORD

Créez un nouveau secret avec le mot de passe du coffre-fort que vous avez défini lors de la génération du coffre-fort

DEVELOPER_PACKAGE_NAME

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
✅ ANDROID_KEYSTORE_FILE
✅ KEYSTORE_KEY_ALIAS
✅ MOT DE Passe DE LA CLÉ DE MAGASIN
✅ MOT DE Passe DE LA CLÉ DE MAGASIN DE STOCKAGE
✅ NOM DE PAQUET DU DÉVELOPPEUR

5. Créez GitHub Flux de travail d'Actions

Créer .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

Créez une étiquette Git pour déclencher le flux de travail
GitHub Actions construit votre application
Fastlane la télécharge sur le canal beta de Google Play
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

Guides de configuration CI/CD

Construction automatique de build iOS avec Capacitor et GitHub Actions - Configuration complète de CI/CD pour iOS
Construction et libération automatique avec GitHub Actions - Tutoriel complet de pipeline CI/CD
Gestion des builds Dev et Prod avec GitHub Actions - Gestion des environnements

Autres plateformes CI/CD

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

Mises à jour en temps réel & Déploiement

Capgo Documentation des mises à jour en temps réel - Ajouter des mises à jour OTA à votre application
Intégration CI/CD avec Capgo - Intégrer les mises à jour en temps réel dans votre pipeline

Ressources

Keep going from Automatic Capacitor Android build with GitHub actions

Si vous utilisez Automatic Capacitor Android build with GitHub actions pour planifier l'automatisation CI/CD, connectez-le 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 GitHub Intégration d'actions pour les détails d'implémentation dans les GitHub Actions Integration.

Construction automatique de l'Capacitor build Android avec des actions GitHub