Automatischer Capacitor Android-Build mit GitHub Actions

Das Einrichten von CI/CD für Capacitor-Apps kann komplex und zeitaufwendig sein. Hier ist das Wichtigste:

Empfohlen für neue Builds: Nutze Capgo Build

Wir empfehlen jetzt Capgo Build mit Capgo CLI für native Capacitor Builds. Dieser Fastlane-Guide ist für Teams gedacht, die bestehende GitHub Actions Pipelines pflegen. Neue Android-Builds sollten jedoch Capgo CLI nutzen, damit ihr Fastlane, Gradle-Runner, Keystores und Upload-Skripte nicht selbst warten müsst.

Voraussetzungen

Bevor du startest, musst du Folgendes einrichten:

Ein GitHub Account mit Admin-Rechten
Deine App ist bereits mit korrekter Signatur im Google Play Store veröffentlicht
Android Signing Key und Keystore-Dateien
Google-Cloud-Console-Projekt mit aktiviertem Play Store API
Service Account mit den richtigen Berechtigungen
Grundkenntnisse in GitHub Actions Workflows
Kenntnisse in der Fastlane-Konfiguration
Zeit für die Wartung und das Debugging der Pipeline

Capgo Build für CI/CD von Capgo

Vergiss die Wartung von Fastlane, Gradle Runner, Keystore und Upload-Skripten. Capgo Build führt signierte Native Builds für Android direkt aus deiner CI/CD-Pipeline aus:

Läuft in deiner Pipeline: Trigger Capgo Build via GitHub Actions, GitLab CI, Jenkins oder lokale Skripte nach deinem Web-Build und npx cap sync.
Signing via CI-Secrets: Behalte Android Keystores, Key-Aliases, Passwörter und Play Console Service Account JSONs sicher in deinen CI-Secrets.
Kein Wartungsaufwand für Runner: Capgo Build bietet gewartete Android-Buildumgebungen, sodass du dich nicht um SDK Images, Gradle-Cache-Probleme oder Fastlane-Lanes kümmern musst.
Artefakte und Einreichung: Lade signierte Artefakte für QA herunter oder reiche Release-Builds über Capgo CLI ein.

Preise

Capgo-Pläne ab 12 $/Monat
Inklusive OTA-Updates und ca. 15 Native Builds pro Monat
Zusätzliche Build-Minuten werden minutengenau über Credits abgerechnet

Capgo Build in CI/CD einrichten

Manuelle Setup-Anleitung

Das müssen Sie tun:

GitHub Actions-Preise

Preis der GitHub Action

GitHub Actions bietet kostenlose Minuten je nach Repository-Typ:

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

Bei privaten Projekten liegen die Kosten bei ca. 0,008 $/Minute. Ein typischer Build dauert 3–5 Minuten.

Manuelle Setup-Schritte

Android Keystore erstellen
Google Play Service Account einrichten
Fastlane einrichten
GitHub Secrets konfigurieren
GitHub Actions-Workflow erstellen

1. Android Keystore erstellen

Bevor du deine Android-App signieren und veröffentlichen kannst, musst du eine Keystore-Datei erstellen. Das ist nur einmalig nötig.

Keystore mit keytool generieren

Führe diesen Befehl in deinem Terminal aus:

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

Du wirst nach Folgendem gefragt:

Keystore-Passwort: Wähle ein sicheres Passwort (du benötigst es als KEYSTORE_STORE_PASSWORD)
Key-Passwort: Wähle ein sicheres Passwort (du benötigst es als KEYSTORE_KEY_PASSWORD)
Dein Name, Organisation, etc.: Trage deine Daten ein

Wichtige Hinweise

Speichere diese Werte sicher:
- Pfad zur Keystore-Datei (z. B. my-release-key.keystore)
- Key-Alias (z. B. my-key-alias) – du benötigst es als KEYSTORE_KEY_ALIAS
- Keystore-Passwort – du benötigst es als KEYSTORE_STORE_PASSWORD
- Key-Passwort – das benötigst du als KEYSTORE_KEY_PASSWORD
Sichere die Keystore-Datei: Wenn du es verlierst, kannst du deine veröffentlichte App nicht mehr updaten
Halte es geheim: Die Keystore-Datei niemals in Git committen
Speichere es sicher: Erstelle mehrere Backups an sicheren Orten

Alternative: Vorhandenen Keystore nutzen

Falls du deine App bereits veröffentlicht hast, musst du denselben Keystore verwenden wie beim ersten Mal. Du findest ihn:

Auf deinem lokalen Rechner, auf dem du die App zuerst gebaut hast
In deiner Play Console → Setup → App-Signatur (falls Google Play App Signing genutzt wird)

2. Google Play Service Account einrichten

Um GitHub Actions das Hochladen von Builds zu Google Play zu ermöglichen, benötigst du ein Service Account.

Schritt 2.1: Google Cloud Projekt erstellen

Gehe zu Google Cloud Console
Neues Projekt erstellen oder bestehendes auswählen
Projekt-ID notieren

Schritt 2.2: Google Play Developer API aktivieren

Gehe in der Google Cloud Console zu APIs & Services → Library
Suche nach „Google Play Android Developer API“
Klicken Aktivieren

Schritt 2.3: Service Account erstellen

Gehe zu IAM & Admin → Service-Accounts
Klicken Service Account erstellen
Details eingeben:
- Name: github-actions-uploader
- Beschreibung: „Service Account für GitHub Actions zum Upload von Builds“
Klicken Erstellen und fortfahren
Rollenzuweisung vorerst überspringen (Klick Weiter, dann Fertig)

Schritt 2.4: Service Account Key erstellen

Klicke auf den neu erstellten Service Account
Gehe zu Keys Tab
Klicken Key hinzufügen → Neuen Key erstellen
Wähle JSON Format
Klicken Erstellen
Eine JSON-Datei wird heruntergeladen – speichere diese sicher, du wirst sie später benötigen

Schritt 2.5: Zugriff in der Play Console gewähren

Gehe zu die Google Play Console
Gehe zu Setup → API Zugriff
Unter Service-Accounts, klicke auf Zugriff gewähren für deinen Service-Account
Auf der App-Berechtigungen Tab, füge deine App hinzu
Auf der Account-Berechtigungen tab, erteile diese Berechtigungen:
- App-Infos einsehen und Massenberichte herunterladen (nur Lesezugriff)
- App-Entwürfe erstellen, bearbeiten und löschen
- Apps in Test-Tracks veröffentlichen
- Apps in Production, Exclude und anderen Tracks veröffentlichen
Klicken Nutzer einladen
Klicken Einladung senden

Schritt 2.6: JSON-Key verifizieren

Die heruntergeladene JSON-Datei sollte so 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 konvertierst das beim Einrichten der GitHub Secrets in Base64.

3. Fastlane einrichten

Erstelle ein fastlane Ordner in deinem Projekt-Root 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. GitHub Secrets konfigurieren

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

Schritt 4.1: Zugriff auf GitHub Secrets

Gehe zu deinem Repository auf GitHub
Klicken Einstellungen → Secrets und Variablen → Aktionen
Klicken Neues Repository-Secret

Schritt 4.2: Erforderliche Secrets hinzufügen

Füge jedes dieser Secrets einzeln hinzu:

PLAY_CONFIG_JSON

Nimm die Service-Account-JSON-Datei, die du in Schritt 2.4 heruntergeladen hast
Konvertiere sie in Base64:

Unter macOS/Linux:

base64 service_account_key.json | pbcopy

Unter Windows (PowerShell):

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

Erstelle ein neues Secret namens PLAY_CONFIG_JSON und füge den Base64-String ein

ANDROID_KEYSTORE_DATEI

Konvertiere deinen Keystore in Base64:

Unter macOS/Linux:

base64 my-release-key.keystore | pbcopy

Unter Windows (PowerShell):

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

Erstelle ein neues Secret namens ANDROID_KEYSTORE_FILE und füge den Base64-String ein

KEYSTORE_KEY_ALIAS

Erstelle ein neues Secret mit dem Key-Alias, den du beim Erstellen des Keystores verwendet hast (z. B. my-key-alias)

KEYSTORE_KEY_PASSWORT

Erstelle ein neues Secret mit dem Key-Passwort, das du beim Erstellen des Keystores festgelegt hast

KEYSTORE_STORE_PASSWORD

Erstelle ein neues Secret mit dem Keystore-Passwort, das du beim Erstellen des Keystores festgelegt hast

DEVELOPER_PACKAGE_NAME

Erstelle ein neues Secret mit dem Package-Namen deiner App (z. B. com.example.app)

Deinen Package-Namen findest du in android/app/build.gradle unter applicationId

Schritt 4.3: Alle Secrets überprüfen

Stelle sicher, dass diese 6 Secrets konfiguriert sind:

✅ PLAY_CONFIG_JSON
✅ ANDROID_KEYSTORE_FILE
✅ KEYSTORE_KEY_ALIAS
✅ KEYSTORE_KEY_PASSWORD
✅ KEYSTORE_STORE_PASSWORD
✅ DEVELOPER_PACKAGE_NAME

5. GitHub Actions Workflow erstellen

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

So funktioniert es

Git-Tag erstellen, um den Workflow zu triggern
GitHub Actions baut deine App
Fastlane lädt sie in den Google Play Beta-Channel hoch
Deine App wird automatisch aktualisiert

Build-Zeit und Kosten

Build-Zeit: 3–5 Minuten
Kosten für private Repos: ~$0,04 pro Build
Kostenlos für Open-Source-Projekte

CI/CD-Setup-Anleitungen

Automatisierter Capacitor iOS Build mit GitHub Actions - Komplette iOS CI/CD-Einrichtung
Automatischer Build und Release mit GitHub Actions - Tutorial zur vollständigen CI/CD-Pipeline
Dev- und Prod-Builds verwalten mit GitHub Actions - Environment-Management

Alternative CI/CD-Plattformen

Build mit GitLab CI - GitLab-Alternative für Android
Build mit CodeMagic - CodeMagic Setup-Guide

Live Updates & Deployment

Capgo Live Updates Dokumentation - OTA-Updates zu deiner App hinzufügen
CI/CD-Integration mit Capgo - Live-Updates in deine Pipeline integrieren

Ressourcen

Weiter mit automatischem Capacitor Android-Build via GitHub Actions

Wenn du es nutzt Automatischer Capacitor Android-Build mit GitHub Actions um CI/CD-Automatisierung zu planen, verbinde es mit Capgo CI/CD für den Produkt-Workflow in Capgo CI/CD, Capgo Native Builds optimieren für den Produkt-Workflow in Capgo Native Builds, Capgo Integrationen für den Produkt-Workflow in Capgo Integrations, CI/CD-Integration für die Implementierungsdetails in der CI/CD-Integration und GitHub Actions-Integration für die Implementierungsdetails in der GitHub Actions-Integration.