Costruzioni Android automatiche con GitLab CI

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

Prerequisiti

Prima di iniziare, dovrai configurare:

Un account GitLab con accesso amministrativo
L'app già pubblicata su Google Play Store con firma corretta
Chiave di firma Android e file del keystore
Progetto Google Cloud Console con Play Store API abilitato
Account di servizio con autorizzazioni corrette
Capacitor Android Build su GitLab
Conoscenza delle configurazioni di Fastlane
Tempo per mantenere e debuggare il flusso di lavoro

Capgo Costruisci per il CI/CD con Capgo

Evita la manutenzione di Fastlane, Gradle runner, keystore e upload-script. Capgo Costruisci Esegue costruzioni native Android firmate a partire dalla tua pipeline CI/CD esistente:

Funziona con il tuo flusso di lavoro: Avvia Capgo Build da GitLab CI, GitHub Actions, Jenkins o script locali dopo la tua build web e npx cap sync.
Autenticazione tramite segreti CIMantieni le tue chiavi Android, alias chiave, password e JSON del servizio Console Play nel tuo proprio segreto CI.
Manutenzione del runner nativo: Capgo Build fornisce ambienti di costruzione Android mantenuti, quindi non dovete gestire SDK immagini, problemi di cache Gradle o Fastlane lanes.
Articoli e sottoscrizione: Scarica gli artefatti firmati per la QA o invia release builds attraverso il Capgo CLI.

Prenotazione

I piani di Capgo iniziano a $12/mese
Le piani di __CAPGO_KEEP_0__ iniziano a $12/mese
Includono aggiornamenti OTA e circa 15 build nativi al mese

Imposta il build Capgo in CI/CD

Guida di Configurazione Manuale

Configura __CAPGO_KEEP_0__ Build in CI/CD

Guida di configurazione manuale

Ecco cosa dovete fare:
Memorizza i tuoi segreti in GitLab encrypted secrets
Creazione e memorizzazione della chiave di servizio Google Play
Memorizza la tua chiave di firma Android
Configura il tuo file di workflow .yml di GitLab

1. Copia i file Fastlane

Fastlane è una libreria Ruby creata per automatizzare le attività comuni di sviluppo mobile. 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 fondamentali.

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 in variabili CI/CD di GitLab

GitLab offre una possibilità di archiviare variabili CI/CD crittografate, simile a GitHub's segreti del repository. Per archiviare le informazioni sensibili in modo sicuro.

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

ANDROID_KEYSTORE_FILE: il file keystore base64 codificato .jks o .keystore file used to sign your Android builds. This will either be the keystore file associated with your upload key (if using Play App Signing), or your app signing key.
PASSWORD_CHIAVE_KEystore: la password associata al file del keystore
KEYSTORE_KEY_ALIAS: l'alias del keystore
KEYSTORE_KEY_ALIAS: l'alias del keystore
KEYSTORE_STORE_PASSWORD: la password della chiave privata
PLAY_CONFIG_JSON: La chiave JSON del servizio account codificata in base64.

Creazione di una chiave di account Google Play Service

Generare il PLAY_CONFIG_JSON seguite questi passaggi

Vai al Google Cloud Console
Creare un nuovo progetto o selezionare uno esistente
Abilita il Google Play Android Developer API
Creare un account di servizio:
- Vai a “IAM & Admin” > “Service Accounts”
- Clicca su “Create Service Account”
- Dai 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 account di servizio nella lista
- Clicca sul menu a tre punti > “Manage keys”
- Clicca su "Aggiungi chiave" > "Crea nuova chiave"
- Scegli formato JSON
- Clicca su "Crea"
Concedi al servizio account l'accesso all'applicazione nel Console di gioco:
- Vai a Console di gioco
- Naviga a "Utenti e autorizzazioni"
- Clicca su "Invita nuovi utenti"
- Inserisci l'indirizzo email del servizio account (che termina con @*.iam.gserviceaccount.com)
- Concedi la "Concessione alla produzione"
- Clicca su "Invita utente"

Converti la chiave JSON in base64:

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

Aggiungi la stringa base64 codificata come PLAY_CONFIG_JSON variabile in GitLab

Configura il tuo flusso di lavoro CI/CD su GitLab

Creare un file .gitlab-ci.yml nella radice del tuo progetto per definire il tuo flusso di lavoro CI/CD. Ecco un esempio di come puoi strutturare il tuo flusso di lavoro:


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 il flusso di lavoro

Quando pubblichi un nuovo tag nel tuo repository GitLab, il flusso di lavoro CI/CD di GitLab verrà automaticamente avviato, che costruirà e distribuirà il tuo 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 del tuo app Android su GitLab CI/CD.

Conclusioni

Configurando il flusso di lavoro 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 libera dal tempo di concentrarti sui punti chiave dello sviluppo di app, aiutandoti a consegnare app Android di alta qualità in modo più efficiente.

Continua da Automatic Capacitor Android build con GitLab

Se stai utilizzando Automatic Capacitor Android build con GitLab 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 workflow del prodotto nelle Capgo Integrazioni Integrazione CI/CD per i dettagli di implementazione nella integrazione CI/CD, e GitHub Actions Integration per i dettagli di implementazione in GitHub Integrazione delle azioni.

Automatic Capacitor Android build with GitLab