Automatic Capacitor build Android automatique avec des GitHub actions

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

Recommended for New Builds: Use Capgo Build

Nous recommandons maintenant d'utiliser Capgo Construire avec le Capgo CLI pour les builds natifs Capacitor. Cette guide Fastlane est conservé pour les équipes qui maintiennent des pipelines d'actions GitHub existants, mais les nouvelles constructions d'Android doivent utiliser le Capgo CLI afin que vous n'ayez pas à maintenir Fastlane, les exécutants Gradle, les clés de stockage et les scripts d'envoi vous-même.

Prerequisites

Avant de commencer, vous aurez besoin de configurer :

• Un compte GitHub avec un 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 l’API Play Store activée
• Compte de service avec les permissions appropriées
• Compréhension des workflows d'actions GitHub
• Connaissances de la configuration Fastlane
• Temps pour maintenir et déboguer le pipeline

Construction Capgo 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 natifs signés à partir de votre pipeline CI/CD existant :

• Marche avec votre pipelineDéclenchez la construction de Capgo à partir de GitHub Actions, GitLab CI, Jenkins ou scripts locaux après votre build web. npx cap sync.
• Signature à partir de secrets CI: Gardez les coffres-forts Android, les alias de clés, les mots de passe et le JSON du service compte Play dans vos propres secrets CI.
• Aucune maintenance du lanceur natif: Capgo Build 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 ou soumettez des builds de mise en production à travers le Capgo CLI.

Tarification

• Les plans de Capgo commencent à 12 $/mois
• Comprennent 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 la mise en construction de Capgo dans l'CI/CD

Guide de configuration manuelle

Guide de configuration manuel

Prix des GitHub Actions

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

• Répositories publics : 2 000 minutes/mois
• Répertoires 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 un flux de travail 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 unique.

Générer une 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 stockage: Choisissez un mot de passe fort (vous en aurez besoin comme 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 informations

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 du coffre-fort - vous en aurez besoin KEYSTORE_STORE_PASSWORD
  • Mot de passe clé - vous en aurez besoin comme KEYSTORE_KEY_PASSWORD

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

• Le gardez secret: Never commit the keystore file to git

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

Alternative : Utiliser le Clé de Signature Existant

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

• In your local machine where you first built the app
• Dans votre console Google Play → Paramètres → Signature d'application (si vous utilisez Google Play App Signing)

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

1. Allez à Console de Google Cloud
2. Créez un nouveau projet ou sélectionnez-en un existant
3. Notez l'ID du projet

Step 2.2: Enable Google Play Developer API

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

Étape 2.3 : Créer un compte d'exploitation

1. Allez à IAM & Admin → Comptes d'exploitation
2. Cliquez Créer un compte d'exploitation
3. Entrer les détails :
   • Nom : github-actions-uploader
   • Description : « Compte d'exploitation pour les actions GitHub pour l'upload des builds »
4. Cliquez Créer et Continuer
5. Sauvegarder le 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. Choisissez JSON format
5. Cliquez Créer
6. Un fichier JSON téléchargera - Enregistrez ceci en toute sécurité, vous en aurez besoin plus tard

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

1. Cliquez sur Console de Play Google
2. Cliquez sur Configuration → API accès
3. Sous Comptes de service, cliquez Accorder accès pour votre compte de service
4. Sur la Permissions de l'application onglet, ajoutez votre application
5. Sur la Permissions de compte onglet, accordez ces permissions :
   • View app information and download bulk reports (read only)
   • Create, edit, and delete draft apps
   • Publier des applications sur des trajectoires de test
   • Lancez les applications en production, excluez, et autres pistes
6. Cliquez Invite user
7. Cliquez Send invite

Étape 2.6 : Vérifiez la clé JSON

La 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 cela en base64 dans l'étape de configuration des secrets GitHub.

3. Configurer Fastlane

Créez un fastlane dossier à 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 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édez aux secrets GitHub

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

Sur la page d'about.astro de Capgo.

PLAY_CONFIG_JSON

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

Convertissez-l’en base64 :

base64 service_account_key.json | pbcopy

Sur macOS/Linux :

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

3. Sur Windows (PowerShell) : PLAY_CONFIG_JSON Créez un nouveau secret nommé

et collez la chaîne base64

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_KEystore

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

CLÉ_DE_PASSWORD_DE_KEystore

Créer un nouveau secret avec la clé mot de passe que vous avez défini lors de la génération du keystore.

CLÉ_DE_PASSWORD_DE_MAGASIN

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

NOM_DE_PACKAGE_DE_DEVELOPPEUR

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 :

• ✅ Configurer la PLAY_JSON
• ✅ Fichier de clé Android Keystore
• ✅ Alias de clé de keystore
• Mot de passe de clé de stockage
• Mot de passe de magasin de clés
• ✅ DEVELOPER_PACKAGE_NAME

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 balise Git pour déclencher le flux de travail
2. GitHub Actions builds your app
3. Fastlane l'envoie sur le canal de test Google Play
4. Your app is automatically updated

Votre application est automatiquement mise à jour

• Temps de construction et coûts
• Temps de construction : 3-5 minutes
• Gratuit pour les projets open-source

Gratuit pour les projets open-source

Articles connexes

• Automatic Capacitor Build iOS automatique avec GitHub Actions - Configuration CI/CD iOS complète
• Construction automatique et mise en production avec des GitHub Actions - Tutoriel complet de pipeline CI/CD
• Gestion des constructions Dev et Prod avec des GitHub Actions - Gestion des environnements

Plateformes CI/CD alternatives

• Construction avec GitLab CI - Alternative GitLab pour Android
• Construction 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 - Ajoutez des mises à jour OTA à votre application
• - Intégration CI/CD avec Capgo - Intégrez les mises à jour en direct dans votre pipeline

Ressources

• Documentation des actions de GitHub
• Documentation Fastlane

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

Si vous utilisez La construction automatique d'Android de Capacitor avec les actions de GitHub pour planifier l'automatisation CI/CD, connectez-l’avec Capgo CI/CD pour le flux de travail du produit dans Capgo CI/CD Capgo Bâtiments natifs pour le flux de produit dans Capgo Bâtiments natifs Capgo Intégrations pour le flux de 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 pour le détail d'implémentation dans GitHub Intégration d'actions