Build Android Capacitor automatique avec les actions GitHub

Configurer la CI/CD pour les apps Capacitor peut être complexe et chronophage. Voici ce qu'il faut savoir :

Recommandé pour les nouveaux builds : utilisez Capgo Build

Nous recommandons désormais d'utiliser Capgo Build avec le Capgo CLI pour les builds natifs Capacitor. Ce guide Fastlane est conservé pour les équipes qui maintiennent des pipelines GitHub Actions existants, mais les nouveaux builds Android doivent utiliser le Capgo CLI pour ne pas avoir à maintenir vous-même Fastlane, les runners Gradle, les keystores et les scripts d'upload.

Prerequisites

Avant de commencer, vous devrez configurer :

• Un compte GitHub avec un accès admin
• Votre application déjà publiée sur le Play Store avec une signature correcte
• Clé de signature Android et fichiers keystore
• Projet Google Cloud Console avec API activé pour le Play Store
• Compte de service avec les permissions adéquates
• Une compréhension des workflows GitHub Actions
• Connaissance de la configuration Fastlane
• Temps de maintenance et de debug du pipeline

Capgo Build pour CI/CD par Capgo

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

• Compatible avec votre pipeline: Déclenchez Capgo Build depuis GitHub Actions, GitLab CI, Jenkins ou des scripts locaux après votre build web et npx cap sync.
• Signature via les secrets CI: Conservez vos keystores Android, alias de clés, mots de passe et fichiers JSON de compte de service Play Console dans vos propres secrets CI.
• Aucune maintenance de runner natif: Capgo Build fournit des environnements de build Android maintenus, vous évitant de gérer SDK, les problèmes de cache Gradle ou les lanes Fastlane.
• Artifacts et soumission: Téléchargez des artifacts signés pour la QA ou soumettez des builds de release via Capgo CLI.

Tarifs

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

Configurez Capgo Build dans votre CI/CD

Guide de configuration manuelle

Voici ce que vous devez faire :

Tarifs GitHub Actions

GitHub Actions offre des minutes gratuites selon votre type de dépôt :

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

Pour les projets privés, le coût est d'environ 0,008 $/minute. Un build typique dure 3 à 5 minutes.

Étapes de configuration manuelle

1. Créer un Android Keystore
2. Configurer un compte de service Google Play
3. Configurer Fastlane
4. Configurer les secrets GitHub
5. Créer un workflow GitHub Actions

1. Créer un Android Keystore

Avant de pouvoir signer et publier votre application Android, vous devez créer un fichier keystore. Cette configuration ne se fait qu'une seule fois.

Générer le Keystore 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

On vous demandera :

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

Notes importantes

• Conservez ces valeurs en lieu sûr:

  • Emplacement du fichier Keystore (ex : my-release-key.keystore)
  • Alias de la clé (ex : my-key-alias) - vous en aurez besoin comme KEYSTORE_KEY_ALIAS
  • Mot de passe du keystore - vous en aurez besoin pour KEYSTORE_STORE_PASSWORD
  • Mot de passe clé - vous en aurez besoin pour KEYSTORE_KEY_PASSWORD

• Sauvegarder le fichier keystore: Si vous le perdez, vous ne pourrez pas mettre à jour votre application publiée

• Gardez-le secret: Ne commitez jamais le fichier keystore sur git

• Stockez-l’en toute sécurité: Conservez plusieurs sauvegardes dans des lieux sécurisés

Alternative : Utiliser un keystore existant

Si vous avez déjà publié votre application, vous devez utiliser le même keystore qu'au départ. Vous pouvez le trouver :

• Sur votre machine locale où vous avez effectué le premier build de l'app
• Dans votre Play Console → Configuration → Signature d'application (si vous utilisez Google Play App Signing)

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

1. Accéder à Console Google Cloud
2. Créer un nouveau projet ou en sélectionner un existant
3. Noter l'ID du projet

Étape 2.2 : Activer l'API Google Play Developer

1. Dans la console Google Cloud, allez sur API et services → Bibliothèque
2. Rechercher « Google Play Android Developer API »
3. Cliquez Activer

Étape 2.3 : Créer un compte de service

1. Accéder à IAM et administration → Comptes de service
2. Cliquez Créer un compte de service
3. Saisissez les détails :
   • Nom : github-actions-uploader
   • Description : « Compte de service pour GitHub Actions afin d'envoyer les builds »
4. Cliquez Créer et continuer
5. Skip role assignment for now (click Continuer, puis Terminé)

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

1. Cliquez sur le compte de service nouvellement créé
2. Accéder à Clés onglet
3. Cliquez Ajouter une clé → Créer une nouvelle clé
4. Choisissez JSON format
5. Cliquez Créer
6. Un fichier JSON va se télécharger - enregistrez-l’en lieu sûr, vous en aurez besoin plus tard

Étape 2.5 : Accorder l'accès dans la Play Console

1. Accéder à Google Play Console
2. Accéder à Configuration → Accès à API
3. Inférieur à Comptes de service, cliquez sur Accorder l'accès pour votre compte de service
4. Dans l'onglet Permissions de l'application , ajoutez votre application
5. Dans l'onglet Permissions du compte onglet, accordez ces permissions :
   • Consulter les infos de l'app et télécharger des rapports groupés (lecture seule)
   • Créer, modifier et supprimer des brouillons d'apps
   • Publier des apps sur les canaux de test
   • Publier des apps en production, les exclure et sur d'autres canaux
6. Cliquez Invite user
7. Cliquez Send invite

Étape 2.6 : Vérifier la clé JSON

Le fichier JSON téléchargé doit 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 ceci en base64 lors de l'étape de configuration des secrets GitHub.

3. Configurer Fastlane

Créer un fastlane dossier à la racine de votre projet et ajouter 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 keystore et votre fichier JSON de service account, vous devez les stocker en toute sécurité 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 chacun de ces secrets un par un :

PLAY_CONFIG_JSON

1. Prenez le fichier JSON du compte de service que vous avez téléchargé à l'étape 2.4
2. Convertissez-l’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 keystore 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

KEYSTORE_KEY_ALIAS

Créez un nouveau secret avec l'alias de clé utilisé lors de la génération du keystore (ex : my-key-alias)

KEYSTORE_KEY_PASSWORD

Créez un nouveau secret avec la clé password que vous avez définie lors de la génération du keystore

KEYSTORE_STORE_PASSWORD

Créez un nouveau secret avec le mot de passe du keystore défini lors de sa génération

DEVELOPER_PACKAGE_NAME

Créez un nouveau secret avec le nom de package de votre app (ex : com.example.app)

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

Étape 4.3 : Vérifier tous les secrets

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

• ✅ PLAY_CONFIG_JSON
• ✅ ANDROID_KEYSTORE_FILE
• ✅ KEYSTORE_KEY_ALIAS
• ✅ KEYSTORE_KEY_PASSWORD
• ✅ KEYSTORE_STORE_PASSWORD
• ✅ DEVELOPER_PACKAGE_NAME

5. Créer le workflow GitHub 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

1. Créez un tag Git pour déclencher le workflow
2. GitHub Actions compile votre app
3. Fastlane l'envoie sur le canal bêta de Google Play
4. Votre app est mise à jour automatiquement

Temps de build et coûts

• Temps de build : 3 à 5 minutes
• Coût pour les repos privés : ~0,04 $ par build
• Gratuit pour les projets open source

Articles similaires

Guides de configuration CI/CD

• Build iOS Capacitor automatique avec GitHub Actions - Configuration CI/CD iOS complète
• Build et release automatiques avec GitHub Actions - Tutoriel complet sur le pipeline CI/CD
• Gérer les builds Dev et Prod avec GitHub Actions - Gestion des environnements

Alternatives aux plateformes CI/CD

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

Live Updates et déploiement

• Documentation Capgo Live Updates - Ajoutez des mises à jour OTA à votre app
• Intégration CI/CD avec Capgo - Intégrez les live updates dans votre pipeline

Ressources

• Documentation GitHub Actions
• Documentation Fastlane

Continuez à partir du build Android automatique Capacitor grâce aux actions GitHub

Si vous utilisez Build Android Capacitor automatique avec les actions GitHub pour planifier l'automatisation CI/CD, et le connecter avec CI/CD Capgo pour le workflow produit dans le CI/CD de Capgo, Capgo Native Build pour le workflow produit dans les Native Builds de Capgo, Intégrations Capgo pour le workflow produit dans les intégrations de Capgo, Intégration CI/CD pour le détail d'implémentation dans l'intégration CI/CD, et Intégration GitHub Actions pour les détails d'implémentation de l'intégration GitHub Actions.