Automatischer Capacitor Android-Build mit GitHub-Actions

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

Empfohlen für Neue Builds: Verwenden Sie Capgo Build

Wir empfehlen nun die Verwendung von Capgo Build mit der Capgo CLI zur Erstellung von nativen Capacitor-Apps. Dieser Fastlane-Leitfaden wird für Teams beibehalten, die bestehende GitHub-Actions-Pipelines weiterhin unterhalten, aber neue Android-Builds sollten die Capgo CLI verwenden, damit Sie keine Fastlane, Gradle-Runner, Keystores und Upload-Skripte selbst pflegen müssen.

Voraussetzungen

Bevor Sie beginnen, müssen Sie Folgendes einrichten:

Eine GitHub-Konto mit Administratorzugriff
Ihr App bereits auf dem Google Play Store veröffentlicht mit korrekter Signierung
Android-Signierungs-Schlüssel und Keystore-Dateien
Einen Google Cloud Console-Projekt mit Play Store API aktiviert
Konto mit angemessenen Berechtigungen
Verständnis von GitHub Actions Workflows
Wissen über die Konfiguration von Fastlane
Zeit zur Wartung und Fehlersuche im Pipeline

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 von Capgo Build von GitHub Actions, GitLab CI, Jenkins oder lokalen Skripten nach Ihrem Web-Build und npx cap sync.
Signieren aus CI-Secrets: Halten Sie Android-Keystores, Schlüsselalias, Passwörter und Play-Console-Dienstkonto-JSON in Ihren eigenen CI-Secrets.
No native runner upkeep: Capgo Build bietet gepflegte Android-Buildumgebungen, sodass Sie keine SDK-Bilder, Gradle-Cache-Probleme oder Fastlane-Linien verwalten müssen.
Artifacts und Submission: Laden Sie signierte Artefakte für QA oder übermitteln Sie Release-Builds über die Capgo CLI.

Preise

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

Set up Capgo Build in CI/CD

Einrichten von __CAPGO_KEEP_0__ Build in CI/CD

Manueller Setup-Leitfaden

GitHub Actions Pricing

Preis GitHub Action

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

Ö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

Erstellen Sie einen Android-Keystore
Konfigurieren Sie die Google Play Service-Konto
Konfigurieren Sie Fastlane
Konfigurieren Sie GitHub-Geheimnisse
Erstellen Sie eine GitHub-Actions-Arbeit

1. Erstellen Sie einen Android-Keystore

Bevor Sie Ihre Android-App signieren und veröffentlichen können, müssen Sie ein Keystore-File erstellen. Dies ist eine einmalige Einstellung.

Keystore mit keytool generieren

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

Wichtige Hinweise

Speichern Sie diese Werte sicher:
- Sicherheitsdatei-Ort (z.B. my-release-key.keystore)
- Alias für die Sicherheitsdatei (z.B. my-key-alias) - Sie benötigen dies als KEYSTORE_KEY_ALIAS
- Sicherheitsdateipasswort - Sie benötigen dies als KEYSTORE_STORE_PASSWORD
- Sicherheitsdateipasswort - Sie benötigen dies als KEYSTORE_KEY_PASSWORD
Sichere die Sicherheitsdatei: Wenn Sie sie verlieren, können Sie Ihre veröffentlichte App nicht aktualisieren
Halten Sie es geheim: Kommitieren Sie die Sicherheitsdatei nie in Git
Sichern Sie es sicher: Halten Sie mehrere Sicherungskopien in sicheren Orten

Alternative: Verwenden Sie eine bestehende Sicherheitsdatei

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

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

2. Einrichten Sie das Google Play Service-Konto

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

Schritt 2.1: Erstellen Sie ein Google Cloud Projekt

Gehe zu Google Cloud Console
Erstellen Sie ein neues Projekt oder wählen Sie ein bestehendes Projekt aus
Hinweis: Notieren Sie sich die Projekt-ID

Schritt 2.2: Aktivieren Sie Google Play Developer API

In Google Cloud Console, gehe zu APIs & Dienstleistungen → Bibliothek
Suchen Sie nach “Google Play Android-Entwickler API”
Klicken Sie Aktivieren

Schritt 2.3: Erstellen Sie einen Dienstkontoadministratoren

Gehe zu IAM & Admin → Dienstkontoadministratoren
Klicken Sie Erstellen Sie einen Dienstkontoadministratoren
Eingaben machen:
- Name: github-actions-uploader
- Beschreibung: „Dienstkonten für GitHub-Actions zum Hochladen von Builds”
Klicken Erstellen und Fortsetzen
Rollenzuweisung für jetzt überspringen (klicken Fortsetzen, dann Fertig)

Schritt 2.4: Erstellen Sie einen Dienstkonten-Schlüssel

Klicken Sie auf das neu erstellte Dienstkonten
Zu Schlüssel Registerkarte
Klicken Sie Schlüssel hinzufügen → Neuen Schlüssel erstellen
Wählen Sie JSON-Format Klicken Sie
Erstellen Ein JSON-Datei wird heruntergeladen -
speichern Sie dies sicher Sie benötigen es späterSie benötigen es später

Schritt 2.5: Zugriffsrechte in Play Console erteilen

Gehe zu Google Play Console
Gehe zu Einstellungen → API Zugriff
Unter Dienstkonten, klicke Zugriffsrechte erteilen für deine Dienstkonto
auf das Zugriffsrechte der App Registerkarte, fügen Sie Ihrer App hinzu
Auf der Kontozugriffsrechte Registerkarte, erteilen Sie diese Berechtigungen:
- Anzeigen von App-Informationen und herunterladen von Massenberichten (nur Lesen)
- Erstellen, bearbeiten und Löschen von Entwurfs-Apps
- Apps auf Testtracks freigeben
- Apps auf Produktions-, Ausschluss- und andere Tracks freigeben
Klicken Sie Benutzer einladen
Klicken Sie Einladung senden

Schritt 2.6: Überprüfe die JSON-Schlüssel

Das 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": "..."
}

Du wirst dies in der GitHub-Geheimnisse-Einstellungsschritt in Base64 umwandeln.

3. Fastlane einrichten

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

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. GitHub-Geheimnisse einrichten

Jetzt hast du deinen Keystore und dein Dienstkonten-JSON, du musst sie sicher in GitHub speichern.

Schritt 4.1: GitHub-Geheimnisse zugreifen

Gehe zu deinem Repository auf GitHub
Klicken Einstellungen → Geheime Werte und Variablen → Aktionen
Klicken Neuer Repository-Schlüssel

Schritt 4.2: Hinzufügen von erforderlichen Geheimnissen

Fügen Sie jedes dieser Geheimnisse einzeln hinzu:

PLAY_CONFIG_JSON

Nehmen Sie das JSON-Datei des Dienstkontos, das Sie in Schritt 2.4 heruntergeladen haben
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

Erstellen Sie ein neues Geheimnis mit dem Namen PLAY_CONFIG_JSON und fügen Sie die Base64-Zeichenfolge ein

ANDROID_KEYSTORE_FILE

Konvertieren Sie Ihr 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

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 Schlüsselalias, den Sie verwendet haben, wenn Sie das Keystore generiert haben (z.B. my-key-alias)

KEYSTORE_KEY_PASSWORD

Erstellen Sie ein neues Geheimnis mit der Schlüsselwort, das Sie bei der Erstellung des Keystores festgelegt haben

KEYSTORE_STORE_PASSWORD

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

DEVELOPER_PACKAGE_NAME

Erstellen Sie ein neues Geheimnis mit Ihrem Anwendungs-Paketnamen (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
✅ SCHRIFTENKASTEN-SCHLÜSSELWORT
✅ SCHRIFTENKASTEN-LAGERSCHLÜSSELWORT
✅ ENTWICKLER-PAKETNAME

5. Erstelle GitHub Actions Workflow

Erstelle .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

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

Zeit und Kosten für die Erstellung

Erstellungszeit: 3-5 Minuten
Kosten für private Repositories: ~$0.04 pro Build
Kostenlos für Open-Source-Projekte

CI/CD-Einrichtungshilfen

Automatischer Capacitor iOS-Build mit GitHub Aktionen - Vollständige iOS-CI/CD-Einrichtung
Automatischer Build und Release mit GitHub Aktionen - Vollständiger CI/CD-Pipeline-Tutorial
Verwaltung von Dev- und Prod-Builds mit GitHub Aktionen - Umgebungsverwaltung

Alternative CI/CD-Plattformen

Build mit GitLab CI - GitLab Alternative für Android
Mit CodeMagic bauen - Anleitung zur CodeMagic-Einrichtung

Live-Updates und Bereitstellung

Capgo Live-Updates-Dokumentation - OTA-Updates in Ihre App hinzufügen
CI/CD-Integration mit Capgo - Live-Updates in Ihrem Pipeline integrieren

Ressourcen

Keep going from Automatic Capacitor Android build with GitHub actions

If Sie __CAPGO_KEEP_0__ verwenden Automatische GitHub Android-Builds mit Capacitor-Aktionen um die CI/CD-Automatisierung zu planen, verbinden Sie es mit Capgo CI/CD für den Produktworkflow in Capgo CI/CD, Capgo Native Builds für den Produktworkflow in Capgo Native Builds, Capgo Integrations für den Produktworkflow in Capgo Integrations, CI/CD-Integration __CAPGO_KEEP_0__ Actions-Integration GitHub für die Implementierungsdetails in GitHub Actions-Integration.

Automatische Capacitor-Android-Build mit GitHub-Aktionen