La construction automatique d'Capacitor Android avec des GitHub actions

La mise en place de la chaîne de production continue (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 la construction Capgo

Nous recommandons désormais d'utiliser Capgo Construction avec le Capgo CLI pour les constructions natives Capacitor. Ce 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 stockage et les scripts d'envoi.

Prérequis

Avant de commencer, vous devrez 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é de stockage
• Projet Google Cloud Console avec la mise en ligne de Google Play Store API activée
• Compte de service avec les permissions appropriées
• Compréhension des workflows d'actions GitHub
• Connaissances de la configuration de Fastlane
• Temps à consacrer à la maintenance et à la débogage du pipeline

Capgo Build pour CI/CD par Capgo

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

• Fonctionne avec votre pipeline: Déclenchez Capgo Construction à partir d'GitHub Actions, GitLab CI, Jenkins ou scripts locaux après votre build web et npx cap sync.
• Signature à partir de secrets CI: Conservez les clés de magasin 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 Construction 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échargez les artefacts signés pour les tests de qualité ou soumettez les builds de lancement à travers le Capgo CLI.

Tarification

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

Configurer Capgo Build dans CI/CD

Guide de configuration manuelle

Ici, 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)

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

Étapes de configuration manuelle

1. Créer un clé de stockage Android
2. Configurer un compte de service Google Play
3. Configurer Fastlane
4. Configurer les secrets GitHub
5. Créer un workflow d'actions GitHub

1. Créer un clé de stockage Android

Avant de pouvoir signer et publier votre application Android, vous devez créer un fichier de clé de stockage. C'est une configuration une fois.

Générer clé de stockage 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é à saisir :

• Mot de passe de clé de stockageChoisissez un mot de passe fort (vous en aurez besoin) KEYSTORE_STORE_PASSWORD)
• Mot de passe clé: Choisissez un mot de passe fort (vous en aurez besoin comme KEYSTORE_KEY_PASSWORD)
• Votre nom, organisation, etc.: Remplissez vos détails

Notes importantes

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

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

• Sauvegardez le fichier de clé de secours: Si vous le perdez, vous ne pouvez pas mettre à jour votre application publiée

• Gardez-le secret: Ne commettez jamais le fichier de clé de stockage au git

• Stockez-le en toute sécurité: Gardez plusieurs copies de sauvegarde dans des emplacements sécurisés

Alternative : Utilisez un 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 :

• Dans 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 la signature de l'application Google Play)

2. Configurez 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éez un projet Cloud Google

1. Allez à Console 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. À la console 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 GitHub Actions pour télécharger des builds »
4. Cliquez Créer et Continuer
5. Passer la mise à jour de rôle pour l'instant (cliquez ContinuerEnsuite Terminé)

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

1. Cliquez sur le compte de service créé récemment
2. Allez à Clés onglet
3. Cliquez Ajouter une clé → Créer une nouvelle clé
4. Sélectionnez JSON format
5. Cliquez Créer
6. Un fichier JSON téléchargera - sauvegardez-le en toute sécuritécar vous en aurez besoin plus tard

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

1. Allez à Console de jeu Google Play
2. Allez à Configuration → API accès
3. En dessous Comptes de service, cliquez Accordez l'accès pour votre compte de service
4. Sur la Permissions d'application rubrique, ajoutez votre application
5. Sur la Permissions de compte rubrique, 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
   • Publier des applications dans des pistes de test
   • Publier des applications dans la production, exclure et d'autres pistes
6. Click Inviter un utilisateur
7. Click 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éer un fastlane répertoire à votre racine de 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. Configurez les GitHub Secrets

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

Étape 4.1 : Accédez à GitHub Secrets

1. Allez à 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 chacun 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

ANDROID_KEYSTORE_FILE

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

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

__CAPGO_KEEP_0__

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

__CAPGO_KEEP_0__

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

__CAPGO_KEEP_0__

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

__CAPGO_KEEP_0__

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 dessous applicationId

Étape 4.3 : Vérifiez tous les secrets

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

• ✅ PLAY_CONFIG_JSON
• ✅ FICHIER DE CLÉ DE KEYSTORE ANDROID
• ✅ ALIAS DE CLÉ DE KEYSTORE
• ✅ MOT DE Passe DE CLÉ DE KEYSTORE
• ✅ MOT DE Passe DU MAGASIN DE CLÉS
• ✅ NOM DU PAQUETAGE DU DÉVELOPPEUR

5. Créez GitHub Workflow d'actions de Capgo

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

1. Créez une balise Git pour déclencher le flux de travail
2. GitHub Actions construit votre application
3. Fastlane la télécharge sur le canal de test 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 projets privés : ~$0.04 par build
• Gratuit pour les projets open-source

Articles connexes

Guides de configuration CI/CD

• Construction automatique de Capacitor iOS avec GitHub Actions - Configuration CI/CD complète de iOS
• Construction Automatique et Lancement avec GitHub Actions - Guide complet de la chaîne de production CI/CD
• Gestion des Constructions Dev et Prod avec GitHub Actions - Gestion des environnements

Plateformes CI/CD Alternatives

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

Mises à jour en temps réel et 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égrez les mises à jour en temps réel dans votre pipeline

Ressources

• Documentation des actions GitHub
• Documentation Fastlane

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