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:

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

Capgo für CI/CD durch Capgo erstellen

Vermeiden Sie die Pflege 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:

Arbeitet mit Ihrer Pipeline: Capgo Build auslösen von GitLab CI, GitHub Actions, Jenkins oder lokalen Skripten nach Ihrer 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-Pflege: Capgo Build stellt Android-Buildumgebungen bereit, sodass Sie keine SDK-Images, Gradle-Cache-Probleme oder Fastlane-Lane-Verwaltung durchführen 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

Manueller Setup-Leitfaden

Hier ist, was Sie tun müssen:

Schritte im Post

Kopieren Sie Fastlane-Dateien
Speichern Sie Ihre Geheimnisse in GitLab-gekryptierten Geheimnissen
Erstellen und speichern Sie Ihren Google Play-Dienstaccount-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 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

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-Schlüssel. 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 Datei des Upload-Schlüssels sein (wenn Sie Play App Signing verwenden), oder Ihr App-Signierungsschlüssel.
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.

Ein Google Play Service Account Key erstellen

Um den geheimen Schlüssel zu generieren, folgen Sie bitte diesen Schritten: PLAY_CONFIG_JSON Zur Google Cloud Console gehen

Ein neues Projekt erstellen oder ein bestehendes Projekt auswählen Die Google Play Android Developer Funktion aktivieren __CAPGO_KEEP_0__
Create a new project or select an existing one
Enable the Google Play Android Developer API
Einen Dienstkonten erstellen:
- Zum ‘IAM & Admin’ > ‘Dienstkonten’ gehen
- Auf ‘Dienstkonten erstellen’ klicken
- Einem Namen und einer Beschreibung geben
- Auf ‘Erstellen und fortfahren’ klicken
- Die Rolle zuweisen und auf ‘Fertig’ klicken
Eine JSON-Schlüsseldatei generieren:
- Ihre Dienstkonten in der Liste finden
- Auf die drei Punkte-Menü > ‘Dienstkonten verwalten’ klicken
- Auf ‘Schlüssel hinzufügen’ > ‘Neuer Schlüssel erstellen’ klicken
- JSON-Format wählen
- Auf ‘Erstellen’ klicken
Dem Dienstkontenkonten Zugriff auf Ihre App in der Google Play Console einräumen:
- Zu Google Play Console
- Zur 'Benutzer und Berechtigungen'-Seite navigieren
- Klicken Sie auf 'Neue Benutzer einladen'
- Das Dienstkonten-E-Mail-Konto (endet mit @*.iam.gserviceaccount.com) eingeben
- Zugriff auf 'Veröffentlichung in die Produktion' erteilen
- Klicken Sie auf 'Benutzer einladen'

Das JSON-Schlüssel in Base64 umwandeln:

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

Die Base64-codierte Zeichenfolge als PLAY_CONFIG_JSON Variablen in GitLab hinzufügen

Deine GitLab CI/CD Pipeline einrichten

Erstellen Sie ein .gitlab-ci.yml-File am Wurzelort 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 an Ihre Projektsstruktur und -anforderungen anpassen. Diese Konfiguration hilft Ihnen, 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 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.

Fortsetzen Sie mit der automatischen Capacitor-Android-Bereitstellung mit GitLab

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

Automatischer Capacitor Android-Build mit GitLab