Costruzioni di build Android con GitLab CI

Setting up CI/CD for Capacitor apps can be complex and time-consuming. Here’s what you need to know:

Prerequisiti

Prima di iniziare, dovrai configurare:

Un account di GitLab con accesso amministrativo
L'app già pubblicata su Google Play Store con firma corretta
Chiavi di firma Android e file di keystore
Progetto Google Cloud Console con Play Store API abilitato
Account di servizio con permessi adeguati
Comprensione dei flussi di lavoro di GitLab CI/CD
Conoscenza della configurazione di Fastlane
Tempo per mantenere e debuggare il pipeline

Capgo Costruisci per CI/CD da Capgo

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

Funziona con il tuo pipeline: Trascina Capgo Costruisci da GitLab CI, GitHub Actions, Jenkins o script locali dopo la tua costruzione web e npx cap sync.
Autenticazione dai segreti CI: Conserva le chiavi di sicurezza Android, gli alias delle chiavi, le password e il file JSON del servizio account di Console Play nei tuoi segreti CI.
Non gestire il runner nativo: Capgo Build fornisce ambienti di costruzione Android mantenuti, quindi non devi gestire SDK immagini, problemi di cache Gradle o tratte di Fastlane.
Articoli e sottoscrizione: Scarica gli articoli firmati per la QA o sottoscrivi i rilasci attraverso il Capgo CLI.

Prenotazioni

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

Configura Capgo Build in CI/CD

Guida di configurazione manuale

Ecco cosa devi fare:

Etappe da seguire nel post

Copia i file Fastlane
Memorizza i tuoi segreti nei segreti GitLab crittografati
Creazione e memorizzazione della chiave del servizio Google Play
Memorizza la tua chiave di firma Android
Configura il tuo file di workflow GitLab .yml

1. Copia i file Fastlane

Fastlane è una libreria Ruby creata per automatizzare le attività di sviluppo mobile comuni. Utilizzando Fastlane, puoi configurare percorsi personalizzati "lanes" che raggruppano una serie di "azioni" che eseguono compiti che normalmente eseguiresti utilizzando Android Studio. Con Fastlane puoi fare molto, ma per i fini di questo tutorial, utilizzeremo solo una manciata di azioni di base.

Creare una cartella Fastlane alla radice del tuo 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

Memorizza i tuoi segreti nelle variabili CI/CD di GitLab

GitLab fornisce un modo per memorizzare le variabili CI/CD crittografate, simile ai segreti del repository di GitHub . Per memorizzare le tue informazioni sensibili in modo sicuro.

Vai alle impostazioni del tuo progetto di GitLab.
Naviga a CI/CD > Variabili
Aggiungi le seguenti variabili:

ANDROID_KEYSTORE_FILE: il file base64 codificato .jks o .keystore utilizzato per firmare le tue build Android. Questo sarà il file keystore associato alla tua chiave di caricamento (se si utilizza la firma di App Play), o la tua chiave di firma dell'app.
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: il tuo ID di app Android come ad esempio com.example.app
PLAY_CONFIG_JSON: La chiave JSON del servizio Google Play base64 codificata.

Creazione di una chiave del servizio Google Play

To generare il PLAY_CONFIG_JSON segreto, segui questi passaggi:

Vai al Console di Google Cloud
Crea un nuovo progetto o seleziona uno esistente
Abilita il Google Play Android Developer API
Crea un account di servizio:
- Vai a “IAM & Amministrazione” > “Conti di servizio”
- Clicca su “Crea Conto di Servizio”
- Dagli un nome e una descrizione
- Clicca su “Crea e Continua”
- Ssaltare l'assegnazione del ruolo e clicca su “Fatto”
Genera una chiave JSON:
- Trovare il tuo account di servizio nella lista
- Clicca sul menu a tre punti > “Gestisci chiavi”
- Clicca su “Aggiungi Chiave” > “Crea nuova chiave”
- Scegli formato JSON
- Clicca su “Crea”
Concedi all'account di servizio l'accesso all'app nel Console di gioco:
- Vai a Console di gioco
- Naviga a “Utenti e autorizzazioni”
- Clicca su “Invita nuovi utenti”
- Inserisci l'indirizzo email dell'account di servizio (che termina con @*.iam.gserviceaccount.com)
- Concedi il permesso di rilascio in produzione
- Clicca su 'Invita l'utente'

Converti la chiave JSON in base64:

base64 -i path/to/your/service-account-key.json | pbcopy

Inserisci la stringa base64 codificata come PLAY_CONFIG_JSON variabile in GitLab

Configura la tua pipeline CI/CD di GitLab

Configura la tua pipeline CI/CD di GitLab. Per farlo, crea un file .gitlab-ci.yml nella radice del tuo progetto e definisci la tua pipeline. Ecco un esempio di come potresti strutturare la tua 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

Quando pubblichi un nuovo tag nel tuo repository di GitLab, la pipeline CI/CD di GitLab si attiverà automaticamente, costruendo e distribuendo la tua app Android utilizzando Fastlane.

Assicurati di adattare le percorso e le dipendenze in base alla struttura e alle esigenze del tuo progetto. Questa configurazione ti aiuterà a automatizzare la distribuzione della tua app Android su GitLab CI/CD.

Conclusioni

Configurando la pipeline CI/CD di GitLab con l'immagine Docker mingc/android-build-box, puoi automatizzare il processo di costruzione dell'app Android, rendendo il tuo workflow di sviluppo più efficiente e affidabile. Questa automazione ti consente di liberare il tuo tempo per concentrarti sui punti chiave dello sviluppo di app, aiutandoti a consegnare app Android di alta qualità in modo più efficiente.

Continua con la costruzione automatica di Android con GitLab Capacitor

Se stai utilizzando La costruzione automatica di Android con GitLab Capacitor 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 il dettaglio di implementazione in Integrazione CI/CD, e Azioni di integrazione di GitHub per i dettagli di implementazione in Azioni di integrazione di GitHub

Automatic Capacitor Android build with GitLab