Automatic Capacitor Android build with GitHub actions

Configurare la CI/CD per le Capacitor app può essere complesso e richiede molto tempo. Ecco cosa devi sapere:

Consigliato per Nuove Costruzioni: Utilizza Capgo Build

Ora raccomandiamo di utilizzare Capgo Build con il Capgo CLI per le costruzioni native Capacitor. Questa guida Fastlane è mantenuta per i team che mantengono pipeline di azioni GitHub esistenti, ma nuove costruzioni Android dovrebbero utilizzare il Capgo CLI in modo da non dover mantenere Fastlane, eseguitori di Gradle, chiavi di firma e script di caricamento da soli.

Requisiti

Prima di iniziare, avrai bisogno di configurare:

Un account GitHub con accesso amministrativo
La tua app già pubblicata su Google Play Store con firma corretta
Chiave di firma Android e file di keystore
Progetto di Google Cloud Console con API di Play Store abilitato
Account di servizio con autorizzazioni adeguate
Capacità di comprendere GitHub Flussi di lavoro di Actions
Conoscenza della configurazione di Fastlane
Tempo per mantenere e debuggare il flusso di lavoro

Capgo Build per CI/CD da Capgo

Evitare la manutenzione di Fastlane, Gradle runner, keystore e upload-script. Capgo Build Esegue costruzioni native Android firmate direttamente dal tuo flusso di lavoro CI/CD esistente:

Lavora con il tuo flusso di lavoro: Trascina Capgo Build da GitHub Actions, GitLab CI, Jenkins o script locali dopo la costruzione web e npx cap sync.
Autenticazione da segreti di CI: Mantieni le chiavi Android, gli alias delle chiavi, le password e il JSON del servizio account di Play Console nei tuoi segreti di CI.
No mantenimento del runner nativo: Il Capgo Build fornisce ambienti di costruzione Android mantenuti, quindi non dovete gestire SDK immagini, problemi di cache Gradle o percorsi Fastlane.
Articoli e sottoscrizione: Scaricate gli articoli firmati per la QA o sottoponete i rilasci attraverso il Capgo CLI.

Prezzi

Capgo plans start at $12/month
I piani __CAPGO_KEEP_0__ iniziano da 12 dollari al mese
Includono aggiornamenti OTA e circa 15 costruzioni native al mese

Set up Capgo Build in CI/CD

Configura il __CAPGO_KEEP_0__ Build in CI/CD

Guida di configurazione manuale

GitHub Actions Pricing

Prezzo GitHub Action

GitHub Actions offre minuti gratuiti in base al tipo del tuo repository:

Repository pubblici: 2.000 minuti/mese
Repository privati: 2.000 minuti/mese (esecutori Linux)

Per i progetti privati, i costi sono di circa $0,008/minuto. Una costruzione tipica richiede 3-5 minuti.

Passaggi di configurazione manuale

Creare Android Keystore
Configurare l'account di servizio Google Play
Configurare Fastlane
Configurare GitHub secrets
Creare GitHub Actions workflow

1. Creare Android Keystore

Prima di poter firmare e pubblicare la tua app Android, devi creare un file keystore. Questo è un setup di una sola volta.

Genera Keystore con keytool

Esegui questo comando nel tuo terminale:

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

Ti verrà chiesto:

Password del keystore: Scegli una password forte (avrai bisogno di questa come KEYSTORE_STORE_PASSWORD)
Password della chiave: Scegli una password forte (avrai bisogno di questa come KEYSTORE_KEY_PASSWORD)
Nome, organizzazione, ecc.: Inserisci i tuoi dati

Note importanti

Salva questi valori in modo sicuro:
- Posizione del file Keystore (ad esempio, my-release-key.keystore)
- Alias della chiave (ad esempio, my-key-alias) - avrai bisogno di questo come KEYSTORE_KEY_ALIAS
- Password del Keystore - avrai bisogno di questo come KEYSTORE_STORE_PASSWORD
- Password della chiave - avrai bisogno di questo come KEYSTORE_KEY_PASSWORD
Backup del file Keystore: Se lo perdi, non potrai aggiornare l'app pubblicata
Tienilo segreto: Mai commetti il file Keystore a git
Conservalo in modo sicuro: Conserva più backup in luoghi sicuri

Alternativa: Utilizza Esistente Keystore

If hai già pubblicato il tuo app, devi utilizzare lo stesso keystore che hai utilizzato inizialmente. Puoi trovarlo:

In macchina locale dove hai costruito l'app per la prima volta
In Console di Gioco → Impostazioni → Firma dell'app (se utilizzando la firma dell'app di Google Play)

2. Configura il Servizio di Gioco di Google

Per consentire agli GitHub Azioni di caricare le build su Google Play, hai bisogno di un account di servizio.

Passo 2.1: Crea Progetto di Google Cloud

Vai a Console di Google Cloud
Crea un nuovo progetto o seleziona uno esistente
Nota l'ID del progetto

Passo 2.2: Abilita il API dello Sviluppatore di Google Play

In Console di Google Cloud, vai a Servizi API → Libreria
Cerca “Google Play Android Developer API”
Clicca Abilita

Passo 2.3: Crea account di servizio

Vai a IAM & Admin → Account di servizio
Clicca Crea account di servizio
Inserisci i dettagli:
- Nome: github-actions-uploader
- Descrizione: “Account di servizio per GitHub azioni per l'upload dei build”
Clicca Creare e Continua
Saltare l'assegnazione del ruolo per ora (clicca Continua, quindi Fatto)

Passo 2.4: Crea Chiave di Account di Servizio

Clicca sul nuovo account di servizio
Vai a Chiavi scheda
Clicca Aggiungi chiave → Crea una nuova chiave
Scegli formato JSON Clicca
Crea Scaricherai un file JSON -
salva questo in modo sicuro ne avrai bisogno in seguitoClicca

Step 2.5: Concedi accesso in Console di Gioco

Vai a Console di Gioco di Google
Vai a Configurazione → API access
__CAPGO_KEEP_0__ accesso SottoConti di servizio , clicca Concedi accesso
per il tuo account di servizio di costruzione nativa di Google Play Console. Su Autorizzazioni dell'app tab, aggiungi la tua app
Nella sezione Autorizzazioni dell'account tab, concedi queste autorizzazioni:
- Visualizzare informazioni sull'app e scaricare rapporti in blocco (lettura solo)
- Creare, modificare e cancellare app in bozza
- Pubblica app in tracce di testing
- Pubblica app in produzione, escludi e altre tracce
Clicca Invita utente
Clicca Invia invito

Passo 2.6: Verifica la chiave JSON

Il file JSON scaricato dovrebbe avere questo aspetto:

{
  "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": "..."
}

Convertirai questo in base64 nel passo di configurazione dei segreti GitHub.

3. Imposta Fastlane

Crea una fastlane cartella nella radice del tuo progetto e aggiungi un Fastfile con il seguente contenuto:

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. Configura i segreti GitHub

Ora che hai il tuo keystore e il file JSON del servizio account, devi memorizzarli in modo sicuro in GitHub.

Passo 4.1: Accesso ai segreti GitHub

Vai al tuo repository su GitHub
Clicca Impostazioni → Segreti e variabili → Azioni
Clicca Crea un nuovo segreto di repository

Passo 4.2: Aggiungi i segreti richiesti

Aggiungi ogni segreto uno per uno:

PLAY_CONFIG_JSON

Prendi il file JSON del servizio account che hai scaricato nel Passo 2.4
Convertilo in base64:

Sui sistemi macOS/Linux:

base64 service_account_key.json | pbcopy

On Windows (PowerShell):

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

Crea un nuovo segreto denominato PLAY_CONFIG_JSON Incolla la stringa base64:

ANDROID_KEYSTORE_FILE

Converti il tuo keystore in base64:

On macOS/Linux:

base64 my-release-key.keystore | pbcopy

On Windows (PowerShell):

[Convert]::ToBase64String([IO.File]::ReadAllBytes("my-release-key.keystore")) | Set-Clipboard

Crea un nuovo segreto denominato ANDROID_KEYSTORE_FILE Incolla la stringa base64:

KEYSTORE_KEY_ALIAS

Crea un nuovo segreto con la chiave alias che hai utilizzato quando hai generato il keystore (ad esempio, my-key-alias)

KEYSTORE_KEY_PASSWORD

Creare un nuovo segreto con la chiave password impostata quando si genera la chiave di archiviazione

KEYSTORE_STORE_PASSWORD

Creare un nuovo segreto con la password della chiave di archiviazione impostata quando si genera la chiave di archiviazione

DEVELOPER_PACKAGE_NAME

Creare un nuovo segreto con il nome del pacchetto della tua app (ad esempio, com.example.app)

Puoi trovare il nome del pacchetto nella sezione android/app/build.gradle sotto applicationId

Passo 4.3: Verifica Tutti i Segreti

Assicurati di avere configurati questi 6 segreti:

✅ PLAY_CONFIG_JSON
✅ ANDROID_KEYSTORE_FILE
✅ KEYSTORE_KEY_ALIAS
✅ CHIAVE_DI_CRIPTAZIONE_DEL_KEYSTORE
✅ CHIAVE_DI_CRIPTAZIONE_DEL_STORE
✅ NOME_DEL_PACKAGE_DEVELOTTORE

5. Crea GitHub Flussi di lavoro di Azioni

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

Come Funziona

Creare
GitHub Actions builds your app
Creare un tag Git per attivare il flusso di lavoro
__CAPGO_KEEP_0__ Azioni costruisce il tuo'app

Fastlane lo carica sul canale beta di Google Play

La tua app viene aggiornata automaticamente
Costo per repository privati: ~$0,04 per build
Gratuito per progetti open-source

Guida alla configurazione CI/CD

Build automatico Capacitor per iOS con GitHub Actions - Configurazione completa di CI/CD per iOS
Build automatico e rilascio con GitHub Actions - Tutorial completo della pipeline CI/CD
Gestione dei build per Dev e Prod con GitHub Actions - Gestione degli ambienti

Alternative piattaforme CI/CD

Build con GitLab CI - Alternativa a GitLab per Android
Costruisci con CodeMagic - Guida di configurazione di CodeMagic

Aggiornamenti in tempo reale & distribuzione

Capgo Documentazione degli aggiornamenti in tempo reale - Aggiungi aggiornamenti OTA al tuo app
Integrazione CI/CD con Capgo - Integra gli aggiornamenti in tempo reale nel tuo pipeline

Risorse

Keep going from Automatic Capacitor Android build with GitHub actions

If sei stai utilizzando Automatic Capacitor build Android con GitHub azioni per pianificare l'automazione CI/CD, connettilo con Capgo CI/CD per il flusso di lavoro del prodotto in Capgo CI/CD, Capgo Build nativi per il flusso di lavoro del prodotto in Capgo Build nativi, Capgo Integrazioni per il flusso di lavoro del prodotto in Capgo Integrazioni, Integrazione CI/CD per il dettaglio di implementazione in Integrazione CI/CD, e GitHub Integrazione azioni per la dettagliata implementazione in GitHub Azioni di integrazione.