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

La mise en place de CI/CD pour les applications Capacitor peut être complexe et fastidieuse. Voici ce dont vous avez besoin de savoir :

Recommandé pour les nouvelles constructions : Utilisez la construction Capgo

Nous recommandons désormais d'utiliser la construction Capgo avec le Capgo CLI pour les applications Capacitor natives. Cette guide Fastlane est conservé pour les équipes qui maintiennent des pipelines d'actions GitHub existants, mais les nouvelles applications 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 vous-même.

Prérequis

Avant de commencer, vous devrez configurer :

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

Configuration de CI/CD professionnelle par Capgo

Sauter la complexité. Capgo configure votre pipeline CI/CD directement sur votre plateforme préférée :

• Indépendance de la plateforme: Fonctionne avec GitHub Actions, GitLab CI ou autres
• Intégration Saisissante: Pas de changement de plateforme nécessaire, fonctionne avec votre processus actuel
• Configuration Adaptée: Paramétrage personnalisé correspondant aux besoins de votre projet
• Conseil Expert: Nous avons déjà configuré CI/CD pour 50+ applications

Tarifs

• Frais de mise en place unique : 2 600 $
• Coûts de fonctionnement en cours : ~300 $ par an
• Comparer à Autre solution propriétaire : 6 000 $ par an
• Économisez 26 100 $ sur 5 ans

Configurer maintenant le CI/CD

Guide de configuration manuelle

Si vous souhaitez toujours configurer tout vous-même, 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 $ par minute. Une construction 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 le workflow d'actions GitHub

1. Créer un fichier de clé Android

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

Générer la clé 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 la clé de stockageChoisissez 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 de clé (par exemple, my-release-key.keystore)
  • Alias de clé (par exemple, my-key-alias) - vous en aurez besoin pour KEYSTORE_KEY_ALIAS
  • Mot de passe de clé - vous en aurez besoin pour KEYSTORE_STORE_PASSWORD
  • Mot de passe de clé - vous en aurez besoin pour KEYSTORE_KEY_PASSWORD

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

• Gardez-le secret: Ne jamais commiter le fichier de clé de stockage dans Git

• Stockez-le en toute sécurité: Faites plusieurs sauvegardes dans des emplacements sécurisés

Alternative : Utiliser un Clé de Stockage Existant

Si vous avez déjà publié votre application, vous devez utiliser la même clé de stockage que celle 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 Google Play → Paramètres → Signature de l'application (si vous utilisez Google Play App Signing)

2. Configurer le Compte de Service Google Play

Pour permettre aux GitHub Actions d'uploader 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. Noter l'ID du projet

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

1. Dans le console Cloud Google, allez à APIs & Services → Bibliothèque
2. Rechercher “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 les builds »
4. Cliquez Créer et Continuer
5. Ignorer l'attribution 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 compte de service créé récemment
2. Allez à Clés Onglet
3. Cliquez Ajouter une clé → Créer une nouvelle clé
4. Choisissez Format JSON Cliquez
5. Étape 2.4 : Créer la clé de compte de service Créez
6. Un fichier JSON téléchargera - sauvegardez cela de manière sécurisée, vous en aurez besoin plus tard

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

1. Allez à Console de jeu Google
2. Allez à Configuration → API accès
3. Sous Comptes de service, cliquez Accordez l'accès pour votre compte d'utilisateur de service
4. Sur la page Permissions de l'application Ajoutez votre application
5. Sur la page Permissions de compte 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
   • Publiez les applications sur les circuits de test
   • Déployez les applications en production, excluez, et autres pistes
6. Cliquez Invitez l'utilisateur
7. Cliquez Envoyez une 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. Configurez 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. Configure 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éder à GitHub Secrets

1. Allez dans 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. Téléchargez 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 secret nommé PLAY_CONFIG_JSON et collez la chaîne base64

ANDROID_KEYSTORE_FILE

1. Convertissez votre fichier de clé 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 secret nommé ANDROID_KEYSTORE_FILE coller la chaîne base64

ALIAS_DE_LA_CLÉ

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)

MOT_DE_PASSE_DE_LA_CLÉ

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

MOT_DE_PASSE_DU_COFFRE_FORT

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

NOM_DU_PACKAGE_DE_DEVELOPPEUR

Créez un nouveau secret avec le nom de votre package d'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 DE CLÉ DE KEYSTORE ANDROID
• ✅ ALIAS DE CLÉ DE KEYSTORE
• ✅ MOT DE PASSE DE CLÉ DE KEYSTORE
• ✅ MOT DE PASSE DE MAGASIN DE KEYSTORE
• ✅ NOM DE PAQUETTE DU DÉVELOPPEUR

5. Créez GitHub Actions Workflow

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 étiquette Git pour déclencher le flux de travail
2. GitHub Actions construit votre application
3. Fastlane l'envoie sur le canal de test Google Play
4. Votre application est automatiquement mise à jour

Temps et Coûts de Construction

• 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

• Build automatique de l'Capacitor iOS avec les GitHub Actions - Configuration complète de CI/CD pour iOS
• Build et Lancement automatiques avec les GitHub Actions - Tutoriel complet de pipeline CI/CD
• Gérer les builds Dev et Prod avec GitHub Actions - Gestion des environnements

Alternatives aux plateformes CI/CD

• 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

• Documentation des mises à jour en temps réel Capgo - 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

• GitHub Actions Documentation
• Documentation de Fastlane