Automatische Capacitor-Android-Builds mit GitHub-Actions

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

Empfohlen für Neubauten: Verwenden Sie Capgo Build

Wir empfehlen nun die Verwendung Capgo Build mit der Capgo CLI für native Capacitor-Bauten. Diese Anleitung zu Fastlane wird für Teams aufrechterhalten, die bestehende GitHub-Actions-Pipelines weiterhin pflegen, aber neue Android-Builds sollten die Capgo- CLI verwenden, damit Sie Fastlane, Gradle-Runner, Keystores und Upload-Skripte nicht selbst pflegen müssen.

Voraussetzungen

Bevor Sie beginnen, müssen Sie Folgendes einrichten:

• Ein GitHub-Konto mit Administrator-Zugriff
• Ihre App bereits auf dem Google Play Store veröffentlicht mit korrekter Signierung
• 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 GitHub-Actions-Workflows
• Kenntnisse in der Fastlane-Konfiguration
• Zeit, um den Pipeline zu pflegen 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 führt signierte native Android-Builds aus Ihrem bestehenden CI/CD-Pipeline:

• Arbeitet mit Ihrer Pipeline: Auslösen Sie Capgo Build von GitHub Actions, GitLab CI, Jenkins oder lokalen Skripten nach Ihrem Web-Build und npx cap sync.
• Signierung aus CI-SecretsHalte Android-Keystores, Alias, Passwörter und Play Console-Dienstkontoinformationen in deinen eigenen CI-Secrets.
• Keine native Runner-Wartung: Capgo Build bietet gepflegte Android-Build-Umgebungen, sodass Sie keine SDK-Images, Gradle-Cache-Probleme oder Fastlane-Linien verwalten müssen.
• Artikel und Einreichung: Laden Sie signierte Artikel für QA herunter oder einreichen Sie Release-Builds über die Capgo CLI.

Preise

• Capgo-Pläne beginnen bei 12 $/Monat
• Enthalten sind OTA-Updates und etwa 15 native Builds pro Monat
• Zusätzliche Build-Minuten werden nach Minute über Krediten abgerechnet

Einstellen Sie die Capgo-Build in CI/CD

__CAPGO_KEEP_0__-Build in CI/CD einrichten

Anleitung zur manuellen Einrichtung

GitHub Aktionen Preisgestaltung

GitHub Actions bietet kostenlose Minuten basierend auf Ihrem Repository-Typ:

• Öffentliche Repositories: 2.000 Minuten/Monat
• Öffentliche Repositorys: 2.000 Minuten/Monat

Für private Projekte betragen die Kosten etwa 0,008 $/Minute. Eine typische Build-Dauer liegt bei 3-5 Minuten.

Manuelle Einrichtungsschritte

1. Erstellen Sie einen Android-Keystore
2. Einrichten Sie ein Google Play Service-Konto
3. Einrichten Sie Fastlane
4. Konfigurieren Sie GitHub-Geheimnisse
5. Erstellen Sie eine GitHub-Actions-Arbeit

1. Erstellen Sie einen Android-Keystore

Bevor Sie Ihr Android-App signieren und veröffentlichen können, müssen Sie einen Keystore-Datei erstellen. Dies ist eine einmalige Einrichtung.

Erstellen Sie einen Keystore mit keytool

Führen Sie diesen Befehl in Ihrem Terminal aus:

keytool -genkey -v -keystore my-release-key.keystore -alias my-key-alias -keyalg RSA -keysize 2048 -validity 10000

Sie werden aufgefordert:

• Keystore-Passwort: Wählen Sie ein starkes Passwort (Sie benötigen dies als KEYSTORE_STORE_PASSWORD)
• Sicherheitspasswort: Wählen Sie ein starkes Passwort (Sie benötigen dies als KEYSTORE_KEY_PASSWORD)
• Ihr Name, Organisation usw.: Füllen Sie Ihre Details

Wichtige Hinweise

• Sichern Sie diese Werte sicher:

  • Speicherort des Keystore-Dateis (z.B. my-release-key.keystore)
  • Alias des Schlüssels (z.B. my-key-alias) - Sie benötigen dies als KEYSTORE_KEY_ALIAS
  • Keystore-Passwort - Sie benötigen dies als KEYSTORE_STORE_PASSWORD
  • Sicherheitspasswort - Sie benötigen dies als KEYSTORE_KEY_PASSWORD

• Die Keystore-Datei sichern: Wenn Sie sie verlieren, können Sie Ihre veröffentlichte App nicht aktualisieren

• Behalten Sie es geheim: Kommitieren Sie die Keystore-Datei nie in Git

• Sichern Sie es sicher: Halten Sie mehrere Sicherungskopien in sicheren Orten

Alternative: Verwendung bestehender Keystore

: Wenn Sie bereits Ihre App veröffentlicht haben, müssen Sie denselben Keystore verwenden, den Sie ursprünglich verwendet haben. Sie können ihn finden:

• Auf Ihrem lokalen Computer, an dem Sie das App erstellten
• In your Play Console → Setup → App signing (if using Google Play App Signing)

2. Einrichten von Google Play Service Account

: Um GitHub-Aktionen zu ermöglichen, Builds auf Google Play hochzuladen, benötigen Sie ein Dienstkonto.

Schritt 2.1: Erstelle Google Cloud Projekt

1. Gehe zu Google Cloud Console
2. Erstelle ein neues Projekt oder wähle eines bestehenden
3. Hinweis die Projekt-ID

Schritt 2.2: Aktiviere Google Play Entwickler API

1. In Google Cloud Console, gehe zu Dienste & APIs → Bibliothek
2. Suche nach „Google Play Android Entwickler API“
3. Klicken Aktivieren

Schritt 2.3: Erstellen Sie einen Dienstkontoadministrativen

1. Zum IAM & Admin → Dienstkonten
2. Klicken Sie Erstellen Sie Dienstkonto
3. Eingabedaten eingeben:
   • Name: github-actions-uploader
   • Beschreibung: „Dienstkonto für GitHub-Aktionen zum Hochladen von Builds“
4. Klicken Sie Erstellen und fortfahren
5. Klicken Sie auf "Skip role assignment for now" Fortschritt, dann Erledigt)

Schritt 2.4: Erstelle Dienstkontoschlüssel

1. Klicken Sie auf die neu erstellte Dienstkonten.
2. Gehe zu Gehe zu Schlüssel
3. Registerkarte Klicken Sie → Hinzufügen
4. Choose JSON Format
5. Klicken Erstellen
6. Eine JSON-Datei wird heruntergeladen - Speichern Sie dies sicherSie benötigen es später

Schritt 2.5: Zugriff in Play Console gewähren

1. Gehe zu Google Play Console
2. Gehe zu Einstellungen → API Zugriff
3. Unter Dienstkonten, klicken Zugriff erteilen für Ihr Dienstkonto
4. Auf der Anwendungsrechte Registerkarte, fügen Sie Ihrer Anwendung
5. Auf der Konto-Berechtigungen Registerkarte, erteilen Sie diese Rechte:
   • Anwendungsinformationen anzeigen und große Berichtsdateien herunterladen (nur Lesen)
   • Create, edit, and delete draft apps
   • Apps auf Testtracks freigeben
   • Apps auf Produktions-, Ausschluss- und andere Tracks freigeben
6. Klicken Benutzer einladen
7. Klicken Einladung senden

Schritt 2.6: Überprüfen Sie die JSON-Schlüssel

Die heruntergeladene JSON-Datei sollte wie folgt aussehen:

{
  "type": "service_account",
  "project_id": "your-project-id",
  "private_key_id": "...",
  "private_key": "-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n",
  "client_email": "github-actions-uploader@your-project-id.iam.gserviceaccount.com",
  "client_id": "...",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "..."
}

Sie werden diese in der GitHub-Geheimnisse-Konfigurationsschritt in Base64 umwandeln.

3. Fastlane einrichten

Erstelle ein fastlane Ordner an deinem Projektroot und füge ein Fastfile mit diesem Inhalt:

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'])
        
        # Get previous build number and increment
        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}")
        
        # Build the app
        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
        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
end

4. Konfiguriere GitHub-Geheimnisse

Jetzt, da du dein Keystore und dein Service-Konto-JSON hast, musst du sie sicher in GitHub speichern.

Schritt 4.1: Zugriff auf GitHub-Geheimnisse

1. Gehe zu deinem Repository auf GitHub
2. Click Klicke → Geheimnisse und Variablen → Actions
3. Click Neues Repository-Secret

Schritt 4.2: Hinzufügen von erforderlichen Geheimnissen

Fügen Sie diese Geheimnisse nacheinander hinzu:

Hinzufügen Sie diese Geheimnisse einzeln hinzufügen:

1. Laden Sie das JSON-Datei des Dienstkontos, das Sie in Schritt 2.4 heruntergeladen haben.
2. Wandeln Sie es in Base64 um:

Konvertieren Sie es in Base64:

base64 service_account_key.json | pbcopy

Unter macOS/Linux:

[Convert]::ToBase64String([IO.File]::ReadAllBytes("service_account_key.json")) | Set-Clipboard

3. Unter Windows (PowerShell): PLAY_CONFIG_JSON Erstellen Sie ein neues Geheimnis mit dem Namen

und fügen Sie die Base64-Zeichenfolge ein

1. Konvertieren Sie Ihren Keystore in Base64:

Auf macOS/Linux:

base64 my-release-key.keystore | pbcopy

Auf Windows (PowerShell):

[Convert]::ToBase64String([IO.File]::ReadAllBytes("my-release-key.keystore")) | Set-Clipboard

2. Erstelle ein neues Geheimnis mit dem Namen ANDROID_KEYSTORE_FILE und füge den Base64-String ein

SCHLÜSSELWORT_ALIASE

Erstellen Sie ein neues Geheimnis mit dem Schlüsselalias, den Sie bei der Erstellung des Keystores verwendet haben (z.B.). my-key-alias)

Keystore-Schlüssel-Passwort

Erstelle ein neues Geheimnis mit dem Passwort der Schlüssel, das du gesetzt hast, wenn du den Keystore generiert hast

Keystore-Speicherpasswort

Erstellen Sie ein neues Geheimnis mit dem Keystore-Passwort, das Sie bei der Erstellung des Keystores festgelegt haben.

DEVELOPER_PACKAGE_NAME

Erstelle ein neues Geheimnis mit dem Paketnamen deiner App (z.B. com.example.app)

Sie finden Ihren Paketnamen in android/app/build.gradle unter applicationId

Schritt 4.3: Überprüfen Sie alle Geheimnisse

Stellen Sie sicher, dass Sie diese 6 Geheimnisse konfiguriert haben:

• ✅ Konfigurationsdatei laden
• ✅ ANDROID_KEYSTORE_DATEI
• ✅ Zertifikatschlüssel-Bezeichner
• ✅ Schlüsselkette-Schlüsselpasswort
• ✅ Keystore-Speicherpwort
• ✅ Entwickler-Paket-Name

5. Erstellen Sie GitHub Actions Workflow

Erstellen .github/workflows/build-upload-android.yml:

name: Build and Deploy Android App

on:
  push:
    tags:
      - '*'

jobs:
  build_android:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      
      - name: Setup Node.js
        uses: actions/setup-node@v6
        with:
          node-version: 24
          cache: npm
          
      - name: Install dependencies
        run: npm ci
        
      - name: Cache Gradle
        uses: actions/cache@v5
        with:
          path: |
            ~/.gradle/caches
            ~/.gradle/wrapper
          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
          restore-keys: |
            ${{ runner.os }}-gradle-
            
      - name: Build app
        run: npm run build
        
      - name: Sync Capacitor
        run: npx cap sync
        
      - name: Setup Java
        uses: actions/setup-node@v5
        with:
            distribution: 'zulu'
            java-version: '17'
            
      - name: Setup Ruby
        uses: ruby/setup-ruby@v1
        with:
          ruby-version: '3.0'
          bundler-cache: true
          
      - name: Run Fastlane
        uses: maierj/fastlane-action@v3.1.0
        env:
          PLAY_CONFIG_JSON: ${{ secrets.PLAY_CONFIG_JSON }}
          ANDROID_KEYSTORE_FILE: ${{ secrets.ANDROID_KEYSTORE_FILE }}
          DEVELOPER_PACKAGE_NAME: ${{ secrets.DEVELOPER_PACKAGE_NAME }}
          KEYSTORE_KEY_ALIAS: ${{ secrets.KEYSTORE_KEY_ALIAS }}
          KEYSTORE_KEY_PASSWORD: ${{ secrets.KEYSTORE_KEY_PASSWORD }}
          KEYSTORE_STORE_PASSWORD: ${{ secrets.KEYSTORE_STORE_PASSWORD }}
        with:
          lane: android beta
          
      - name: Upload artifact
        uses: actions/upload-artifact@v2
        with:
          name: android-release
          path: ./android/app/build/outputs/bundle/release/app-release.aab
          retention-days: 10

How es funktioniert

1. Erstelle eine Git-Tag, um den Workflow auszulösen
2. GitHub Actions baut dein App
3. Fastlane lädt es in den Google Play Beta-Kanal hoch
4. Deine App wird automatisch aktualisiert

Buildzeit und Kosten

• Buildzeit: 3-5 Minuten
• Kosten für private Repositories: ~0,04 $ pro Build
• Kostenlos für Open-Source-Projekte

Zugehörige Artikel

CI/CD-Einrichtungsleitfäden

• Automatische Capacitor iOS-Build mit GitHub Actions - Vollständige iOS CI/CD-Einrichtung
• Automatische Build- und Release-Vorgänge mit GitHub-Actions - Vollständiger CI/CD-Pipeline-Tutorial
• Verwaltung von Entwicklungs- und Produktionsbuilds mit GitHub-Actions - Umgebungsverwaltung

Alternative CI/CD-Plattformen

• Mit GitLab CI bauen - GitLab-Alternative für Android
• Mit CodeMagic bauen - CodeMagic-Einrichtungshandbuch

Live-Updates und Bereitstellung

• Capgo-Dokumentation zu Live-Updates - App-Updates über das Internet hinzufügen
• - Integration mit Capgo in CI/CD - Live-Updates in deinem Pipeline integrieren

Ressourcen

• GitHub Aktionen-Dokumentation
• __CAPGO_KEEP_0__-Aktionen-Dokumentation

Weitermachen mit der automatischen Capacitor Android-Build-Workflow mit GitHub Aktionen

Fortsetzung von der automatischen __CAPGO_KEEP_0__-Android-Build mit __CAPGO_KEEP_1__-Aktionen Automatische Capacitor-Android-Build mit GitHub-Aktionen um die CI/CD-Automatisierung zu planen, mit ihr zu verbinden Capgo CI/CD für den Produktworkflow in Capgo CI/CD, Capgo nativee Native Builds für das Produktworkflow in Capgo Native Builds Capgo Integrations für das 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