Automatische Capacitor Android-Build mit GitHub Aktionen

Die Einrichtung von CI/CD 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 Fastlane-Anleitung wird für Teams beibehalten, 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 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 mit einer gültigen Signatur versehen
• Android-Signierungs-Schlüssel und Keystore-Dateien
• Ein Google Cloud Console-Projekt mit Play Store API aktiviert
• Ein Dienstkonto mit den richtigen Berechtigungen
• Verständnis der GitHub-Actions-Workflows
• Kenntnisse in der Fastlane-Konfiguration
• Zeit, um den Pipeline zu warten 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 von Ihrem bestehenden CI/CD-Pipeline aus signierte native Android-Builds durch:

• Funktioniert mit Ihrem Pipeline: Auslösen Capgo Build von GitHub Actions, GitLab CI, Jenkins oder lokalen Skripten nach Ihrem Web-Build und npx cap sync.
• Signierung aus CI-Secrets: Halten Sie Android-Keystores, Schlüssel-Aliase, Passwörter und Play-Console-Dienstkonten-JSON in Ihren eigenen CI-Secrets.
• Keine native Runner-Vermögensverwaltung: Capgo Build stellt sichergestellte Android-Build-Umgebungen bereit, sodass Sie keine SDK Bilder, Gradle-Cache-Probleme oder Fastlane-Linien verwalten müssen.
• Artikel und Einreichung: Laden Sie signierte Artikel für QA herunter oder übermitteln Sie Release-Builds über die Capgo CLI.

Preise

• Capgo-Pläne beginnen bei 12 $/Monat
• Inklusive OTA-Updates und etwa 15 native Builds pro Monat
• Zusätzliche Build-Minuten werden durch Minuten über Credits abgerechnet

Einrichten von Capgo in CI/CD

Anleitung für die manuelle Einrichtung

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.

Schritte für die manuelle Einrichtung

1. Erstellen von Android-Keystore
2. Einrichten von Google Play Service Account
3. Einstellungen für Fastlane einrichten
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.

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

Wichtige Hinweise

• Sichern Sie diese Werte:

  • 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
  • Passwort für den Keystore - Sie benötigen dies als KEYSTORE_STORE_PASSWORD
  • Passwort für den Schlüssel - Sie benötigen dies als KEYSTORE_KEY_PASSWORD

• Sichern Sie die Keystore-DateiWenn Sie es verlieren, können Sie Ihre veröffentlichte App nicht aktualisieren

• Halten Sie es geheim: Nie commitieren Sie das Keystore-File in Git.

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

Alternative: Verwenden Sie 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 erstellt haben.
• In Ihrem Play-Console → Einstellungen → App-Zertifizierung (wenn Sie Google Play App-Zertifizierung verwenden).

2. Einrichten Sie Google Play Service Account

Um GitHub-Aktionen, die Builds auf Google Play hochladen, benötigen Sie ein Dienstkonto.

Schritt 2.1: Erstellen Sie Google Cloud Projekt

1. Gehen Sie zu Google Cloud Console
2. Einen neuen Projekt erstellen oder ein bestehendes auswählen
3. Den Projekt-Id beachten

Schritt 2.2: Google Play-Entwickler-Konto aktivieren API

1. In der Google Cloud Console gehen Sie zu APIs & Dienste → Bibliothek
2. Nach „Google Play Android-Entwickler API“ suchen
3. Auf ‚Aktivieren‘ klicken Schritt 2.3: Dienstkonten erstellen

Zu ‚IAM & Admin‘ gehen

1. Schritt 2.2: Google Play-Entwickler-Konto aktivieren __CAPGO_KEEP_0__ Schritt 2.3: Dienstkonten erstellen → Service Accounts
2. Klicken Sie Servicekonto erstellen
3. Eingaben:
   • Name: github-actions-uploader
   • Beschreibung: „Dienstkonto für GitHub Aktionen zum Hochladen von Builds“
4. Klicken Sie Erstellen und fortfahren
5. Rollenzuweisung für den Moment auslassen (klicken Sie Fortfahren, dann Abgeschlossen)

Schritt 2.4: Erstelle Dienstkontoschlüssel

1. Klicken Sie auf das neu erstellte Dienstkonto
2. Gehe zu Schlüssel Registerkarte
3. Klicken Sie Schlüssel hinzufügen → Neuen Schlüssel erstellen
4. Wähle JSON-Format auswählen
5. Klicken Sie Erfassen
6. Eine JSON-Datei wird heruntergeladen - speichern Sie dies sicher, Sie benötigen es später

Schritt 2.5: Zugriff in Play Console gewähren

1. Zum Google Play Console
2. Zum Einstellungen → API Zugriff
3. Unter DienstkontenKlicken Sie auf Zugriff gewähren zur Ihr Dienstkonten
4. On der Erlaubnisse für Anwendungen Seite, fügen Sie Ihre Anwendung
5. On der Erlaubnisse für Konten Seite, gewähren Sie diese Erlaubnisse:
   • Anwendungsinformationen anzeigen und große Berichte herunterladen (nur Lesen)
   • Draft-Anwendungen erstellen, bearbeiten und löschen
   • Anwendungen in Test-Tracks freigeben
   • Apps in die Produktion freigeben, ausgeschlossen und andere Tracks
6. Klicken Sie Benutzer einladen
7. Klicken Sie Einladung senden

Schritt 2.6: Überprüfen Sie 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": "..."
}

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

3. Fastlane einrichten

Eine fastlane Ordner in Ihrem Projektroot erstellen und einen Fastfile mit diesem Inhalt hinzufügen:

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. Konfigurieren Sie GitHub-Geheimnisse

Jetzt, dass Sie Ihren Keystore und Ihr Dienstkontoinhalt JSON haben, müssen Sie sie sicher in GitHub speichern.

Schritt 4.1: Zugriff auf GitHub-Geheimnisse

1. Gehen Sie zu Ihrem Repository auf GitHub
2. Klicken Sie Einstellungen → Geheimnisse und Variablen → Aktionen
3. Klicken Sie Neues Repository-Geheimnis erstellen

Schritt 4.2: Hinzufügen von erforderlichen Geheimnissen

Fügen Sie jedes dieser Geheimnisse einzeln hinzu:

PLAY_CONFIG_JSON

1. Laden Sie die JSON-Datei Ihres Dienstkontos, die 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 ein neues Geheimnis mit dem Namen PLAY_CONFIG_JSON und fügen Sie den Base64-String ein

ANDROID_KEYSTORE_FILE

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

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

KEYSTORE_KEY_PASSWORD

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

KEYSTORE_STORE_PASSWORD

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

DEVELOPER_PACKAGE_NAME

Erstellen Sie ein neues Geheimnis mit dem Paketnamen Ihrer App (z.B. com.example.app)

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

Schritt 4.3: Überprüfen Sie alle Geheimnisse

Stellen Sie sicher, dass diese 6 Geheimnisse konfiguriert sind:

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

5. Erstellen Sie den 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 Actions 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-Einrichtungsleitfäden

• 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-Leitfaden
• Entwicklungs- und Produktionsbuilds mit GitHub Aktionen verwalten - 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 - OTA-Updates in Ihre App hinzufügen
• CI/CD-Integration mit Capgo - Live-Updates in Ihrem Pipeline integrieren

Ressourcen

• GitHub Aktionen Dokumentation
• Fastlane Dokumentation

Weitermachen von der automatischen Capacitor Android-Build mit GitHub Aktionen

Wenn Sie "__CAPGO_KEEP_0__ Actions Documentation" verwenden Automatische Capacitor Android-Build mit GitHub 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 für die Implementierungsdetails in CI/CD-Integration, und GitHub Aktionen-Integration für die Implementierungsdetails in GitHub Aktionen-Integration.