Automatische Android-Builds mit GitLab CI
Das Einrichten von CI/CD für Capacitor-Apps kann komplex und zeitaufwendig sein. Hier ist das Wichtigste:
Voraussetzungen
Bevor du startest, musst du Folgendes einrichten:
- Ein GitLab-Konto mit Admin-Zugriff
- Deine App ist bereits mit korrekter Signatur im Google Play Store veröffentlicht
- Android Signing Key und Keystore-Dateien
- Google-Cloud-Console-Projekt mit aktiviertem Play Store API
- Service Account mit den richtigen Berechtigungen
- Verständnis von GitLab CI/CD-Workflows
- Kenntnisse in der Fastlane-Konfiguration
- Zeit für die Wartung und das Debugging der Pipeline
Capgo Build für CI/CD von Capgo
Verzichten Sie auf die Wartung von Fastlane, Gradle-Runner, Keystore und Upload-Skripten. Capgo Build führt signierte native Android-Builds aus Ihrer bestehenden CI/CD-Pipeline aus:
- Funktioniert mit Ihrer Pipeline: Starten Sie Capgo Build aus GitLab CI, GitHub Actions, Jenkins oder lokalen Skripten nach Ihrem Web-Build und
npx cap sync. - Signierung aus CI-Secrets: Bewahren Sie Android-Keystores, Key-Aliase, Passwörter und die Service-Account-JSON-Datei der Play Console in Ihren eigenen CI-Secrets auf.
- Kein Wartungsaufwand für Native Runner: Capgo Build stellt gewartete Android-Build-Umgebungen bereit, sodass Sie sich nicht um SDK-Images, Gradle-Cache-Probleme oder Fastlane-Lanes kümmern müssen.
- Artefakte und Einreichung: Lade signierte Artefakte für QA herunter oder reiche Release-Builds über Capgo CLI ein.
Preise
- Capgo-Pläne ab 12 $/Monat
- Inklusive OTA-Updates und ca. 15 Native Builds pro Monat
- Zusätzliche Build-Minuten werden minutengenau über Credits abgerechnet
Capgo Build in CI/CD einrichten
Manuelle Setup-Anleitung
Das müssen Sie tun:
Schritte im Beitrag
- Fastlane-Dateien kopieren
- Secrets in GitLab verschlüsselten Secrets speichern
- Google Play Service Account Key erstellen & speichern
- Android Signing Key speichern
- GitLab Workflow .yml-Datei einrichten
1. Fastlane-Dateien kopieren
Fastlane ist eine Ruby-Library, mit der sich gängige Aufgaben in der Mobile-Entwicklung automatisieren lassen. Mit Fastlane kannst du eigene „Lanes“ konfigurieren, die eine Reihe von „Actions“ bündeln, um Aufgaben auszuführen, die du normalerweise in Android Studio erledigst. Mit Fastlane lässt sich viel erreichen, aber in diesem Tutorial nutzen wir nur eine Handvoll Core-Actions.
Fastlane-Ordner im Projektstamm anlegen und folgende Dateien kopieren: 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
Secrets in GitLab-CI/CD-Variablen speichern
GitLab bietet eine Möglichkeit, verschlüsselte CI/CD-Variablen zu speichern, ähnlich wie die Repository Secrets von GitHub. So speicherst du sensible Informationen sicher.
- Gehe zu den Einstellungen deines GitLab-Projekts.
- Navigiere zu CI/CD > Variablen
- Füge die folgenden Variablen hinzu:
- ANDROID_KEYSTORE_FILE: die base64-kodierte
.jksoder.keystoreDatei, die zum Signieren Ihrer Android-Builds verwendet wird. Dies ist entweder die Keystore-Datei, die mit Ihrem Upload-Schlüssel verknüpft ist (bei Play App Signing), oder Ihr App-Signierungsschlüssel. - KEYSTORE_KEY_PASSWORD: das Passwort, das mit der Keystore-Datei verknüpft ist
- KEYSTORE_KEY_ALIAS: der Key-Store-Alias
- KEYSTORE_STORE_PASSWORD: das Private-Key-Passwort
- DEVELOPER_PACKAGE_NAME: Ihre Android-App-ID wie com.example.app
- PLAY_CONFIG_JSON: Der base64-kodierte Service-Account-Key-JSON.
Google Play Service Account Key erstellen
To generate the PLAY_CONFIG_JSON Secret zu generieren, befolgen Sie diese Schritte:
- Besuchen Sie die Google Cloud Console
- Neues Projekt erstellen oder bestehendes auswählen
- Google Play Android Developer API aktivieren
- Service Account erstellen:
- Gehe zu „IAM & Admin“ > „Service Accounts“
- Klicke auf „Service Account erstellen“
- Name und Beschreibung vergeben
- Klicke auf „Erstellen und Fortfahren“
- Rollenzuweisung überspringen und auf „Fertig“ klicken
- JSON-Schlüssel generieren:
- Deinen Service Account in der Liste finden
- Drei-Punkte-Menü > „Schlüssel verwalten“
- Klicken Sie auf „Add Key“ > „Create new key“
- Wählen Sie das JSON-Format
- Klicken Sie auf „Erstellen“
- Gewähren Sie dem Service Account Zugriff auf Ihre App in der Play Console:
- Gehe zu Play Console
- Navigieren Sie zu „Benutzer und Berechtigungen“
- Klicken Sie auf „Neue Benutzer einladen“
- Geben Sie die E-Mail-Adresse des Service Accounts ein (endet mit @*.iam.gserviceaccount.com)
- Gewähren Sie die Berechtigung „Release in Produktion“
- Klicken Sie auf „Benutzer einladen“
- JSON-Schlüssel in base64 konvertieren:
base64 -i path/to/your/service-account-key.json | pbcopy - Die base64-kodierte Zeichenfolge als
PLAY_CONFIG_JSONVariable in GitLab hinzufügen
Richte deine GitLab CI/CD-Pipeline ein
Erstellen Sie eine .gitlab-ci.yml-Datei im Projektstamm, um Ihre CI/CD-Pipeline zu definieren. Nachfolgend ein Beispiel für die Struktur Ihrer 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
Pipeline triggern
Sobald Sie einen neuen Tag in Ihr GitLab-Repository pushen, löst GitLab CI/CD automatisch die definierte Pipeline aus, die Ihre Android-App mit Fastlane baut und deployt.
Passen Sie die Pfade und Abhängigkeiten an die Struktur und Anforderungen Ihres Projekts an. Dieses Setup hilft Ihnen, den Deployment-Prozess Ihrer Android-App in GitLab CI/CD zu automatisieren.
Fazit
Wenn Sie GitLab CI/CD mit dem Docker-Image mingc/android-build-box konfigurieren, automatisieren Sie den Android-Build-Prozess und machen Ihren Entwicklungs-Workflow effizienter und zuverlässiger. Diese Automatisierung verschafft Ihnen mehr Zeit für die Kernaspekte der App-Entwicklung, sodass Sie hochwertige Android-Apps effizienter ausliefern.
Weiter geht's: Automatischer Capacitor Android-Build mit GitLab
Wenn du es nutzt Automatischer Capacitor Android-Build mit GitLab um CI/CD-Automatisierung zu planen, verbinde es mit Capgo CI/CD für den Produkt-Workflow in Capgo CI/CD, Capgo Native Builds optimieren für den Produkt-Workflow in Capgo Native Builds, Capgo Integrationen für den Produkt-Workflow in Capgo Integrations, CI/CD-Integration für die Implementierungsdetails in der CI/CD-Integration und GitHub Actions-Integration für die Implementierungsdetails in der GitHub Actions-Integration.