Automatische Android-Builds mit GitLab CI

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

Voraussetzungen

Bevor Sie beginnen, müssen Sie Folgendes einrichten:

Ein GitLab-Konto mit Administrator-Zugriff
Ihre App bereits im Google Play Store veröffentlicht mit korrekter Signatur
Android-Signierungs-Schlüssel und Keystore-Dateien
Google Cloud Console-Projekt mit Play Store API aktiviert
Service-Konto mit geeigneten Berechtigungen
Verständnis von GitLab CI/CD-Workflows
Wissen über 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 führt von Ihrem bestehenden CI/CD-Pipeline aus signierte native Android-Builds durch:

Arbeitet mit Ihrer Pipeline: Auslösen Sie Capgo Build von GitLab CI, GitHub Actions, Jenkins oder lokalen Skripten nach Ihrem Web-Build und npx cap sync.
Signierung aus CI-SecretsBehalte Android-Keystores, Schlüsselalias, Passwörter und Play-Console-Dienstkontoinformationen in deinen eigenen CI-Secrets.
Keine native Runner-Vereinbarkeit Capgo Build stellt wartungsfreie Android-Buildumgebungen bereit, sodass du keine SDK-Images, Gradle-Cache-Probleme oder Fastlane-Linien verwalten musst.
Artikel und EinreichungLade signierte Artikel für QA oder einreiche Release-Builds über den Capgo CLI.

Preise

Capgo-Pläne beginnen bei 12 $/Monat
Inklusive OTA-Updates und etwa 15 native Builds pro Monat
Zusätzliche Build-Minuten werden nach Minute über Kreditkarten berechnet

Setze Capgo Build in CI/CD ein

Manueller Setup-Leitfaden

Hier ist, was Sie tun müssen:

Schritte, die Sie im Post befolgen müssen

Fastlane-Dateien kopieren
Ihre Geheimnisse in GitLab verschlüsselten Geheimnissen speichern
Erstellen und speichern Sie Ihren Google Play-Dienstkontoschlüssel
Ihren Android-Signierungsschlüssel speichern
Einstellen Sie Ihr GitLab-Workflow-Datei .yml

1. Fastlane-Dateien kopieren

Fastlane ist eine Ruby-Bibliothek, die zum Automatisieren von mobilen Entwicklungsarbeiten 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

Ihre 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 Ihre 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 Datei, die für die Signierung deiner Android-Builds verwendet wird. Dies kann entweder die Datei des Upload-Schlüssels sein (wenn Play App Signing verwendet wird), oder dein App-Signierungs-Schlüssel.
KEYSTORE_KEY_PASSWORD: das Passwort, das mit der Datei des Schlüsselkontos verbunden ist
KEYSTORE_KEY_ALIAS: der Schlüsselkontosalias
KEYSTORE_STORE_PASSWORD: das Passwort für die private Schlüsseldatei
DEVELOPER_PACKAGE_NAME: dein Android-App-Id wie z.B. com.example.app
PLAY_CONFIG_JSON: Die bas64-codierte JSON-Schlüsseldatei des Google Play-Dienstkontos.

Erstellung einer Google Play-Dienstkontoschlüsseldatei

Um den PLAY_CONFIG_JSON geheimen Schlüssel zu generieren, folge bitte diesen Schritten:

Gehe zur Google Cloud Console
Erstelle ein neues Projekt oder wähle ein bestehendes aus
Aktiviere die Google Play Android Developer API
Erstelle ein Dienstkonto:
- Gehe zu “IAM & Admin” > “Service Accounts”
- Klicke auf “Create Service Account”
- Gib ihm einen Namen und eine Beschreibung
- Klicke auf “Create and Continue”
- Überspringe die Rollezuweisung und klicke auf “Done”
Erstelle ein JSON-Schlüssel:
- Finden Sie Ihr Dienstkontoin der Liste
- Klicken Sie auf das Dreipunkte-Menü > „Schlüssel verwalten“
- Klicken Sie auf „Schlüssel hinzufügen“ > „Neuer Schlüssel erstellen“
- Wählen Sie die JSON-Format
- Klicken Sie auf „Erstellen“
Gewähren Sie dem Dienstkontoin Zugriff auf Ihre App im Google Play Console:
- Gehe zu Google Play Console
- Navigieren Sie zu „Benutzer und Berechtigungen“
- Klicken Sie auf „Benutzer einladen“
- Geben Sie die E-Mail-Adresse des Dienstkontoin (endet mit @*.iam.gserviceaccount.com) ein
- Die Berechtigung für 'Release to production' 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 Base64-codierte Zeichenfolge als PLAY_CONFIG_JSON Variable in GitLab hinzu

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 GitLab CI/CD die definierte Pipeline automatisch auslösen, die Ihre Android-App mit Fastlane baut und bereitstellt.

Stellen Sie sicher, dass Sie die Pfade und Abhängigkeiten entsprechend der Struktur und Anforderungen Ihres Projekts anpassen. Diese Einrichtung hilft Ihnen dabei, die Bereitstellung Ihrer Android-App auf GitLab CI/CD zu automatisieren.

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, damit Sie sich auf die Kernaspekte der App-Entwicklung konzentrieren können, was Ihnen letztendlich hilft, hochwertige Android-Apps effizienter zu liefern.

Bleiben Sie bei der automatischen Capacitor Android-Build mit GitLab

Wenn Sie Automatische Capacitor Android-Build mit GitLab um die CI/CD-Automatisierung zu planen, verbinden Sie sie mit Capgo CI/CD für den Produktworkflow in Capgo CI/CD, Capgo Native Builds für den Produktworkflow in Capgo Native Builds, Capgo Integrations für den Produktworkflow in Capgo Integrations, CI/CD-Integration für die Implementierungsdetails in CI/CD-Integration, und GitHub Aktionen-Integration für die Implementierungsdetails in GitHub Aktionen-Integration.