iOS-Builds

Kopiere einen Setup-Prompt mit den Installationsschritten und dem vollständigen Markdown-Guide für dieses Plugin.

iOS-Apps bauen und an TestFlight und den App Store einreichen – mit der dedizierten Mac-Infrastruktur von Capgo.

Was du lernen wirst

Du lernst, wie du deine App über Capgo Native Build hochlädst
Du lernst, wie du die Zertifikate für Capgo Native Build konfigurierst

Voraussetzungen

Ein Capgo Account (ein kostenloser Testzugang reicht für den Start)
Deine App ist bereits in Capgo registriert (sonst führe bunx @capgo/cli@latest app add aus)
Kein Mac nötig: Capgo Build kompiliert und signiert deine iOS-App in der Cloud, du kannst das also unter macOS, Windows oder Linux ausführen
Gültiger Apple Developer Account ($99/Jahr) (Du brauchst Admin- oder Owner-Rechte im Apple Developer Account)
Deine App muss sich erfolgreich bauen lassen (lokal in Xcode oder mit Capgo Build)
Eine Capacitor App
Ein konfiguriertes Icon für die App. Apps ohne Icon können nicht in den App Store hochgeladen werden.

Bevor du in Apples Portalen startest

Bevor du Zertifikate einrichtest oder deinen ersten TestFlight-Upload auslöst, stelle sicher, dass das Apple-Konto und das Team bereit sind:

Aktiviere die Zwei-Faktor-Authentifizierung für den Apple Account, den du für die Registrierung nutzt
Wähle den passenden Mitgliedschaftstyp:
- Einzelperson / Einzelunternehmer: dein gesetzlicher Name wird als Verkäufername im App Store angezeigt
- Organisation: erfordert eine juristische Person, eine D-U-N-S-Nummer, eine öffentliche Firmenwebsite, eine geschäftliche E-Mail-Adresse auf der Firmen-Domain und eine Person, die die Organisation an Apples Verträge binden darf
Nutze ein Konto mit Zugriff auf Apple Developer und App Store Connect – für Zertifikate, App-Einträge, API Keys und TestFlight
Lege deine finale Bundle ID frühzeitig fest. Eine spätere Änderung bedeutet meist, dass du das App-Store-Setup neu machen musst
Plane diese Punkte in App Store Connect vor dem App Review: Support-URL, Datenschutzrichtlinien-URL, Altersfreigabe, Screenshots, Export-Compliance und Kontaktdaten fürs App Review

Wähle den richtigen Apple-Developer-Entity-Typ

App Store Connect nach der Registrierung

Das musst du nicht manuell machen. Das Onboarding von Capgo erstellt und konfiguriert deine iOS-Signing-Credentials (Distribution Certificate + Provisioning Profile) für dich – das ist der empfohlene Weg:

bunx @capgo/cli@latest build init --platform ios

Die folgende manuelle Anleitung richtet sich nur an diejenigen, die ihre Credentials lieber selbst einrichten oder genau verstehen wollen, was Capgo unter der Haube macht.

Der erste manuelle Build

Bevor wir darüber nachdenken, die App mit Capgo zu bauen, sollten wir es zuerst einrichten und einen ersten TestFlight-Build manuell erstellen. Ein manueller Build zuerst hat einige Vorteile:

Du richtest das Distribution Certificate auf deinem lokalen Rechner ein
Du erstellst den App Store Record, falls noch nicht geschehen
Du kannst alle Probleme im Build-Prozess deiner code-App herausfinden

Bevor wir starten können, muss das Distribution Certificate auf deinem lokalen Rechner installiert sein. Das ist ziemlich komplex, aber ich erkläre es dir unten.

Distribution Certificate einrichten

Xcode öffnen
Klicken Sie auf Xcode -> Settings... Alternativ kannst du die Tastenkombination nutzen Cmd + ,
Gehe zu Accounts
Finde den Apple Account, der dem Apple Developer Account hinzugefügt wurde
Wähle das Team aus, mit dem du die App deployen möchtest
Klicke auf die Manage Certificates... Button
Stelle sicher, dass du das Distribution Certificate in der Liste siehst
Falls nicht, musst du ein neues Certificate erstellen

Apple begrenzt die Anzahl der Distribution Certificates auf 3. Wenn du mehr als 3 hast, musst du eines löschen, um ein neues zu erstellen. Das behandle ich im Tutorial nicht.
1. Klicke auf die + Button und dann auf Apple Distribution
2. Das Zertifikat wird automatisch erstellt. Du findest es in der Liste. Überprüfe den vorherigen Schritt, um sicherzustellen, dass es angezeigt wird.

Nachdem du das Distribution Certificate installiert hast, kannst du mit dem Build-Prozess beginnen.

Manueller Build für TestFlight

Öffne die App in Xcode

Ausführen bunx cap open ios um die App in Xcode zu öffnen.
Finde und klicke auf archive Button

Finde in der Xcode-Toolbar und klicke auf product -> archive Button.
Warte, bis der Build abgeschlossen ist
Klicke auf die Distribute App Button
Wähle TestFlight Internal Only als Verteilungsmethode und klicken Sie auf Distribute Button
App-Record konfigurieren

Füllen Sie die folgenden Felder aus:
1. Name: Der Name Ihrer App – sichtbar im App Store
2. SKU – die SKU Ihrer App – wird verwendet, um Ihre App im App Store zu identifizieren
3. Primäre Sprache – die Primärsprache Ihrer App
Klicken Sie anschließend auf next Button
Falls die Erstellung des App-Records fehlschlägt, schließe das Fenster und versuche erneut, die App zu archivieren.
Warte, bis der Upload abgeschlossen ist
Wenn alles geklappt hat, solltest du folgenden Bildschirm sehen
Klicke auf die Done Button

Vielleicht denkst du jetzt, dass alles erledigt ist und du deine App direkt in TestFlight sehen kannst, aber ein paar Schritte fehlen noch:

Füge dich selbst zu TestFlight hinzu
Export Compliance abschließen, damit der Build testbar wird
Trage die erforderlichen App Store Connect Metadaten ein, wie z. B. deine Support-URL, die URL zur Datenschutzerklärung und die Altersfreigabe.
Screenshots für die Geräte vorbereiten, die du tatsächlich unterstützt
Füge App-Review-Kontaktdaten und eventuelle Test-Zugangsdaten hinzu, bevor du für die Produktion einreichst

Fangen wir mit dem ersten an:

Dich selbst zu TestFlight hinzufügen

Besuchen Sie die App Store Connect Seite
Mit deinem Apple Developer Account anmelden
Wähle das Team aus, das du beim Anlegen des App-Eintrags verwendet hast. Wenn du nur einem Developer Account angehörst, kannst du diesen Schritt überspringen.
Klicke auf die Apps Button
Finde die App, die du im vorherigen Schritt erstellt hast, und klicke darauf
Klicke auf die TestFlight Button
Klicke auf die Internal Testers plus Button
Neue Gruppe erstellen

Ich nenne die Gruppe gerne „internal“. Du kannst sie aber auch beliebig benennen.
Klicken Sie auf Invite testers Button
Fügen Sie sich selbst zur Gruppe hinzu.

Suchen Sie sich selbst in der Liste und setzen Sie das Häkchen neben Ihrem Namen. (Eventuell müssen Sie die Seite neu laden, um sich selbst zu sehen.) Klicken Sie dann auf das Add Button.
Prüfen Sie, ob Sie zur Gruppe hinzugefügt wurden

Sie sollten nun in der Gruppe aufgeführt sein.

Glückwunsch 🎉 Sie haben sich selbst zu TestFlight hinzugefügt. Jetzt gibt es nur noch eine Sache, die Sie erledigen müssen, bevor Sie Capgo Native Build konfigurieren können.

Compliance-Informationen einrichten

Du musst Apple nun zusichern, dass deine App keine nicht standardisierte Verschlüsselung (z. B. einen eigenen Algorithmus) verwendet. Falls deine App doch nicht standardisierte Verschlüsselung nutzt, empfehle ich dir, Apple-Dokumentation zum weiteren Vorgehen zu lesen. Es gibt zwei Möglichkeiten:

Das kannst du jedes Mal manuell machen, wenn du deine App buildest.
Du kannst deine plist-Datei so konfigurieren, dass dieser Wert automatisch auf false.

Fangen wir mit dem ersten an:

Folge allen Schritten aus dem vorherigen Abschnitt, um den TestFlight-Bereich in App Store Connect zu finden
Klicken Sie auf Builds -> iOS
Suche den Build mit fehlenden Compliance-Informationen und klicke auf Manage
Wähle die Option, die deine App am besten beschreibt

Für mich ist das none, bei dir kann es aber anders sein. Klicke danach auf Speichern
Deine App sollte jetzt anzeigen ready to test

Für den zweiten Punkt sind dies die Schritte:

Öffne die Info.plist Datei

Füge den folgenden Schlüssel hinzu:

<key>ITSAppUsesNonExemptEncryption</key>
<false/>

Datei speichern

TestFlight-App installieren und Einladung annehmen

Jetzt bist du FAST bereit, deine App in TestFlight zu testen. Davor musst du Folgendes tun:

Laden Sie TestFlight-App aus dem App Store auf deinem iOS-/iPadOS-Gerät herunter
Nimm die Einladung zum Testen deiner App an

Ich gehe nicht auf die Details ein, wie du die TestFlight-App auf deinem Gerät installierst. Falls du dir nicht sicher bist, wie man eine App installiert, findest du bei Google einige großartige Anleitungen dazu.

Was das Annehmen der Einladung betrifft, erhältst du eine E-Mail von Apple mit einem Link, um die Einladung anzunehmen.

Öffne die E-Mail von Apple mit dem Link, um die Einladung anzunehmen
Klicken Sie auf View in TestFlight Button
Klicke auf die Install Button
App auf Ihrem Gerät installieren

Falls du die App zuvor bereits über Xcode installiert hast, erscheint eventuell der folgende Bildschirm. Bitte klicke auf den install Button.
Warte, bis die App installiert ist
Klicke auf die Open Button und klicke darauf

Glückwunsch 🎉 Du hast die Einladung angenommen, deine App in TestFlight zu testen. Jetzt kannst du Capgo Native Build konfigurieren, um deine App zu builden und bei TestFlight einzureichen.

Konfiguration von Capgo Native Build

Du musst einige Dinge in Capgo Native Build konfigurieren, um deine App zu builden und bei TestFlight einzureichen. Hier ist eine Liste der Werte, die du an die Capgo CLI übergibst:

Parameter	Beschreibung
`--platform`	Zielplattform für den Build (`ios`)
`--apple-team-id`	Ihre Apple-Developer-Team-ID (zu finden im Apple Developer Portal)
`--apple-key`	Pfad zu Ihrer App Store Connect API-Schlüsseldatei (`.p8` Datei)
`--apple-key-id`	Key ID Ihres App Store Connect API-Schlüssels
`--apple-issuer-id`	Ihre App Store Connect Issuer ID
`--certificate`	Pfad zu Ihrem Distribution-Zertifikat (`.p12` Datei)
`--ios-provisioning-profile`	Provisioning-Profil-Mapping (`bundleId=path` oder nur der Pfad für ein einzelnes Profil)

Beispielbefehl:

bunx @capgo/cli@latest build credentials save \
  --platform ios \
  --apple-team-id YOUR_TEAM_ID \
  --apple-key '/path/to/AuthKey_XXXXX.p8' \
  --apple-key-id YOUR_KEY_ID \
  --apple-issuer-id YOUR_ISSUER_ID \
  --certificate '/path/to/certificate.p12' \
  --ios-provisioning-profile '/path/to/profile.mobileprovision'

Team-ID

Beginnen wir mit der Team-ID. Sie lässt sich leicht finden.

Gehe zu Apple-Developer-Konto und scrolle nach unten
Suche nach Team ID

Apple Key, Apple Key ID und Apple Issuer ID

Nun widmen wir uns dem Apple-Schlüssel.

Gehe zu App Store Connect-Benutzer- und Zugriffsseite

Bei mir funktioniert der Link manchmal nicht. Lade die Seite neu, falls er bei dir auch nicht funktioniert.
Wähle das richtige Team im Dropdown aus
1. Klicke oben rechts auf deinen Namen
2. Klicke auf das Team, das du nutzen möchtest
Klicke auf die Integrations Button
Suche nach issuer

Dies MUSS GESPEICHERT WERDEN - du wirst es später brauchen

Klicke auf die copy Button zum Kopieren der Issuer-ID
Klicke auf den Plus-Button
Namen des Schlüssels festlegen und den Zugriff auf App manager und klicke auf Generate Button
Key-ID speichern

Dies MUSS GESPEICHERT WERDEN - du wirst es später brauchen
Schlüssel herunterladen

Dies MUSS GESPEICHERT WERDEN - du wirst es später brauchen

TEILE DEN SCHLÜSSEL NIEMALS MIT JEMANDEM – NUTZE IHN NUR IN CAPGO CLI

Glückwunsch 🎉 Du hast den Apple-Key, die Apple Key ID und die Apple Issuer ID erstellt.

Zertifikat

Jetzt kannst du das Zertifikat exportieren. Wie du dich erinnerst, war einer der ersten Schritte in dieser Anleitung das Einrichten des Distribution Certificates.

Apple hat in seiner unendlichen Weisheit jedoch entschieden, dass der Export des Zertifikats ganz anders funktioniert als die Erstellung 🙃 So richtest du es ein:

Öffne Keychain Access
1. Klicken Command + Space um die Suchleiste zu öffnen
2. Suche nach Keychain Access
3. Klicke auf die Keychain Access App
Wähle die login Kategorie und klicken Sie auf My Certificates Button
Suchen Sie Ihr Zertifikat in der Liste

Das Zertifikat sollte diesen Namen haben Apple Distribution: [Your Name/Company] (your team ID)
Rechtsklick auf das Zertifikat und auswählen Export
Speichere das Zertifikat als .p12 Datei

Dies MUSS GESPEICHERT WERDEN - du wirst es später brauchen
1. Wähle einen passenden Namen für die Zertifikatsdatei aus
2. Stelle sicher, dass das Dateiformat eingestellt ist Personal Information Exchange (.p12)
3. Klicke auf die Save Button
Wenn nach dem Passwort gefragt wird, hast du zwei Optionen:
- Passwort überspringen (empfohlen für Einfachheit): Klicke auf OK ohne ein Passwort einzugeben
- Passwort festlegen: Wenn du dein Zertifikat mit einem Passwort schützen möchtest, kannst du es hier setzen. Passwortschutz .p12 Dateien werden vollständig von Capgo CLI unterstützt – gib einfach das Passwort über die --p12-password Option beim Ausführen des Konfigurationsbefehls ein.
Wenn nach dem „Login-Keychain-Passwort“ gefragt wird, gib das Passwort ein, mit dem du dich bei deinem Mac anmeldest

Gib das Passwort ein, mit dem du dich bei deinem Mac anmeldest. Klicke dann auf Allow Button.

Glückwunsch 🎉 Du hast das Zertifikat exportiert.

Provisioning-Profil

Jetzt kannst du das Provisioning Profile exportieren. Versprochen: Das ist das Letzte, was du von Apple brauchst.

Gehe zu Apple-Developer-Profile
Wähle das richtige Team im Dropdown aus
1. Klicke oben rechts auf deinen Namen
2. Klicke auf das Team, das du nutzen möchtest
Stelle sicher, dass du auf der richtigen Seite bist. Sie sollte so aussehen; falls nicht, klicke auf profiles in der Sidebar
Klicke auf die + Button
Profiltyp auswählen Auswählen App Store Connect und klicke auf Continue Button
Wähle die App aus, die du bauen möchtest

Suche deine App im Dropdown und klicke auf Continue Button
Wähle das richtige Distribution-Zertifikat aus

Wähle das Zertifikat aus, das du im vorherigen Schritt exportiert hast, und klicke auf Continue Button

Wenn du unsicher bist, welches Zertifikat du wählen sollst, geh zurück zu Keychain Access und suche das Zertifikat, das du exportiert hast. Schau dir dann das Ablaufdatum an.
Profil benennen

Gib dem Profil einen Namen und klicke auf Generate Button

Der Profilname wird automatisch von Capgo CLI extrahiert – du musst ihn dir nicht merken.
Profil herunterladen

Klicke auf die Download Button zum Download des Profils

Diese Datei MUSS GESPEICHERT WERDEN - du wirst es später brauchen

Glückwunsch 🎉 Du hast jetzt alles, was du brauchst, um Capgo Native Build zu konfigurieren.

Konfigurationsbefehl ausführen

Geschafft! Du hast jetzt alles, was du brauchst, um Capgo Native Build zu konfigurieren.

Der Befehl, den du ausführen musst, lautet:

bunx @capgo/cli@latest build credentials save \
  --platform ios \
  --apple-team-id UVTJ336J2D \
  --apple-key ./capgo-tutorial/AuthKey_66FGQZB566.p8 \
  --apple-key-id 66FGQZB566 \
  --apple-issuer-id 0cd4db4a-5598-45b8-9d32-75cdf127d005 \
  --certificate ./capgo-tutorial/capgo-build-tutorial-certificate.p12 \
  --ios-provisioning-profile ./capgo-tutorial/capgo_native_build_tutorial.mobileprovision

Wenn alles gut gegangen ist, sehen Sie die folgende Ausgabe:

Capgo CLI Credentials speichern

CI/CD-Setup (GitHub Actions)

Falls du bereits abgeschlossen hast Team-ID, Apple Key, Apple Key ID und Apple Issuer ID, Zertifikat, und Provisioning-Profil, du hast bereits alles für CI/CD bereit. Dieser Abschnitt erklärt nur, wie du diese Werte als GitHub Actions Secrets und Umgebungsvariablen übergibst.

1) Credential-Dateien in einzeiliges Base64 konvertieren

# Distribution certificate (.p12)
base64 -i ./capgo-tutorial/capgo-build-tutorial-certificate.p12 | tr -d '\n' > certificate_base64.txt

# Provisioning profile (.mobileprovision)
base64 -i ./capgo-tutorial/capgo_native_build_tutorial.mobileprovision | tr -d '\n' > profile_base64.txt

# App Store Connect API key (.p8)
base64 -i ./capgo-tutorial/AuthKey_66FGQZB566.p8 | tr -d '\n' > apple_key_base64.txt

2) Repository-Secrets erstellen

Unter GitHub > Repository > Settings > Secrets and variables > Actions, hinzufügen:

Secret-Name	Wert
`CAPGO_TOKEN`	Dein Capgo API Token
`APP_STORE_CONNECT_TEAM_ID`	Team-ID von Team-ID
`APPLE_KEY_ID`	Key-ID von Apple Key, Apple Key ID und Apple Issuer ID
`APPLE_ISSUER_ID`	Issuer-ID von Apple Key, Apple Key ID und Apple Issuer ID
`BUILD_CERTIFICATE_BASE64`	Inhalt von `certificate_base64.txt`
`CAPGO_IOS_PROVISIONING_MAP`	Erstellt von CLI — kopiert von `.capgo-credentials` Datei
`APPLE_KEY_CONTENT`	Inhalt von `apple_key_base64.txt`
`P12_PASSWORD` (optional)	Dein `.p12` Passwort, falls beim Export gesetzt

3) Nutze Umgebungsvariablen in deinem GitHub Actions Workflow

name: iOS Cloud Build

on:
  workflow_dispatch:
  push:
    branches: [main]

jobs:
  ios-build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      - uses: oven-sh/setup-bun@v2
        with:
          bun-version: latest
      - name: Request iOS build with Capgo
        run: bunx @capgo/cli@latest build request --platform ios
        env:
          CAPGO_TOKEN: ${{ secrets.CAPGO_TOKEN }}
          APP_STORE_CONNECT_TEAM_ID: ${{ secrets.APP_STORE_CONNECT_TEAM_ID }}
          APPLE_KEY_ID: ${{ secrets.APPLE_KEY_ID }}
          APPLE_ISSUER_ID: ${{ secrets.APPLE_ISSUER_ID }}
          BUILD_CERTIFICATE_BASE64: ${{ secrets.BUILD_CERTIFICATE_BASE64 }}
          CAPGO_IOS_PROVISIONING_MAP: ${{ secrets.CAPGO_IOS_PROVISIONING_MAP }}
          APPLE_KEY_CONTENT: ${{ secrets.APPLE_KEY_CONTENT }}
          P12_PASSWORD: ${{ secrets.P12_PASSWORD }}

Build ausführen

Jetzt kannst du deinen ersten Build ausführen.

Führe folgenden Befehl aus, um deine App zu bauen:

bunx @capgo/cli@latest build request --platform ios

Glückwunsch 🎉 Damit hast du deinen Build erfolgreich abgeschlossen und deine App ist bereit für die Einreichung im App Store.

Zur App Store Review einreichen

Der normale App-Store-Build-Pfad lädt den Build zu App Store Connect/TestFlight hoch. Wenn dein CI-Release den verarbeiteten TestFlight-Build zusätzlich an die App-Store-Version anhängen und zur App Review einreichen soll, übergib --submit-to-store-review mit einem Release-Build:

npx @capgo/cli@latest build request com.example.app \
  --platform ios \
  --build-mode release \
  --ios-distribution app_store \
  --submit-to-store-review \
  --store-release-name "1.2.3" \
  --store-release-notes "General improvements" \
  --store-release-notes-locale "en-US=General improvements" \
  --store-release-notes-locale "nl-NL=Algemene verbeteringen" \
  --store-release-notes-locale "fr-FR=Ameliorations generales" \
  --no-ios-automatic-release

Hierfür sind App Store Connect API Key-Zugangsdaten erforderlich (APPLE_KEY_ID, APPLE_ISSUER_ID, APPLE_KEY_CONTENT, und APP_STORE_CONNECT_TEAM_ID). Mit App-spezifischen Passwörtern können Uploads und ad_hoc Distributionen keinen Build zur Review einreichen. --store-release-name ist die App-Store-Version; falls weggelassen, liest Capgo MARKETING_VERSION aus dem Xcode-Projekt. --store-release-notes ist der Fallback-Text für „Was gibt's Neues“ im App Store, und jeder --store-release-notes-locale "locale=notes" Eintrag kann diesen für eine Store-Lokalisierung überschreiben. Nutze --ios-automatic-release für ein automatisches Release nach der Apple-Freigabe, oder --no-ios-automatic-release um auf ein manuelles Release zu warten. --ios-testflight-groups ist weiterhin für die externe Beta-Distribution verfügbar, ist aber nicht für die App-Store-Review-Einreichung erforderlich.

Ad-Hoc-Verteilungsmodus

Standardmäßig erstellt Capgo iOS-Apps für die App-Store-Verteilung (TestFlight + App Store). Wenn du stattdessen Ad-hoc-Builds brauchst (z. B. für interne Tests oder zum Sammeln von CI-Artefakten), kannst du den --ios-distribution Flag.

Wann Ad-Hoc-Modus nutzen

Du möchtest IPAs direkt an registrierte Geräte verteilen (ohne TestFlight)
Du hast keinen App Store Connect API Key oder willst keinen nutzen
Du möchtest Build-Artefakte sammeln über --output-upload ohne sie beim App Store einzureichen

Anforderungen

Ad-hoc-Builds haben weniger Anforderungen als App-Store-Builds:

Credentials	Erforderlich?
Distribution-Zertifikat (`.p12`)	Ja
Ad-hoc-Provisioning-Profil (`.mobileprovision`)	Ja
Team-ID (`--apple-team-id`)	Ja
App Store Connect API Key (`.p8`)	Nein
Apple Key ID / Issuer ID	Nein

Erstellen eines Ad-hoc-Provisioning-Profils

Folge denselben Schritten wie bei Provisioning-Profil, aber in Schritt 5 wähle Ad Hoc anstatt App Store:

Gehe zu Apple-Developer-Profile
Klicke auf das + Button
Wähle Ad Hoc und klicke auf Weiter
Wähle deine App und dein Distribution Certificate aus
Wählen Sie die Geräte aus, die Sie registrieren möchten
Profil benennen und herunterladen

Ad-Hoc-Zugangsdaten speichern

bunx @capgo/cli@latest build credentials save \
  --platform ios \
  --ios-distribution ad_hoc \
  --apple-team-id YOUR_TEAM_ID \
  --certificate './certificate.p12' \
  --ios-provisioning-profile './adhoc_profile.mobileprovision'

Nein --apple-key, --apple-key-id, oder --apple-issuer-id benötigt.

Ad-Hoc-Build ausführen

bunx @capgo/cli@latest build request \
  --platform ios \
  --ios-distribution ad_hoc

Um die IPA als Build-Artefakt zu sammeln, füge hinzu --output-upload:

bunx @capgo/cli@latest build request \
  --platform ios \
  --ios-distribution ad_hoc \
  --output-upload

CI/CD mit Ad-Hoc-Builds

Für GitHub Actions benötigst du weniger Secrets als für App Store-Builds:

name: iOS Ad-Hoc Build

on:
  workflow_dispatch:

jobs:
  ios-adhoc:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      - uses: oven-sh/setup-bun@v2
        with:
          bun-version: latest
      - name: Request iOS ad-hoc build
        run: bunx @capgo/cli@latest build request --platform ios --ios-distribution ad_hoc --output-upload
        env:
          CAPGO_TOKEN: ${{ secrets.CAPGO_TOKEN }}
          APP_STORE_CONNECT_TEAM_ID: ${{ secrets.APP_STORE_CONNECT_TEAM_ID }}
          BUILD_CERTIFICATE_BASE64: ${{ secrets.BUILD_CERTIFICATE_BASE64 }}
          CAPGO_IOS_PROVISIONING_MAP: ${{ secrets.CAPGO_IOS_PROVISIONING_MAP_ADHOC }}
          CAPGO_IOS_DISTRIBUTION: ad_hoc

Apps mit Extensions (Multi-Target Signing)

Wenn deine App Extensions enthält (Share Extensions, Widgets, Notification Service Extensions usw.), benötigt jedes Extension-Target ein eigenes Provisioning Profile. Capgo unterstützt dies über das wiederholbare --ios-provisioning-profile Flag.

bunx @capgo/cli@latest build credentials save \
  --platform ios \
  --apple-team-id YOUR_TEAM_ID \
  --apple-key '/path/to/AuthKey_XXXXX.p8' \
  --apple-key-id YOUR_KEY_ID \
  --apple-issuer-id YOUR_ISSUER_ID \
  --certificate '/path/to/certificate.p12' \
  --ios-provisioning-profile "com.example.app=./app_profile.mobileprovision" \
  --ios-provisioning-profile "com.example.app.share-extension=./share_ext_profile.mobileprovision"

Jedes --ios-provisioning-profile Flag ordnet eine Bundle ID ihrem Provisioning Profile zu. Das CLI:

Liest jede mobileprovision-Datei
Extrahiert den Profilnamen automatisch aus der eingebetteten plist
Kodiert die Datei als Base64
Speichert alles als ein einziges CAPGO_IOS_PROVISIONING_MAP Credential

Migration vom Single Profile

If you previously used BUILD_PROVISION_PROFILE_BASE64 (Single Profile) genutzt hast, führe aus:

bunx @capgo/cli@latest build credentials migrate --platform ios

Dies konvertiert deine bestehenden Single-Profile-Credentials in das neue CAPGO_IOS_PROVISIONING_MAP Format und entfernt die alten Keys (BUILD_PROVISION_PROFILE_BASE64, APPLE_PROFILE_NAME).

Nach der Migration fügst du Erweiterungsprofile mit dem update Befehl hinzu (additiver Merge):

bunx @capgo/cli@latest build credentials update \
  --platform ios \
  --ios-provisioning-profile "com.example.app.share-extension=./share_ext_profile.mobileprovision"

Fehlerbehebung

Provisioning Profile enthält die XYZ Capability nicht.

Manchmal tritt folgender Fehler auf:

Provisioning profile "YOUR_PROVISIONING_PROFILE_NAME" doesn't include the XYZ capability. (in target 'App' from project 'App')"

Das passiert, weil du eine neue Capability aktiviert hast, nachdem das Provisioning Profile erstellt wurde. Das alte Provisioning Profile enthält die neue Capability noch nicht.

Um dies zu beheben, musst du das Provisioning Profile neu generieren.

Öffne Apple Developer Portal
Wähle das richtige Team im Dropdown aus
Klicke auf die Profiles Button
Finden Sie das Provisioning-Profil, das Sie neu generieren möchten
Klicke auf die Edit Button
Klicke auf die Save Button
Klicke auf die Download Button
Führe den Capgo Native Build Setup-Befehl erneut aus mit dem neu heruntergeladenen Profil.

Das sollte das Problem beheben.

Weitere Probleme

Falls du aus irgendeinem Grund Probleme mit Capgo Native Build, der Konfiguration der Zugangsdaten oder dem Build der App hast, zögere nicht, uns über unseren Support.

Weiter mit iOS Builds

Wenn du es nutzt iOS-Builds 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.