Costruzione automatica di Capacitor Android con GitHub azioni

La configurazione della CI/CD per le Capacitor app può essere complessa e richiede molto tempo. Ecco cosa devi sapere:

Consigliato per Nuove Costruzioni: Utilizza Capgo Costruzione

Ora raccomandiamo l'uso di Capgo Costruzione con il Capgo CLI per le costruzioni native Capacitor. Questa guida di 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, esegutori Gradle, keystore e script di caricamento.

Requisiti

Prima di iniziare, avrai bisogno di configurare:

• A GitHub account con accesso amministrativo
• La tua app è già pubblicata su Google Play Store con firma corretta
• Chiave di firma Android e file del keystore
• Progetto di Google Cloud Console con Play Store API 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 il pipeline

Capgo Build per CI/CD da Capgo

Saltare la manutenzione di Fastlane, Gradle runner, keystore e upload-script. Capgo Build esegue build native Android firmate da un pipeline CI/CD esistente:

• Funziona con il tuo pipeline: Attiva Capgo Build da GitHub Actions, GitLab CI, Jenkins o script locali dopo la tua build web e npx cap sync.
• Autenticazione da segreti CI: Mantieni le chiavi Android, gli alias delle chiavi, le password e il file JSON del servizio account Play Console nei tuoi segreti CI.
• Assenza di manutenzione del runner nativo: Capgo Build fornisce ambienti di build Android mantenuti, quindi non devi gestire SDK immagini, problemi di cache Gradle o Fastlane lanes.
• Articoli e sottoscrizione: Scarica gli articoli firmati per la QA o sottoscrivi le release attraverso il Capgo CLI.

Prenotazione

• I piani Capgo iniziano a $12/mese
• Includono aggiornamenti OTA e circa 15 build native al mese
• I minuti di build extra sono fatturati per minuto attraverso crediti

Configura Capgo Costruzione in CI/CD

Guida di configurazione manuale

Ecco cosa devi fare:

GitHub Azioni Prezzi

GitHub Azioni 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 progetti privati, i costi sono di circa $0,008/minuto. Una costruzione tipica richiede 3-5 minuti.

Passaggi di configurazione manuale

1. Crea Keystore Android
2. Configura account di servizio Google Play
3. Configura Fastlane
4. Configura segreti GitHub
5. Crea workflow GitHub Actions

1. Crea Keystore Android

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

Genera Keystore con keytool

Eseguisci 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)
• Il tuo nome, l'organizzazione, ecc.: Inserisci i tuoi dati

Nota importante

• 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

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

• Tienilo segreto: Mai commetti il file del keystore in git

• Conservalo in un luogo sicuro: Conserva più copie di backup 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:

• Sul tuo computer locale dove hai costruito l'app per la prima volta
• Nella tua Console di Play → Impostazioni → Firma dell'app (se utilizi la firma dell'app di Google Play)

2. Configura Servizio Account di Google Play

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

Passo 2.1: Crea Progetto di Google Cloud

1. Vai a Console di Google Cloud
2. Creare un nuovo progetto o selezionare uno esistente
3. Nota l'ID del progetto

Passo 2.2: Abilita il Google Play Developer API

1. In Google Cloud Console, 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 → Accounti di servizio
2. Click Crea Account di Servizio
3. Inserisci dettagli:
   • Nome: github-actions-uploader
   • Descrizione: “Account di servizio per GitHub Azioni per caricare build”
4. Click Crea e Continua
5. Saltare l'assegnazione del ruolo per ora (click Continua, poi Completato)

Passo 2.4: Crea Chiave di Servizio

1. Clicca sul servizio account appena creato
2. Vai a Chiavi tab
3. Clicca Aggiungi Chiave → Crea nuova chiave
4. Scegli Formato JSON Clicca
5. __CAPGO_KEEP_0__ Creare
6. Un file JSON scaricherà - salva questo in modo sicuro, avrai bisogno di esso in seguito

Passo 2.5: Concedi accesso in Console Play

1. Vai a Console di Gioco Play
2. Vai a Configurazione → API accesso
3. Sotto Conti di servizioClicca qui Concedi accesso per il tuo account di servizio
4. Sul pannello Permessi dell'app aggiungi il tuo app
5. Sul pannello Permessi dell'account concedi questi permessi:
   • Visualizza informazioni sull'app e scarica rapporti in bulk (solo lettura)
   • Crea, modifica e elimina app di bozza
   • Pubblica app nei percorsi di testing
   • Rilascia app in produzione, escludi, e altri tracciati
6. Clicca Invita l'utente
7. Clicca Inviare 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. Configura Fastlane

Crea un fastlane cartella nella radice del tuo progetto e aggiungi un Fastfile con questo 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 GitHub Segreti

Ora che hai il tuo keystore e il file JSON del servizio account, hai bisogno di archiviarli in modo sicuro in GitHub.

Passo 4.1: Accesso a GitHub Segreti

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

Passo 4.2: Aggiungi i segreti richiesti

Aggiungi ogni segreto uno per uno:

PLAY_CONFIG_JSON

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

Sui sistemi macOS/Linux:

base64 service_account_key.json | pbcopy

Sui sistemi Windows (PowerShell):

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

3. Crea un nuovo segreto denominato PLAY_CONFIG_JSON incolla la stringa base64

ANDROID_KEYSTORE_FILE

1. Converti il tuo keystore in base64:

Sui sistemi macOS/Linux:

base64 my-release-key.keystore | pbcopy

Sui sistemi 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 KEYSSTORE

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

PASSWORD DELLA CHIAVE DEL KEYSSTORE

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

PASSWORD DEL KEYSSTORE

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

NOME DELLA PACKAGE DELLO SVILUPPATORE

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

Puoi trovare il nome della package in android/app/build.gradle sotto applicationId

Passaggio 4.3: Verifica Tutti i Segreti

Assicurati di avere configurati questi 6 segreti:

• ✅ PLAY_CONFIG_JSON
• ✅ FILE DEL KEYSSTORE DI ANDROID
• ✅ ALIAS DELLA CHIAVE DEL KEYSSTORE
• ✅ PAROLA DI CHIAVE DEL KEYSSTORE
• ✅ PAROLA DI ACCESSO DEL KEYSSTORE
• ✅ NOME DELLA PACKAGE DELLO SVILUPPATORE

5. Crea GitHub Workflow di azioni

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. Carica Fastlane sul canale beta di Google Play
4. La tua app viene aggiornata automaticamente

Tempo di costruzione e costi

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

Articoli correlati

Guida alla configurazione CI/CD

• Costruzione automatica di iOS con Capacitor e GitHub - Configurazione completa di CI/CD per iOS
• Costruzione e rilascio automatico con GitHub - Tutorial completo della pipeline CI/CD
• Gestisci Costruzioni Dev e Prod con GitHub Azioni - Gestione dell'ambiente

Alternative piattaforme CI/CD

• Costruisci con GitLab CI - Guida di configurazione di 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

• GitHub Azioni Documentazione
• Documentazione Fastlane

Continua con l'Capacitor costruzione Android automatica con GitHub azioni

Se stai utilizzando L'Capacitor costruzione Android automatica 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 Costruzioni native per il flusso di lavoro del prodotto in Capgo Costruzioni native, Capgo Integrazioni For il flusso di lavoro del prodotto in Capgo Integrations, Integrazione CI/CD For il dettaglio di implementazione in Integrazione CI/CD, e GitHub Azioni di integrazione For il dettaglio di implementazione in GitHub Azioni di integrazione.