Automatische Android-Builds mit GitLab CI

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

Voraussetzungen

Bevor Sie beginnen, müssen Sie Folgendes einrichten:

A GitLab-Konto mit Administratorzugriff
Deine App ist bereits auf dem Google Play Store veröffentlicht und mit einer gültigen Signatur versehen
Android-Signierungschlüssel und Keystore-Dateien
Ein Google Cloud Console-Projekt mit Play Store API aktiviert
Eine Dienstkontrolle mit den erforderlichen Berechtigungen
Eine Verständigung der GitLab CI/CD-Workflows
Eine Kenntnis der Fastlane-Konfiguration
Zeit, um den Pipeline zu pflegen und zu debuggen

Capgo Build für CI/CD durch Capgo

Vermeide die Fastlane-, Gradle-Runner-, Keystore- und Upload-Script-Verwaltung. Capgo Build führt signierte native Android-Builds aus deinem bestehenden CI/CD-Pipeline:

Arbeitet mit Ihrem Pipeline: Auslösen Capgo Build von GitLab CI, GitHub Actions, Jenkins oder lokalen Skripten nach Ihrem Web-Build und npx cap sync.
Signierung aus CI-Secrets: Halten Sie Android-Keystores, Schlüsselalias, Passwörter und Play-Console-Dienstkontoinformationen in Ihren eigenen CI-Secrets.
Keine native Runner-Vermögensverwaltung: Capgo Build stellt Ihnen eine gepflegte Android-Buildumgebung zur Verfügung, sodass Sie keine SDK Bilder, Gradle-Cache-Probleme oder Fastlane-Linien verwalten müssen.
Artikel und Einreichung: Laden Sie signierte Artikel für QA herunter oder übermitteln Sie Release-Builds über die 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 Credits abgerechnet

Einrichten Sie Capgo Build in CI/CD

Anleitung zum manuellen Setup

Hier ist, was Sie tun müssen:

Schritte, die im Beitrag zu beachten sind

Kopieren Sie die Fastlane-Dateien
Speichern Sie Ihre Geheimnisse in GitLab verschlüsselten Geheimnissen
Erstellen und speichern Sie Ihre Google Play-Dienstkontozugangsdaten
Speichern Sie Ihre Android-Signierungsdatei
Einrichten 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 ausführen würden. Mit Fastlane können Sie viel erreichen, 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-Secrets. Um Ihre sensitive Informationen sicher zu speichern.

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

ANDROID_KEYSTORE_FILE: die bas64-codierte .jks oder .keystore Entscheide dich zwischen den verschiedenen Möglichkeiten, um deine App zu erstellen.
Datei, die zum Signieren deiner Android-Builds verwendet wird. Dies kann entweder die Keystore-Datei sein, die mit deinem Upload-Schlüssel verbunden ist (wenn du Play App Signing verwendest), oder dein App-Signierungsschlüssel.
KEYSTORE_KEY_PASSWORD: das Passwort, das mit der Keystore-Datei verbunden ist
KEYSTORE_KEY_ALIAS: der Alias der Keystore-Datei
KEYSTORE_STORE_PASSWORD: das Passwort für den privaten Schlüssel
PLAY_CONFIG_JSON: Die bas64-codierte JSON-Schlüsseldatei des Dienstkontos.

Erstellung einer Google Play Service Account Schlüssel

Um den Schlüssel zu generieren, folgen Sie bitte diesen Schritten: PLAY_CONFIG_JSON Gehe zur

Google Cloud Console Erstelle ein neues Projekt oder wähle ein bestehendes aus
Aktiviere die Google Play Android Developer __CAPGO_KEEP_0__
Enable the Google Play Android Developer API
Gehe zu “IAM & Admin” > “Service Accounts”
- Klicke auf “Create Service Account”
- Gib ihm einen Namen und eine Beschreibung
- Schritte zur Erstellung eines Google Play Service Account Schlüssels
- Klicken Sie auf „Erstellen und fortfahren“
- Übergehen Sie die Rollezuweisung und klicken Sie auf „Fertig“
Erstellen Sie eine 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’
- Eingeben Sie die E-Mail-Adresse des Dienstkontos (endet mit @*.iam.gserviceaccount.com)
- Erlauben Sie die Berechtigung ‘In die Produktion freigeben’
- Klicken Sie auf ‘Benutzer einladen’

Konvertieren Sie die 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 Variablen in GitLab hinzu

Einstellungen für 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

Auslösen Sie die Pipeline

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 Einstellung hilft Ihnen, die Bereitstellung Ihrer Android-App auf GitLab CI/CD zu automatisieren.

Zusammenfassung

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

Fortsetzung von Automatischem Capacitor Android-Build mit GitLab

Wenn Sie Automatic __CAPGO_KEEP_0__ Android-Build mit GitLab verwenden Wenn Sie Automatic Capacitor Android-Build mit GitLab verwenden um die CI/CD-Automatisierung zu planen, verbinden Sie es mit __CAPGO_KEEP_0__ CI/CD um den Produktworkflow in Capgo CI/CD um den Produktworkflow in Capgo Native Builds um den Produktworkflow in Capgo Native Builds um den Produktworkflow in Capgo Integrations um den Produktworkflow in Capgo Integrations for the product workflow 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.

Automatischer Capacitor-Build für Android mit GitLab