Automatische Android-Builds mit GitLab CI

Die Einrichtung von CI/CD für Capacitor-Apps kann komplex und zeitaufwändig sein. Hier ist, was Sie wissen müssen:

Voraussetzungen

Bevor Sie beginnen, müssen Sie Folgendes einrichten:

Eine GitLab-Konto mit Administratorzugriff
Ihr App bereits auf dem Google Play Store veröffentlicht mit korrekter Signierung
Android-Signierungskey und Keystore-Dateien
Ein Google Cloud Console-Projekt mit Play Store API aktiviert
Eine Dienstkontoin mit den richtigen Berechtigungen
Eine Verständnis für GitLab CI/CD-Workflows
Kenntnisse in der Fastlane-Konfiguration
Zeit, um den Pipeline zu warten und zu debuggen

Capgo Build für CI/CD durch Capgo

Vermeiden Sie die Wartung von Fastlane, Gradle-Runner, Keystore und Upload-Script. Capgo Build __CAPGO_KEEP_0__ Build führt signierte native Android-Builds aus Ihrem bestehenden CI/CD-Pipeline aus:

Funktioniert 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-Secrets: Halten Sie Android-Keystores, Schlüsselalias, Passwörter und Play-Console-Dienstkonten-JSON in Ihren eigenen CI-Secrets.
Keine native Runner-Wartung: Capgo Build stellt Android-Build-Umgebungen bereit, sodass Sie keine SDK-Images, Gradle-Cache-Probleme oder Fastlane-Lane verwalten müssen.
Artikel und Einreichung: Laden Sie signierte Artikel für QA herunter oder übermitteln Sie Release-Builds über die Capgo CLI.

Pricing

Capgo plans start at $12/month
__CAPGO_KEEP_0__ Pläne beginnen bei 12 $/Monat
Umfasst OTA-Updates und etwa 15 native Builds pro Monat

Set up Capgo Build in CI/CD

Einstellung von __CAPGO_KEEP_0__ Build in CI/CD

Manueller Setup-Leitfaden

Hier sind die Schritte, die Sie ausführen müssen:

Schritte, die in diesem Beitrag beschrieben werden
Kopieren Sie die Fastlane-Dateien
Speichern Sie Ihre Geheimnisse in GitLab verschlüsselten Geheimnissen
Erstellen und speichern Sie Ihre Google Play-Dienstkontoinformationen-Schlüssel
Deine GitLab-Workflow-Datei .yml einrichten

1. Fastlane-Dateien kopieren

Fastlane ist eine Ruby-Bibliothek, die zum Automatisieren von gemeinsamen 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 eine Menge tun, aber für den Zweck dieses Tutorials werden wir nur eine Handvoll grundlegender Aktionen verwenden.

Erstelle einen Fastlane-Ordner am Root deines Projekts und kopiere 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 provides a way to store encrypted CI/CD variables, similar to GitHub’s repository secrets. To store your sensitive information securely.

Zu CI/CD > Variablen navigieren
Die folgenden Variablen hinzufügen:
ANDROID_KEYSTORE_FILE: die bas64-codierte

Oder .jks Alternativen zu Live-Updates mit Capacitor .keystore Alternativen zu Appflow oder
KEYSTORE_KEY_PASSWORD: der Passwort, das mit dem Keystore-Datei verbunden ist
KEYSTORE_KEY_ALIAS: der Schlüssel Speicher Alias
KEYSTORE_STORE_PASSWORD: das private Schlüssel Passwort
DEVELOPER_PACKAGE_NAME: Ihre Android-App-ID wie com.example.app
PLAY_CONFIG_JSON: Die bas64-codierte Dienstkonten Schlüssel JSON.

Erstellung eines Google Play Service Account Schlüssels

Um den PLAY_CONFIG_JSON Geheimen zu generieren, folgen Sie bitte diesen Schritten:

Gehe zur Google Cloud Console
Erstelle ein neues Projekt oder wähle ein bestehendes
Aktiviere die Google Play Android-Entwickler API
Dienstkontodaten erstellen:
- Gehe zu “IAM & Admin” > “Service Accounts”
- Klicke auf “Dienstkonto erstellen”
- Gib ihm einen Namen und eine Beschreibung
- Klicke auf “Erstellen und fortfahren”
- Überspringe die Rolle zuweisen und klicke auf “Fertig”
Erstelle eine JSON-Schlüsseldatei:
- Finde dein Dienstkonto in der Liste
- Klicke auf das Dreipunktemenü > “Schlüssel verwalten”
- Klicke auf “Schlüssel hinzufügen” > “Neuer Schlüssel erstellen”
- Wähle die JSON-Formatierung
- Klicke auf “Erstellen”
Dem Dienstkontenkonten gewähren Sie 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 Dienstkontenkontos ein (endet mit @*.iam.gserviceaccount.com)
- Gewähren 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 variable in GitLab

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. Im Folgenden finden Sie 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

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

Zusammenfassung

Durch die Konfiguration von GitLab CI/CD mit dem mingc/android-build-box-Docker-Image können Sie den Android-App-Build-Prozess automatisieren, was Ihre Entwicklungsmethodik 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.

Keep going from Automatic Capacitor Android build with GitLab

Wenn Sie CI/CD-Automatisierung mit Automatic Capacitor Android build with GitLab planen, verbinden Sie es mit Capgo CI/CD für den Produktworkflow in Capgo CI/CD Capgo 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 Actions-Integration zur Implementierungsdetail in GitHub Actions-Integration

Automatischer Capacitor-Build für Android mit GitLab