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:

Ein GitLab-Konto mit Administratorzugriff
Ihre 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
Ein Dienstkonto mit den richtigen Berechtigungen
Verständnis von GitLab CI/CD-Workflows
Kenntnisse in der Konfiguration von Fastlane
Zeit, um den Pipeline zu warten und zu debuggen

Professionelle CI/CD-Einrichtung durch Capgo

Komplexität vermeiden. Capgo konfiguriert Ihre CI/CD-Pipeline direkt in Ihrer bevorzugten Plattform:

Plattformunabhängigkeit: Funktioniert mit GitHub Aktionen, GitLab CI oder anderen
Nahtlose Integration: Keine Plattformwechsel erforderlich, funktioniert mit Ihrem aktuellen Prozess
Angepasste Konfiguration: Anpassete Einrichtung, die den Bedürfnissen Ihres Projekts entspricht
Experte Unterstützung: Wir haben bereits CI/CD für 50+ Apps eingerichtet

Preise

Einmaliger Einrichtungsbetrag: 2.600 $
Ihre laufenden Kosten: ~300 $/Jahr
Vergleichen Sie mit anderen proprietären Lösungen: 6.000 $/Jahr
Sparen Sie 26.100 € über 5 Jahre

Setup CI/CD Jetzt

Manueller Setup Guide

Wenn Sie trotzdem alles selbst einrichten möchten, hier ist, was Sie tun müssen:

Schritte, die im Post zu beachten sind

Kopieren Sie die Fastlane-Dateien
Speichern Sie Ihre Geheimnisse in GitLab verschlüsselten Geheimnissen
Erstellen und speichern Sie Ihren Google Play-Dienstkonten-Schlüssel
Speichern Sie Ihren 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 gängigen 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 Wurzelverzeichnis 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

Speichern Sie Ihre Geheimnisse in GitLab CI/CD-Variablen

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.

Gehen Sie zu den Einstellungen Ihres GitLab-Projekts.
Navigieren Sie zu CI/CD > Variablen
Fügen Sie die folgenden Variablen hinzu:

ANDROID_KEYSTORE_FILE: die bas64-codierte .jks oder .keystore Datei, die zum Signieren Ihrer Android-Builds verwendet wird. Dies wird entweder die Keystore-Datei sein, die mit Ihrem Upload-Schlüssel (wenn Sie Play App Signing verwenden), oder Ihr App-Signier-Schlüssel.
KEYSTORE_KEY_PASSWORD: der Schlüssel für die Keystore-Datei
KEYSTORE_KEY_ALIAS: der Schlüssel-Store-Alias
KEYSTORE_STORE_PASSWORD: der private Schlüssel-Passwort
Entwickler-Paketname: Ihre Android-App-ID wie com.example.app
PLAY_CONFIG_JSON: Die bas64-codierte Dienstkontokenn-JSON.

Erstellung einer Google Play Service-Kennung

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

Gehen Sie zur Google Cloud Console
Erstellen Sie ein neues Projekt oder wählen Sie ein bestehendes aus
Aktivieren Sie die Google Play Android-Entwickler API
Erstellen Sie eine Dienstkonto:
- Gehen Sie zu “IAM & Admin” > “Service Accounts”
- Klicken Sie auf “Create Service Account”
- Geben Sie ihm einen Namen und eine Beschreibung
- Klicken Sie auf „Erstellen und fortfahren“
- Überspringen Sie die Rollezuweisung und klicken Sie auf „Fertig“
Erstellen Sie einen 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“
Geben Sie dem Dienstkontoin Ihrem App Zugriff in der Play Console ein:
- Gehe zu Play Console
- Navigieren Sie zu “Benutzer und Berechtigungen”
- Klicken Sie auf “Benutzer einladen”
- Geben Sie die E-Mail-Adresse des Dienstkontos 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-codierten Zeichenfolge als PLAY_CONFIG_JSON Variablen in GitLab hinzu

Einstellungen für Ihre GitLab CI/CD Pipeline

Erstellen Sie eine .gitlab-ci.yml-Datei am Anfang 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, die Pfade und Abhängigkeiten entsprechend der Struktur und Anforderungen Ihres Projekts anzupassen. Diese Konfiguration hilft Ihnen dabei, 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 Ihren Entwicklungsworkflow effizienter und zuverlässiger macht. Diese Automatisierung befreit Ihnen Zeit, um sich auf die Kernaspekte der App-Entwicklung zu konzentrieren, was Ihnen letztendlich hilft, hochwertige Android-Apps effizienter zu liefern.

Automatischer Capacitor Android-Build mit GitLab