Salta al contenuto principale
CI/CD

Build Android Capacitor automatica con GitLab

Come configurare una pipeline CI/CD per la tua app Android Ionic usando fastlane e GitLab in 5 minuti

Build Android automatico di Capacitor con GitLab Capgo illustrazione del blog

Build Android automatiche con GitLab CI

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

Prerequisiti

Prima di iniziare, dovrai configurare:

  • Un account GitLab con accesso admin
  • La tua app già pubblicata su Google Play Store con firma corretta
  • Chiave di firma Android e file keystore
  • Progetto Google Cloud Console con API di Play Store abilitato
  • Account di servizio con i permessi appropriati
  • Conoscenza dei workflow GitLab CI/CD
  • Conoscenza della configurazione di Fastlane
  • Tempo per mantenere e fare debug della pipeline

Capgo Build per CI/CD con Capgo

Dimentica la manutenzione di Fastlane, Gradle runner, keystore e script di upload. Build Capgo esegue build native Android firmate direttamente dalla tua pipeline CI/CD:

  • Si integra con la tua pipeline: Avvia la build Capgo da GitLab CI, GitHub Actions, Jenkins o script locali dopo la build web e npx cap sync.
  • Firma tramite segreti CI: Mantieni i keystore Android, alias, password e il JSON del service account di Play Console nei tuoi segreti CI.
  • Nessuna gestione runner native: Capgo Build offre ambienti di build Android pronti all'uso, così non dovrai gestire immagini SDK, problemi di cache Gradle o lane di Fastlane.
  • Artifacts e submission: Scarica gli artifact firmati per la QA o invia le release build tramite Capgo CLI.

Prezzi

  • I piani Capgo partono da $12/mese
  • Include aggiornamenti OTA e circa 15 Native Build al mese
  • I minuti extra di build sono fatturati al minuto tramite crediti

Configura Capgo Build in CI/CD

Guida alla configurazione manuale

Ecco cosa devi fare:

Passaggi descritti nel post

  1. Copia i file Fastlane
  2. Conservare i segreti in GitLab encrypted secrets
  3. Creare e conservare la chiave del service account di Google Play
  4. Conservare la chiave di firma Android
  5. Configurare il file .yml del workflow GitLab

1. Copia i file Fastlane

Fastlane è una libreria Ruby creata per automatizzare i comuni task di sviluppo mobile. Con Fastlane puoi configurare "lane" personalizzate che raggruppano una serie di "action" per eseguire operazioni che normalmente faresti su Android Studio. Puoi fare moltissimo con Fastlane, ma per questo tutorial useremo solo alcune action fondamentali.

Crea una cartella Fastlane nella radice del progetto e copia i seguenti file: Fastlane

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'])
				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}")
        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(
					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
    lane :build do
      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}",
        })
    end
    lane :prod_release do
      build_gradle = File.read("../android/app/build.gradle")

      verify_changelog_exists(version_code: build_gradle.match(/versionCode (\d+)/)[1])
      verify_upload_to_staging(version_name: build_gradle.match(/versionName '([\d\.]+)'/)[1])

      supply(
        track_promote_to: 'beta',
        skip_upload_apk: true,
        skip_upload_aab: true,
        skip_upload_metadata: false,
        skip_upload_changelogs: false,
        skip_upload_images: false,
        skip_upload_screenshots: false
      )
    end
end

Come salvare i tuoi secret nelle variabili GitLab CI/CD

GitLab permette di memorizzare variabili CI/CD criptate, in modo simile ai repository secrets di GitHub, per proteggere le tue informazioni sensibili.

  1. Vai nelle Settings del tuo progetto GitLab.
  2. Vai su CI/CD > Variables
  3. Aggiungi le seguenti variabili:
  • ANDROID_KEYSTORE_FILE: il file in formato .jks oppure .keystore base64 utilizzato per firmare i tuoi build Android. Sarà il file keystore associato alla tua upload key (se usi Play App Signing) o la tua app signing key.
  • KEYSTORE_KEY_PASSWORD: la password associata al file keystore
  • KEYSTORE_KEY_ALIAS: l'alias del keystore
  • KEYSTORE_STORE_PASSWORD: la password della chiave privata
  • DEVELOPER_PACKAGE_NAME: l'ID della tua app Android, es. com.example.app
  • PLAY_CONFIG_JSON: la chiave JSON dell'account di servizio codificata in base64.

Creazione di una chiave dell'account di servizio di Google Play

Per generare la PLAY_CONFIG_JSON segreta, segui questi passaggi:

  1. Vai a Google Cloud Console
  2. Crea un nuovo progetto o seleziona uno esistente
  3. Abilita l'API di Google Play Android Developer
  4. Crea un account di servizio:
    • Vai su “IAM & Admin” > “Service Accounts”
    • Clicca su “Create Service Account”
    • Dagli un nome e una descrizione
    • Clicca su “Create and Continue”
    • Salta l'assegnazione dei ruoli e clicca su “Done”
  5. Genera una chiave JSON:
    • Trova il tuo service account nell'elenco
    • Clicca sul menu dei tre puntini > “Manage keys”
    • Clicca su “Add Key” > “Create new key”
    • Scegli il formato JSON
    • Clicca su “Create”
  6. Concedi al service account l'accesso alla tua app nella Play Console:
    • Vai su Play Console
    • Vai su “Utenti e permessi”
    • Clicca su “Invita nuovi utenti”
    • Inserisci l'email dell'account di servizio (termina con @*.iam.gserviceaccount.com)
    • Concedi il permesso “Release to production”
    • Clicca su “Invita utente”
  7. Converti la chiave JSON in base64:
    base64 -i path/to/your/service-account-key.json | pbcopy
  8. Aggiungi la stringa codificata in base64 come PLAY_CONFIG_JSON variabile in GitLab

Configura la pipeline CI/CD di GitLab

Crea un file .gitlab-ci.yml nella radice del progetto per definire la pipeline CI/CD. Di seguito un esempio di come strutturare la pipeline:


image: mingc/android-build-box:latest

stages:
  - build
  - upload_to_capgo
  - build_and_upload_android

build:
  stage: build
  tags:
    - saas-linux-xlarge-amd64
  cache:
    - key:
        files:
          - bun.lockb
      paths:
        - .node_modules/
  script:
    - npm install
    - npm run build
  artifacts:
    paths:
      - node_modules/
      - dist/
  only:
    - master

upload_to_capgo:
  stage: upload_to_capgo
  tags:
    - saas-linux-xlarge-amd64
  script:
    - npx @capgo/cli@latest bundle upload -a $CAPGO_TOKEN -c dev
  dependencies:
    - build
  when: manual
  only:
    - master

build_and_upload_android:
  tags:
    - saas-linux-xlarge-amd64
  stage:    build_and_upload_android
  cache:
    - key:
        files:
          - android/gradle/wrapper/gradle-wrapper.properties
      paths:
        - ~/.gradle/caches/
  script:
    - npx cap sync android
    - npx cap copy android
    - bundle exec fastlane android beta # We do create a tag for the build to trigger XCode cloud builds
  dependencies:
    - build
  when: manual
  only:
    - master

Avvia la pipeline

Ogni volta che pushi un nuovo tag nel tuo repository GitLab, GitLab CI/CD avvierà automaticamente la pipeline definita, che compilerà e distribuirà la tua app Android utilizzando Fastlane.

Assicurati di adattare i percorsi e le dipendenze in base alla struttura e ai requisiti del tuo progetto. Questa configurazione ti aiuterà ad automatizzare la distribuzione della tua app Android su GitLab CI/CD.

Conclusione

Configurando GitLab CI/CD con l'immagine Docker mingc/android-build-box, puoi automatizzare il processo di build dell'app Android, rendendo il tuo flusso di lavoro di sviluppo più efficiente e affidabile. Questa automazione ti libera tempo per concentrarti sugli aspetti fondamentali dello sviluppo dell'app, aiutandoti a consegnare app Android di alta qualità in modo più efficiente.

Continua con la build Android automatica Capacitor con GitLab

Se stai usando Build Android Capacitor automatica con GitLab per pianificare l'automazione CI/CD e connetterla a CI/CD con Capgo per il workflow del prodotto in Capgo CI/CD, Capgo Native Build per il workflow di prodotto in Capgo Native Builds, Integrazioni Capgo per il workflow di prodotto in Integrazioni Capgo, Integrazione CI/CD per i dettagli implementativi in CI/CD Integration, e Integrazione GitHub Actions per i dettagli implementativi in GitHub Actions Integration.

Live updates per le app Capacitor

Quando un bug nel web-layer è live, rilascia la fix tramite Capgo invece di aspettare giorni l'approvazione degli store. Gli utenti ricevono l'update in background, mentre le modifiche native restano nel normale processo di review.

Ultimi articoli dal blog

Capgo ti offre gli insight migliori che ti servono per creare un'app mobile davvero professionale.