Automatische Capacitor-Android-Build mit GitHub-Aktionen

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

Empfohlen für Neubauten: Verwenden Sie Capgo-Build

Wir empfehlen nun die Verwendung von Capgo-Build mit der Capgo-CLI für native Capacitor-Bauten. Diese Anleitung für 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 ist bereits auf dem Google Play Store veröffentlicht und verfügt über eine ordnungsgemäße Signierung
• Android-Signierungs-Schlüssel und Keystore-Dateien
• Google Cloud Console-Projekt mit Play Store API aktiviert
• 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

Professionelle CI/CD-Einrichtung durch Capgo

Die Komplexität umgehen. Capgo Konfiguriert Ihre CI/CD-Pipeline direkt in Ihrer bevorzugten Plattform:

• Plattformunabhängigkeit: Funktioniert mit GitHub Actions, GitLab CI oder anderen
• Glattes Integration: Keine Plattformwechsel erforderlich, funktioniert mit Ihrem aktuellen Prozess
• Angepasste Konfiguration: Benutzerdefinierte Einrichtung, die den Bedürfnissen Ihres Projekts entspricht
• Experte Beratung: 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

Manuelle Einrichtungsanleitung

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

GitHub Aktionen Preis

GitHub Aktionen bieten kostenlose Minuten auf der Grundlage Ihres Repository-Typs an:

• Öffentliche Repositorys: 2.000 Minuten/Monat
• Private Repositorys: 2.000 Minuten/Monat (Linux-Runner)

Für private Projekte betragen die Kosten etwa 0,008 $/Minute. Ein typischer Build dauert 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 GitHub-Actions-Workflow

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)
• Schlüsselpasswort: Wählen Sie ein starkes Passwort (Sie benötigen dies als KEYSTORE_KEY_PASSWORD)
• Ihr Name, Organisation usw.: Füllen Sie Ihre Details ein

Wichtige Hinweise

• Speichern Sie diese Werte sicher:

  • Speicherort des Keystore-Dateis (z.B. my-release-key.keystore)
  • Schlüsselalias (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 es als KEYSTORE_KEY_PASSWORD

• Sichern Sie das Keystore-File: Wenn Sie es verlieren, können Sie Ihre veröffentlichte App nicht aktualisieren

• Halten Sie es geheim: Komitieren Sie das Keystore-File nie in Git

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

Alternative: Verwenden Sie ein bestehendes Keystore

Wenn Sie bereits Ihre App veröffentlicht haben, müssen Sie das gleiche Keystore verwenden, das Sie ursprünglich verwendet haben. Sie können es finden:

• Auf Ihrem lokalen Computer, an dem Sie die App zum ersten Mal gebaut haben
• In Ihrem Play-Console → Einstellungen → App-Zertifizierung (wenn Sie Google Play App-Zertifizierung verwenden)

2. Einrichten Sie Google Play Service-Konto

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

Schritt 2.1: Erstellen Sie ein Google Cloud Projekt

1. Gehe zu Google Cloud Console
2. Erstellen Sie ein neues Projekt oder wählen Sie eines aus, das bereits existiert
3. Beachten Sie die Projekt-ID

Schritt 2.2: Aktivieren Sie Google Play Developer API

1. In der Google Cloud Console gehen Sie zu APIs & Dienste → Bibliothek
2. Suchen Sie nach „Google Play Android Developer API“
3. Klicken Sie Aktivieren

Schritt 2.3: Erstellen Sie einen Dienstkontoadministrator

1. Gehe zu IAM & Admin → Dienstkonten
2. Klicken Sie Dienstkontoadministrator erstellen
3. Details eingeben:
   • Name: github-actions-uploader
   • Beschreibung: „Dienstkonto für GitHub Aktionen zum Hochladen von Builds“
4. Klicken Sie Erstellen und fortfahren
5. Skip die Rolenzuweisung für den Moment (klicken Fortsetzen, dann Fertig)

Schritt 2.4: Erstellen Sie eine Dienstkontozertifikatschlüssel

1. Klicken Sie auf das neu erstellte Dienstkonto
2. Gehe zu Schlüssel Registerkarte
3. Klicken Schlüssel hinzufügen → Neuen Schlüssel erstellen
4. Wählen Sie JSON-Format Format
5. Klicken Sie Erstellen
6. Ein JSON-Datei wird heruntergeladen - speichern Sie dies sicher, Sie benötigen es später Schritt 2.5: Zugriff in Play Console gewährenGehe zu

Google Play Console

1. Gehe zu Schritt 2.5: Zugriff in Play Console gewähren
2. Gehe zu Google Play Console Einrichtung → API Zugriff
3. Unter Dienstkonten, klicken Sie Zugriff gewähren für Ihre Dienstkonto
4. Auf der Anwendungsrechte Registerkarte fügen Sie Ihrer Anwendung
5. Auf der Kontorechte Zugriffsrechte erteilen:
   • Anwendungsinformationen anzeigen und große Berichte herunterladen (nur Lesen)
   • Entwicklungsanwendungen erstellen, bearbeiten und löschen
   • Anwendungen auf Testtracks freigeben
   • Anwendungen auf Produktions-, Ausschluss- und anderen Tracks freigeben
6. Klicken Benutzer einladen
7. Klicken Einladung senden

Schritt 2.6: JSON-Schlüssel überprüfen

Das heruntergeladene JSON-File 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 dies in der GitHub-Geheimnisse-Einstellungsschritt in Base64 umwandeln.

3. Einrichten von Fastlane

Erstelle einen fastlane Ordner in deinem Projektroot und füge einen 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. Konfiguration von GitHub-Geheimnissen

Da du nun dein Keystore und dein Service-Account-JSON hast, musst du sie sicher in GitHub speichern.

Schritt 4.1: Zugriff auf GitHub-Geheimnisse

1. Gehe zu deinem Repository auf GitHub
2. Klicke Einstellungen → Geheimnisse und Variablen → Aktionen
3. Klicken Sie Neuer Repository-Schlüssel

Schritt 4.2: Fügen Sie erforderliche Geheimnisse hinzu

Fügen Sie jedes dieser Geheimnisse einzeln hinzu:

PLAY_CONFIG_JSON

1. Nehmen Sie das JSON-Datei des Dienstkontos, das Sie in Schritt 2.4 heruntergeladen haben
2. Konvertieren Sie es in Base64:

Auf macOS/Linux:

base64 service_account_key.json | pbcopy

Auf Windows (PowerShell):

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

3. Erstellen Sie einen neuen geheimen Schlüssel mit dem Namen PLAY_CONFIG_JSON und fügen Sie den Base64-String ein

ANDROID_KEYSTORE_FILE

1. Ihre Keystore umwandeln 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. Erstellen Sie ein neues Geheimnis mit dem Namen ANDROID_KEYSTORE_FILE und fügen Sie die Base64-Zeichenfolge ein

KEYSTORE_KEY_ALIAS

Erstellen Sie ein neues Geheimnis mit dem Alias für die Schlüssel, den Sie verwendet haben, als Sie die Keystore erstellten (z.B., my-key-alias)

KEYSTORE_KEY_PASSWORD

Erstellen Sie ein neues Geheimnis mit dem Schlüsselpasswort, das Sie bei der Erstellung der Keystore gesetzt haben

KEYSTORE_STORE_PASSWORD

Erstellen Sie ein neues Geheimnis mit dem Passwort für die Keystore, das Sie bei der Erstellung gesetzt haben

DEVELOPER_PACKAGE_NAME

Erstellen Sie ein neues Geheimnis mit dem Paketnamen Ihrer 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:

• ✅ PLAY_CONFIG_JSON
• ✅ ANDROID_KEYSTORE_FILE
• ✅ KEYSTORE_KEY_ALIAS
• ✅ KEYSTORE_KEY_PASSWORD
• ✅ KEYSTORE_STORE_PASSWORD
• ✅ ENTWICKLER_PAKETNAME

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

Wie es funktioniert

1. Erstellen Sie einen Git-Tag, um den Workflow auszulösen
2. GitHub Aktionen baut Ihr App
3. Fastlane lädt es in den Google Play Beta-Kanal hoch
4. Ihre 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-Einrichtungshandbücher

• Automatische Capacitor iOS-Build mit GitHub Aktionen - Vollständige iOS CI/CD-Einrichtung
• Automatische Build- und Release-Prozesse mit GitHub Aktionen - Vollständiger CI/CD-Pipeline-Leitfaden
• Verwalte Dev- und Prod-Builds mit GitHub Aktionen - Umgebungsverwaltung

Alternative CI/CD-Plattformen

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

Live-Updates und Bereitstellung

• Capgo Live Updates Dokumentation - Hinzufügen von Live-Updates zu Ihrer App
• CI/CD-Integration mit Capgo - Integrieren von Live-Updates in Ihrem Pipeline

Ressourcen

• GitHub Actions Dokumentation
• Fastlane Dokumentation