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
- Copia i file Fastlane
- Conservare i segreti in GitLab encrypted secrets
- Creare e conservare la chiave del service account di Google Play
- Conservare la chiave di firma Android
- 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.
- Vai nelle Settings del tuo progetto GitLab.
- Vai su CI/CD > Variables
- Aggiungi le seguenti variabili:
- ANDROID_KEYSTORE_FILE: il file in formato
.jksoppure.keystorebase64 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:
- Vai a Google Cloud Console
- Crea un nuovo progetto o seleziona uno esistente
- Abilita l'API di Google Play Android Developer
- 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”
- 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”
- 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”
- Converti la chiave JSON in base64:
base64 -i path/to/your/service-account-key.json | pbcopy - Aggiungi la stringa codificata in base64 come
PLAY_CONFIG_JSONvariabile 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.