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
Grundverstä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: Halten Sie Android-Keystores, Key-Aliase, Passwörter und die Service-Account-JSON-Datei der Play Console in Ihren eigenen CI-Secrets.
Kein Wartungsaufwand für Native-Runner: Capgo Build stellt gewartete Android-Build-Umgebungen bereit, sodass Sie keine SDK-Images, Gradle-Cache-Probleme oder Fastlane-Lanes verwalten 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üsselte 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 kannst du sensible Informationen sicher ablegen.

Gehe zu den Einstellungen deines GitLab-Projekts.
Navigiere zu CI/CD > Variablen
Füge die folgenden Variablen hinzu:

ANDROID_KEYSTORE_FILE: die base64-kodierte .jks oder .keystore Datei, die zum Signieren deiner Android-Builds verwendet wird. Dies ist entweder die Keystore-Datei, die mit deinem Upload-Key verknüpft ist (bei Play App Signing), oder dein App-Signing-Key.
KEYSTORE_KEY_PASSWORD: das Passwort, das mit der Keystore-Datei verknüpft ist
KEYSTORE_KEY_ALIAS: Der Key-Store-Alias
KEYSTORE_STORE_PASSWORD: Das Passwort des privaten Schlüssels
DEVELOPER_PACKAGE_NAME: Ihre Android-App-ID, z. B. 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
Erstellen Sie ein neues Projekt oder wählen Sie ein bestehendes aus
Aktivieren Sie die Google Play Android Developer API
Erstellen Sie einen Service-Account:
- Gehe zu „IAM & Admin“ > „Service Accounts“
- Klicke auf „Service Account erstellen“
- Gib einen Namen und eine Beschreibung ein
- Klicke auf „Erstellen und Fortfahren“
- Überspringe die Rollenzuweisung und klicke auf „Fertig“
Erzeuge einen JSON-Key:
- Finde dein Service Account in der Liste
- Klicke auf das Drei-Punkte-Menü > „Keys verwalten“
- Klicke auf „Key hinzufügen“ > „Neuen Key erstellen“
- Wähle das JSON-Format
- Klicke auf „Erstellen“
Erteile dem Service Account Zugriff auf deine App in der Play Console:
- Gehe zu Play Console
- Gehe zu „Benutzer und Berechtigungen“
- Klicke auf „Neue Benutzer einladen“
- Gib die E-Mail-Adresse des Service Accounts ein (endet mit @*.iam.gserviceaccount.com)
- Verliehe die Berechtigung „Release in Produktion“
- Klicke auf „Benutzer einladen“

Konvertiere den JSON-Schlüssel nach base64:

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

Füge die base64-kodierte Zeichenkette als PLAY_CONFIG_JSON Variable in GitLab hinzu

Richte deine GitLab CI/CD-Pipeline ein

Erstelle eine .gitlab-ci.yml-Datei im Projektstamm, um deine CI/CD-Pipeline zu definieren. Nachfolgend findest du ein Beispiel für die Struktur deiner 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 du einen neuen Tag in dein GitLab-Repository pusht, löst GitLab CI/CD automatisch die definierte Pipeline aus, die deine Android-App mit Fastlane baut und deployt.

Passe die Pfade und Abhängigkeiten an die Struktur und Anforderungen deines Projekts an. Dieses Setup hilft dir, das Deployment deiner 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.