Automatische Android-Builds mit GitLab CI

Die Einrichtung von CI/CD für Capacitor-Apps kann komplex und zeitaufwändig sein. Hier sind die wichtigen Informationen:

Voraussetzungen

Bevor Sie beginnen, müssen Sie Folgendes einrichten:

Eine GitLab-Konto mit Administratorrechten
Ihr bereits veröffentlichtes App auf Google Play Store mit korrekter Signierung
Android-Signierungs-Schlüssel und Keystore-Dateien
Ein Google Cloud Console-Projekt mit Play Store API aktiviert
Eine Dienstkontoin mit den richtigen Berechtigungen
Verständnis von GitLab CI/CD-Workflows
Wissen über die Fastlane-Konfiguration
Zeit zur Wartung und Fehlersuche im Pipeline

Capgo Build für CI/CD durch Capgo

Vermeiden Sie die Wartung von Fastlane, Gradle-Runner, Keystore und Upload-Script. Capgo Build kontinuierliche native Android-Builds aus Ihrer bestehenden CI/CD-Pipeline ausführen:

Arbeitet mit Ihrer Pipeline: Auslösen Sie Capgo Build von GitLab CI, GitHub Actions, Jenkins oder lokalen Skripten nach Ihrer Web-Build und npx cap sync.
Signieren aus CI-SecretsHalte Android-Keystores, Alias, Passwörter und Play Console-Dienstkontoinformationen in deinen eigenen CI-Secrets.
Keine native Runner-Wartung: Capgo Build bietet gepflegte Android-Buildumgebungen, sodass Sie keine SDK-Images, Gradle-Cache-Probleme oder Fastlane-Linien verwalten müssen.
Artikel und Einreichung: Laden Sie signierte Artefakte für QA oder übermitteln Sie Release-Builds über den Capgo CLI.

Preise

Capgo-Pläne beginnen bei 12 $/Monat
Enthält OTA-Updates und etwa 15 native Builds pro Monat.
Minuten für zusätzliche Buildzeit werden pro Minute mit Credits berechnet.

: Capgo-Pläne beginnen bei 12 $/Monat

: __CAPGO_KEEP_0__-Pläne beginnen bei 12 $/Monat

: __CAPGO_KEEP_0__-Pläne beginnen bei 12 $/Monat

: __CAPGO_KEEP_0__-Pläne beginnen bei 12 $/Monat
Deine Geheimnisse in GitLab verschlüsselte Geheimnisse speichern
Erstellen und speichern Sie Ihr Google Play-Dienstkontoinfoberecht
Speichern Sie Ihre Android-Signierungs-Schlüssel
Konfigurieren Sie Ihr GitLab-Workflow-Datei .yml

1. Kopieren Sie die Fastlane-Dateien

Fastlane ist eine Ruby-Bibliothek, die zum Automatisieren von häufigen Aufgaben der mobilen Entwicklung erstellt wurde. Mit Fastlane können Sie benutzerdefinierte "Bahnen" konfigurieren, die eine Reihe von "Aktionen" enthalten, die Aufgaben ausführen, die Sie normalerweise mit Android Studio durchführen würden. Mit Fastlane können Sie eine Menge tun, aber für die Zwecke dieses Tutorials werden wir nur eine Handvoll grundlegender Aktionen verwenden.

Erstellen Sie einen Fastlane-Ordner am Root Ihres Projekts und kopieren Sie die folgenden Dateien: 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

Deine Geheimnisse in GitLab CI/CD-Variablen speichern

GitLab bietet eine Möglichkeit, verschlüsselte CI/CD-Variablen zu speichern, ähnlich wie GitHub's Repository-Geheimnisse. Um deine sensiblen Informationen sicher zu speichern.

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

ANDROID_KEYSTORE_FILE: die bas64-codierte .jks oder .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.
KEYSTORE_KEY_PASSWORD: der zugehörige Passwort für das Keystore-Datei
KEYSTORE_STORE_PASSWORD: das private Schlüssel Passwort
DEVELOPER_PACKAGE_NAME: Ihre Android-App-ID wie com.example.app
DEVELOPER_PACKAGE_NAME: Ihre Android-App-ID wie com.example.app
Erstellen Sie einen Google Play Service Account Schlüssel

Erstellen Sie eine Google Play-Dienstkontozugangsbeschreibung

Automatischen PLAY_CONFIG_JSON Geheim, folge diesen Schritten:

or Google Cloud Console
Einen neuen Projekt erstellen oder ein bestehendes auswählen
Aktivieren Sie die Google Play Android-Entwickler API
Einen Dienstkonten erstellen:
- Zum “IAM & Admin”-Bereich gehen > “Dienstkonten”
- Auf “Dienstkonten erstellen” klicken
- Einen Namen und eine Beschreibung geben
- Auf “Erstellen und fortfahren” klicken
- Die Rolle zuweisen und auf “Fertig” klicken
Eine JSON-Schlüssel generieren:
- Nach Ihrem Dienstkonten in der Liste suchen
- Auf die drei Punkte-Menü > “Schlüssel verwalten” klicken
- Click “Add Key” > “Create new key”
- Wählen Sie die JSON-Formatierung
- Klicken Sie auf ‘Erstellen’
Stellen Sie dem Dienstkontoinhaber Zugriff auf Ihre App im Google Play Console ein:
- Gehe zu Google Play Console
- Navigiere zu ‘Benutzer und Berechtigungen’
- Klicken Sie auf ‘Benutzer einladen’
- Geben Sie die E-Mail-Adresse des Dienstkontoinhabers ein (endet mit @*.iam.gserviceaccount.com)
- Erlaubnis für "Veröffentlichung in die Produktion" erteilen
- Klicken Sie auf ‘Benutzer einladen’

Konvertieren Sie den JSON-Schlüssel in Base64:

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

Fügen Sie die bas64-codierte Zeichenfolge als PLAY_CONFIG_JSON Variable in GitLab

Einrichten Sie Ihre GitLab CI/CD-Pipeline

Erstellen Sie ein .gitlab-ci.yml-File im Wurzelverzeichnis Ihres Projekts, um Ihre CI/CD-Pipeline zu definieren. Hier ist ein Beispiel dafür, wie Sie Ihre Pipeline strukturieren können:


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 auslösen

Wenn Sie ein neues Tag in Ihrem GitLab-Repository pushen, wird die CI/CD-Pipeline automatisch ausgelöst, die Ihre Android-App mit Fastlane baut und bereitstellt.

Stellen Sie sicher, dass Sie die Pfade und Abhängigkeiten an Ihre Projektstruktur und -anforderungen anpassen. Diese Einrichtung hilft Ihnen bei der Automatisierung der Bereitstellung Ihrer Android-App auf GitLab CI/CD.

Fazit

Indem Sie GitLab CI/CD mit dem mingc/android-build-box-Docker-Image konfigurieren, können Sie den Android-App-Build-Prozess automatisieren, was Ihre Entwicklungsbearbeitung effizienter und zuverlässiger macht. Diese Automatisierung befreit Ihre Zeit, um sich auf die Kernaspekte der App-Entwicklung zu konzentrieren, was Ihnen hilft, hochwertige Android-Apps effizienter zu liefern.

Fortsetzen von Automatischer Capacitor Android-Build mit GitLab

Wenn Sie Automatischer __CAPGO_KEEP_0__ Android-Build mit GitLab verwenden Automatischer Capacitor Android-Build mit GitLab verwenden um die CI/CD-Automatisierung zu planen, verbinden Sie sie mit Capgo CI/CD zur Produktworkflow in Capgo CI/CD Capgo nativee Native Builds zur Produktworkflow in Capgo Native Builds Capgo Integrations zur Produktworkflow in Capgo Integrations CI/CD-Integration zur Implementierungsdetail in CI/CD-Integration, und GitHub Aktionen-Integration zur Implementierungsdetail in GitHub Actions Integration

Automatischer Capacitor-Build für Android mit GitLab