Automatischer Capacitor-Build mit GitHub-Aktionen

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 Neubauten: Verwenden Sie Capgo-Build

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

Voraussetzungen

Bevor Sie beginnen, müssen Sie Folgendes einrichten:

Eine GitHub-Konto mit Administratorzugriff
Ihr bereits veröffentlichtes App auf dem Google Play Store mit korrekter Signierung
Android-Signierungs-Schlüssel und Keystore-Dateien
Ein Google Cloud Console-Projekt mit Play Store API aktiviert
Konto mit ausreichenden Berechtigungen
Verständnis von GitHub Actions Workflows
Wissen über die Fastlane-Konfiguration
Zeit für die 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 aus:

Funktioniert 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.
Signieren von CI-Secrets: Halten Sie Android-Keystores, Schlüsselalias, Passwörter und Play-Console-Dienstkonten-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.
Artikel und Einreichung: Laden Sie signierte Artikel für QA oder übermitteln Sie Release-Builds über die Capgo CLI.

Preise

Capgo-Pläne beginnen bei 12 $/Monat
__CAPGO_KEEP_0__-Pläne beginnen bei 12 $/Monat
Zusätzliche Build-Minuten werden nach Minute über Krediten abgerechnet

Capgo in CI/CD einrichten

Manuelle Einrichtungsanleitung

Hier ist, was Sie tun müssen:

GitHub-Actions-Preise

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)
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 aus

Wichtige Hinweise

Speichern Sie diese Werte sicher:
- Schlüsselbankdatei-Ort (z.B. my-release-key.keystore)
- Alias für den Schlüssel (z.B. my-key-alias) - Sie benötigen dies als KEYSTORE_KEY_ALIAS
- Schlüsselbankpasswort - Sie benötigen dies als KEYSTORE_STORE_PASSWORD
- Passwort für den Schlüssel - Sie benötigen dies als KEYSTORE_KEY_PASSWORD
Die Schlüsselbankdatei sichern : Wenn Sie sie verlieren, können Sie Ihre veröffentlichte App nicht aktualisieren
Es ist ein Geheimnis : Kommitieren Sie die Schlüsselbankdatei nie in Git
Sichere Ort speichern : Halten Sie mehrere Sicherungskopien in sicheren Orten

Alternative: Eine bestehende Schlüsselbank verwenden

Wenn Sie Ihre App bereits 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, die Builds auf Google Play hochzuladen, benötigen Sie ein Dienstkonto.

Schritt 2.1: Erstellen Sie ein Google Cloud-Projekt

Gehen Sie zu Google Cloud Console
Erstellen Sie ein neues Projekt oder wählen Sie ein bestehendes Projekt aus
Haben Sie sich das Projekt-ID notiert?

Schritt 2.2: Aktivieren Sie Google Play Developer API

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

Schritt 2.3: Erstellen Sie einen Dienstkonten

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

Schritt 2.4: Erstellen Sie eine Dienstkonten-Schlüssel

Klicken Sie auf das neu erstellte Dienstkonto
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 Anwendungsrechte Registerkarte, fügen Sie Ihrer App hinzu
Auf der Konto-Rechte Registerkarte, erteilen Sie diese Rechte:
- Anzeigen von App-Informationen und herunterladen von Massenberichten (nur Lesen)
- Erstellen, bearbeiten und Löschen von Entwurfs-Apps
- Apps auf Test-Tracks freigeben
- Apps auf Produktions-Tracks, Ausschluss und andere Tracks freigeben
Klicken Benutzer einladen
Klicken 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 Ordner in deinem Projektroot und füge einen mit diesem Inhalt hinzu: fastlane 4. __CAPGO_KEEP_0__-Geheimnisse einrichten Fastfile Jetzt hast du deinen Keystore und dein Dienstkontoinformationen in JSON, du musst sie sicher in __CAPGO_KEEP_0__ speichern.

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

Schritt 4.1: GitHub-Geheimnisse zugreifen

Gehe zu deinem Repository auf GitHub

Step 4.1: Access GitHub Secrets

Go to your repository on GitHub
Klicken Einstellungen → Geheime Werte und Variablen → Aktionen
Klicken Neuer Repository-Geheimcode

Schritt 4.2: Fügen Sie erforderliche Geheimcodes hinzu

Fügen Sie jeden dieser Geheimcodes einzeln hinzu:

PLAY_CONFIG_JSON

Nehmen Sie die JSON-Datei des Dienstkontos, die Sie in Schritt 2.4 heruntergeladen haben
Konvertieren Sie sie in Base64:

Auf macOS/Linux:

base64 service_account_key.json | pbcopy

On 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:

On macOS/Linux:

base64 my-release-key.keystore | pbcopy

On 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 generierten (z.B. my-key-alias)

KEYSTORE_KEY_PASSWORD

Erstelle ein neues Geheimnis mit der Schlüsselwort, das du gesetzt hast, als du den Keystore generiert hast

KEYSTORE_STORE_PASSWORD

Erstelle ein neues Geheimnis mit dem Keystore-Schlüsselwort, das du gesetzt hast, als du den Keystore generiert hast

DEVELOPER_PACKAGE_NAME

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

Du kannst deinen Paketnamen in android/app/build.gradle unter applicationId

Schritt 4.3: Überprüfe alle Geheimnisse

Stelle sicher, dass du diese 6 Geheimnisse konfiguriert hast:

✅ 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 ein Git-Tag, 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-Einrichtungsanleitungen

Automatische Capacitor iOS-Builds mit GitHub Aktionen - Vollständige iOS-CI/CD-Einrichtung
Automatische 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

Wenn Sie diese Funktion verwenden Automatische Capacitor-Android-Builds mit GitHub-Aktionen um die CI/CD-Automatisierung zu planen, verbinden Sie sie 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 für die Implementierungsdetails in CI/CD-Integration, und GitHub-Aktionenintegration Für die Implementierungsdetails in GitHub Actions Integration.

Automatische Capacitor-Android-Build mit GitHub-Aktionen