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 Costruzione

Ora raccomandiamo di utilizzare Capgo Costruzione con il Capgo CLI per le costruzioni native Capacitor. Questa guida Fastlane è mantenuta per le squadre che mantengono pipeline di azioni GitHub esistenti, ma i nuovi build Android dovrebbero utilizzare il Capgo CLI in modo da non dover mantenere Fastlane, i runner Gradle, le chiavi di sicurezza e i script di caricamento da soli.

Prerequisites

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 corrette
• Comprensione dei flussi di lavoro di GitHub Actions
• Conoscenza della configurazione di Fastlane
• Tempo per mantenere e debuggare la pipeline

Capgo Build per CI/CD da Capgo

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

• Funziona con il tuo pipelineTrasferisci Capgo Build dopo il tuo build web e da GitHub Actions, GitLab CI, Jenkins o script locali. npx cap sync.
• Firma da segreti CIMantieni le tue chiavi Android, alias chiave, password e JSON del servizio Console Play nel tuo proprio segreto CI.
• Nessuna manutenzione del runner nativoLa Capgo Build fornisce ambienti di costruzione Android mantenuti, quindi non devi gestire SDK immagini, problemi di cache Gradle o percorsi Fastlane.
• Articoli e sottoscrizione: Scarica gli articoli firmati per le QA o sottoscrivi i rilasci attraverso il Capgo CLI.

Prezzi

• Capgo piani iniziano a $12/mese
• Includono aggiornamenti OTA e circa 15 build nativi al mese
• Minuti aggiuntivi per build sono fatturati per minuto attraverso crediti

Imposta la costruzione Capgo in CI/CD

Configura __CAPGO_KEEP_0__ Build in CI/CD

Guida di configurazione manuale

GitHub Azioni Prezzi

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

• Raccolta pubblica: 2.000 minuti al mese
• Raccolta privata: 2.000 minuti al mese (esecutori Linux)

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

Passaggi di configurazione manuale

1. Creare Keystore Android
2. Configurare account servizio Google Play
3. Configurare Fastlane
4. Configurare segreti GitHub
5. Creare workflow GitHub Actions

1. Creare Keystore Android

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

Generare 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 chiave: Scegli una password forte (avrai bisogno di questa come KEYSTORE_KEY_PASSWORD)
• Il tuo nome, l'organizzazione, ecc.: Compila i tuoi dati

Nota importante

• Salva questi valori in modo sicuro:

  • Posizione del file Keystore (ad esempio, my-release-key.keystore)
  • Alias chiave (ad esempio, my-key-alias) - avrai bisogno di questa come KEYSTORE_KEY_ALIAS
  • Password Keystore - avrai bisogno di questa come KEYSTORE_STORE_PASSWORD
  • Password chiave - avrai bisogno di questa come KEYSTORE_KEY_PASSWORD

• Salva il file del keystore: Se lo perdi, non potrai aggiornare il tuo app pubblicato

• Mantienilo segreto: Non commettere mai il file del keystore a git

• Conservalo in sicurezza: Conserva più copie in luoghi sicuri

Alternativa: Utilizza Esistente Keystore

: Se 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
• Nella tua console di Play → Impostazioni → App firmata (se utilizzi la firma di Google Play App)

2. Configura il Servizio Account di Google Play

Per consentire agli GitHub Actions di caricare le build su Google Play, è necessario un account di servizio.

Passo 2.1: Crea Progetto Google Cloud

1. Vai a Pannello di controllo di Google Cloud
2. Crea un nuovo progetto o seleziona uno esistente
3. Nota l'ID del progetto

Step 2.2: Enable Google Play Developer API

1. In Pannello di controllo di Google Cloud, vai a APIs & Servizi → Libreria
2. Cerca "Google Play Android Developer API"
3. Clicca Abilita

Passo 2.3: Crea account di servizio

1. Vai a IAM & Amministrazione → Account di servizio
2. Clicca Crea account di servizio
3. Inserisci dettagli:
   • Nome: github-actions-uploader
   • Descrizione: "Account di servizio per GitHub azioni per caricare i build"
4. Clicca Crea e continua
5. Saltare l'assegnazione del ruolo per ora (clicca Continua, quindi Fatto)

Passo 2.4: Crea chiave account servizio

1. Clicca sul nuovo account di servizio creato
2. Vai a Vai a Chiavi
3. tab Clicca → Aggiungi chiave
4. Choose JSON formato
5. Clicca Crea
6. Un file JSON scaricherà - salva questo in modo sicuropoi lo utilizzerai

Passo 2.5: Concedi accesso in Console Play

1. Clicca su Console di Gioco Play
2. Clicca su Configura → API accesso
3. Sotto Conti account, clicca Concedi l'accesso per il tuo account del servizio
4. Sul pannello Permessi dell'app aggiungi la tua app
5. Sul pannello Permessi dell'account aggiungi questi permessi:
   • Visualizza informazioni sull'app e scarica rapporti in bulk (solo lettura)
   • Creare, modificare e eliminare app di bozza
   • Pubblica app in tracce di testing
   • Pubblica app in produzione, escludi e altre tracce
6. Clicca Invita utente
7. Clicca Invia invito

Passo 2.6: Verifica la chiave JSON

La file JSON scaricata 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. Configura Fastlane

Creare un fastlane cartella nella radice del tuo progetto e aggiungere 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 GitHub Segreti

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 GitHub Segreti

1. Vai al tuo repository su GitHub
2. Clicca Impostazioni → Segreti e variabili → Azioni
3. Clicca Nuovo segreto repository

Passo 4.2: Aggiungi i segreti richiesti

Aggiungi ogni segreto uno per uno:

Aggiungi ogni segreto uno per uno:

1. Prendere il file JSON del servizio account scaricato nel passo 2.4.
2. Converti in base64:

Convertilo in base64:

base64 service_account_key.json | pbcopy

Su Windows (PowerShell):

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

3. Sul Windows (PowerShell): PLAY_CONFIG_JSON Crea un nuovo segreto denominato

incolla la stringa base64

1. Converti il tuo keystore in base64:

Su macOS/Linux:

base64 my-release-key.keystore | pbcopy

Su Windows (PowerShell):

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

2. Crea un nuovo segreto denominato ANDROID_KEYSTORE_FILE Incolla la stringa base64

Alias della chiave del keystore

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

Parola di chiave del keystore

Crea un nuovo segreto con la password della chiave che hai impostato quando hai generato il keystore

Parola_di_chiusura_della_keystore

Crea un nuovo segreto con la password del keystore che hai impostato quando hai generato il keystore

DEVELOPER_PACKAGE_NAME

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

Puoi trovare il nome del tuo pacchetto in android/app/build.gradle sotto applicationId

Passo 4.3: Verifica Tutti i Segreti

Assicurati di avere configurati questi 6 segreti:

• ✅ Configurazione JSON
• ✅ File keystore Android
• ✅ Alias chiave keystore
• ✅ Password della chiave del keystore
• ✅ Password del keystore
• ✅ Pacchetto di sviluppatore

5. Crea Flussi di Azioni GitHub

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

1. Crea un tag Git per attivare il workflow
2. GitHub Azioni costruisce il tuo app
3. Fastlane lo carica sul canale beta di Google Play
4. La tua app viene aggiornata automaticamente

Tempo e Costi di Costruzione

• Tempo di costruzione: 3-5 minuti
• Costo per repository privati: ~$0,04 per costruzione
• Gratuito per progetti open-source

Articoli correlati

Guida di configurazione CI/CD

• Automatico Capacitor costruzione iOS con GitHub Azioni - Configurazione CI/CD completa per iOS
• Costruzione automatica e rilascio con azioni GitHub - Tutorial completo della pipeline CI/CD
• Gestione dei costruzioni Dev e Prod con azioni GitHub - Gestione delle ambientazioni

Alternative piattaforme CI/CD

• Costruzione con GitLab CI - Alternativa di GitLab per Android
• Costruzione con CodeMagic - Guida di configurazione di CodeMagic

Aggiornamenti in tempo reale & distribuzione

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

Risorse

• Documentazione GitHub Azioni
• Documentazione Fastlane

Continua da Automatic Capacitor Android build con GitHub azioni

Se stai utilizzando Automatic Capacitor Android build with GitHub actions per pianificare l'automazione CI/CD, connettilo con Capgo CI/CD per il flusso di lavoro del prodotto in Capgo CI/CD, Capgo Costruzioni native per il flusso di lavoro del prodotto in Capgo Costruzioni native Capgo Integrazioni per il flusso di lavoro del prodotto in Capgo Integrazioni Integrazione CI/CD per la dettaglio di implementazione in Integrazione CI/CD, e GitHub Integrazione azioni per la dettaglio di implementazione in GitHub Integrazione azioni