Build Android automatici 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 permessi di admin
La tua app già pubblicata su Google Play Store e firmata correttamente
Chiave di firma Android e file keystore
Progetto Google Cloud Console con API di Play Store abilitato
Service account con i permessi corretti
Conoscenza dei workflow GitLab CI/CD
Conoscenza della configurazione Fastlane
Tempo per la manutenzione e il debug della pipeline

Capgo Build per CI/CD di Capgo

Dimentica la manutenzione di Fastlane, Gradle runner, keystore e script di upload. Build con Capgo esegue Native Build Android firmati dalla tua pipeline CI/CD esistente:

Compatibile con la tua pipeline: Avvia Capgo Build da GitLab CI, GitHub Actions, Jenkins o script locali dopo il web build e npx cap sync.
Firma tramite segreti CI: Mantieni keystore Android, alias, password e il JSON del service account di Play Console nei tuoi segreti CI.
Nessuna manutenzione runner nativi: Capgo Build offre ambienti Android gestiti, così non dovrai gestire immagini SDK, problemi di cache Gradle o lane Fastlane.
Artifacts and submission: Scarica gli artifact firmati per la QA o invia i 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 di build extra sono fatturati al minuto tramite crediti

Configura Capgo Build in CI/CD

Guida alla configurazione manuale

Ecco cosa devi fare:

Passaggi da seguire nel post

Copia i file Fastlane
Salva i tuoi segreti negli encrypted secrets di GitLab
Crea e salva la chiave del service account di Google Play
Salva la tua Android signing key
Configura il file workflow .yml di 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” che eseguono operazioni che normalmente faresti con Android Studio. Puoi fare moltissimo con Fastlane, ma per questo tutorial useremo solo poche action fondamentali.

Crea una cartella Fastlane nella root 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 impostazioni del tuo progetto GitLab.
Vai su CI/CD > Variables
Aggiungi le seguenti variabili:

ANDROID_KEYSTORE_FILE: il file in formato .jks o .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: Il JSON della chiave del service account codificato in base64.

Creazione di una chiave del service account di Google Play

Per generare il PLAY_CONFIG_JSON secret, segui questi passaggi:

Vai su Google Cloud Console
Crea un nuovo progetto o selezionane uno esistente
Abilita l'API Google Play Android Developer
Crea un service account:
- Vai su “IAM & Admin” > “Service Accounts”
- Clicca su “Create Service Account”
- Assegna un nome e una descrizione
- Clicca su “Create and Continue”
- Salta l'assegnazione del ruolo e clicca su “Done”
Genera una chiave JSON:
- Trova il tuo service account nell'elenco
- Clicca sul menu con i 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 “Users and permissions”
- Clicca su “Invite new users”
- Inserisci l'email del service account (termina con @*.iam.gserviceaccount.com)
- Assegna il permesso “Release to production”
- Clicca su “Invite user”

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_JSON variabile in GitLab

Configura la tua pipeline GitLab CI/CD

Crea un file .gitlab-ci.yml nella root del progetto per definire la pipeline CI/CD. Ecco un esempio di come strutturarla:


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 farai il push di un nuovo tag sul repository GitLab, GitLab CI/CD avvierà automaticamente la pipeline definita, che build e deployerà la tua app Android tramite Fastlane.

Assicurati di adattare i path e le dipendenze alla struttura e ai requisiti del tuo progetto. Questo setup ti aiuterà ad automatizzare il deployment 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 delle app Android, rendendo il tuo workflow di sviluppo più efficiente e affidabile. Questa automazione ti permette di concentrarti sugli aspetti core dello sviluppo, aiutandoti a rilasciare app Android di alta qualità in modo più rapido.

Continua con la build Android automatica di Capacitor con GitLab

Se stai usando Build Android automatica di Capacitor con GitLab per pianificare l'automazione CI/CD, connettilo a CI/CD di Capgo per il workflow di 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 Capgo Integrazioni, Integrazione CI/CD per i dettagli implementativi dell'integrazione CI/CD, e Integrazione GitHub Actions per i dettagli implementativi dell'integrazione con GitHub Actions.