Vorabveröffentlichungen von iOS-Builds durch App-Bereitstellung schneller vertreiben

1. Hinweis

In diesem Codelab erfahren Sie, wie Sie mit Firebase App Distribution und dem fastlane-Plug-in eine iOS-App an Tester verteilen, UDIDs von Testgeräten erfassen und sie im Bereitstellungsprofil Ihrer App registrieren, damit Sie Ad-hoc-Builds schnell an die Tester weitergeben können.

Lerninhalte

• So laden Sie eine Vorabversion einer iOS-App (Ad Hoc) mit Firebase App Distribution und fastlane hoch und verteilen sie an Tester.
• So registrieren Sie sich als Tester und laden die bereitgestellte App auf ein Testgerät herunter.
• So registrieren Sie Testgeräte schnell, indem Sie die UDIDs der Testgeräte mit dem fastlane-Plug-in der App Distribution exportieren.
• So aktualisieren Sie das Bereitstellungsprofil Ihrer App und laden es zur Bereitstellung noch einmal hoch.

Voraussetzungen

• Ein Google-Konto
• Ein Apple-Computer mit XCode 11.7 oder höher
• Eine Ad-hoc-Pre-Release-iOS-App, die in Xcode erstellt wurde
• Ein kostenpflichtiges Apple-Entwicklerkonto
• Ein physisches iOS-Gerät für Tests.

Die iOS-Simulator-App funktioniert für den Großteil des Codelabs, aber über Simulatoren können keine Releases heruntergeladen werden.

Sie können trotzdem prüfen, ob die Einrichtung funktioniert hat, indem Sie in der App Distribution Tester-Web-App nachsehen, ob die Schaltfläche „Herunterladen“ angezeigt wird.

2. Jetzt starten

fastlane einrichten

Die App-Bereitstellung lässt sich in fastlane einbinden, damit Sie den Vertrieb von Pre-Release-Builds Ihrer App automatisieren können. Die App-Bereitstellung lässt sich in Ihre fastlane-Konfiguration einbinden.

1. Installieren und einrichten Sie fastlane.
2. Führen Sie während der Einrichtung fastlane init im Stammverzeichnis Ihres Projekts aus und wählen Sie „Manuelle Einrichtung“ aus. Sie sehen ein Unterverzeichnis namens fastlane mit den Dateien Fastfile, Appfile und Pluginfile, mit denen Sie fastlane konfigurieren.

Firebase CLI installieren

Außerdem müssen Sie die Firebase CLI installieren. Wenn Sie macOS oder Linux verwenden, können Sie den folgenden cURL-Befehl ausführen:

curl -sL https://firebase.tools | bash

Wenn Sie Windows verwenden, lesen Sie die Installationsanleitung, um ein eigenständiges Binärprogramm zu erhalten oder die Installation über npm durchzuführen.

Nachdem Sie die Befehlszeile installiert haben, sollte beim Ausführen von firebase --version die Version 12.0.0 oder höher angezeigt werden:

$ firebase --version
12.0.0

3. App mit fastlane erstellen

App entwickeln

1. Legen Sie einige globale Variablen für fastlane in ./fastlane/Appfile. fest. Geben Sie dabei die ID Ihrer App und Ihre Apple-ID an:

app_identifier("<your app's bundle identifier>")
apple_id("<your Apple id>")

2. Erstellen Sie Ihre erste Spur und verwenden Sie die build_app-Aktion (auch gym genannt) von fastlane , um Ihre App zu erstellen. Fügen Sie dazu Folgendes zu ./fastlane/Fastfile hinzu:

default_platform(:ios)

lane :build do
    build_app(export_method: "ad-hoc")
end

3. Signieren Sie Ihre App für den Vertrieb.

In diesem Codelab verwalten Sie Ihre eigene Zertifizierung und Ihr eigenes Profil mit get_certificates (auch cert genannt), das Signaturzertifikate lokal generiert und alles in Ihrem macOS-Schlüsselbund speichert. Normalerweise sollten Sie jedoch fastlane sync_code_signing action (auch match genannt) verwenden, um die Codesignaturzertifikate und ‑profile Ihres Teams sicher zu verwalten.

lane :build do
    get_certificates()
    build_app(export_method: "ad-hoc")
end

4. Richten Sie mit der Aktion get_provisioning_profile (auch sigh genannt) ein Bereitstellungsprofil für Ihre App ein. So können Sie Ihre App mit Testern teilen.

lane :build do
    get_certificates()
    get_provisioning_profile(adhoc: true)
    build_app(export_method: "ad-hoc")
end

5. [Optional] Wenn Sie Ihre App noch nie ausgeführt haben, führen Sie den folgenden Befehl aus, um sie in der Apple Developer Console zu erstellen:

$ fastlane produce --skip_itc

6. Erstellen Sie abschließend Ihre App, indem Sie die Lane ausführen.

Sie werden aufgefordert, Ihre Apple-ID, Ihr Passwort (das in Ihrem Schlüsselbund gespeichert ist) und die Bundle-ID Ihrer App einzugeben.

$ fastlane build

Wenn Probleme auftreten, findest du in der Anleitung zur Fehlerbehebung weitere Informationen.

4. App in Firebase hochladen

Nachdem Sie Ihre App erstellt haben, können Sie sie in die App-Bereitstellung hochladen.

Firebase-Projekt erstellen und einrichten

1. Melden Sie sich in Firebase an.
2. Erstellen oder fügen Sie in der Firebase Console ein neues Projekt hinzu und benennen Sie es in „UDID Export Codelab“ um.

Sie müssen Google Analytics für dieses Projekt nicht aktivieren.

3. Klicken Sie auf Projekt erstellen.

iOS-App zum Projekt hinzufügen

1. Klicken Sie auf das iOS-Symbol, um eine neue Firebase-iOS-App zu erstellen, und geben Sie die Bundle-ID Ihrer App ein.

2. Überspringen Sie die nächsten Schritte und klicken Sie dann auf Weiter zur Konsole. SDKs fügen Sie Ihrer App später hinzu.

Ihr Projekt und Ihre App sind jetzt auf der Seite Projektübersicht verfügbar.

App-Bereitstellung aktivieren

1. Klicken Sie im Bereich „Release und Monitoring“ auf App-Bereitstellung.
2. Akzeptieren Sie die Nutzungsbedingungen und klicken Sie dann auf „Jetzt starten“, um die App-Bereitstellung für Ihre App zu aktivieren.

Distribution in fastlane einrichten

1. Führen Sie den folgenden Befehl im Stammverzeichnis Ihres iOS-Projekts aus, um Ihrer fastlane-Konfiguration die App-Bereitstellung hinzuzufügen.

Wenn Sie nach dem Befehl eine Option auswählen müssen, wählen Sie Option 3: RubyGems.org aus:

$ fastlane add_plugin firebase_app_distribution

2. Prüfen Sie, ob das Plug-in installiert ist:

$ fastlane

In der Ausgabe sollte fastlane-plugin-firebase_app_distribution in der Liste der installierten Plug-ins angezeigt werden.

3. Nachdem du bestätigt hast, dass das Plug-in installiert ist, wähle Option 0 aus, um abzuschließen.

Firebase-Projekt authentifizieren

Wenn Sie das fastlane-Plug-in verwenden möchten, müssen Sie zuerst Ihr Firebase-Projekt authentifizieren.

1. Führen Sie den folgenden Befehl aus, um die Befehlszeile mit Ihrem Google-Konto zu verknüpfen:

$ firebase login

2. Wenn der Befehl einen Authentifizierungslink druckt, öffnen Sie den Link in einem Browser.
3. Melden Sie sich auf Aufforderung in Ihrem Google-Konto an und gewähren Sie die Berechtigung zum Zugriff auf Ihr Firebase-Projekt.

App vertreiben

Sie können jetzt Ihre App vertreiben.

1. Definieren Sie oben in ./fastlane/Fastfile die Variable firebase_app_id. Ersetzen Sie <your_app_id> durch die Firebase-App-ID der von Ihnen erstellten App. Sie finden sie auf der Seite Projekteinstellungen.

Die Fastfile ist in Ruby geschrieben. Verwenden Sie daher die Ruby-Syntax, um Variablen zu definieren.

firebase_app_id = "<your_app_id>"

2. Fügen Sie eine neue Lane namens distribute hinzu, die die Build-Lane aufruft, und verteilen Sie Ihre App dann mit der Aktion firebase_app_distribution.

lane :distribute do
    build
    firebase_app_distribution(
        app: firebase_app_id,
        release_notes: "Try out this app!",
    )
end

3. Führen Sie die neue Lane aus, um Ihre App zu erstellen und eine Distribution zu erstellen.

$ fastlane distribute

Ihre Fastfile sollte jetzt so aussehen:

firebase_app_id = "<your Firebase app ID>"

default_platform(:ios)

lane :build do
    get_certificates()
    get_provisioning_profile(adhoc: true)
    build_app(export_method: "ad-hoc")
end

lane :distribute do
    build
    firebase_app_distribution(
        app: firebase_app_id,
        release_notes: "Try out this app!",
    )
end

Nachdem Sie die Firebase Console aktualisiert haben, sehen Sie den neuen Release für Ihre App.

5. Tester zum Herunterladen Ihrer App einladen

Wenn ein Tester eine Einladung zum Testen eines Ad-hoc-Builds annimmt, wird er um Erlaubnis gebeten, seine UDID freizugeben. Wenn er zustimmt, werden seine Geräteinformationen von der App-Bereitstellung erfasst und Sie werden per E-Mail benachrichtigt. In diesem Abschnitt fügen Sie sich als Tester hinzu, um die von Ihnen bereitgestellte App herunterzuladen und zu testen.

Sich selbst als Tester zum Release hinzufügen

1. Erstellen Sie oben in der Fastfile unter firebase_app_id eine Variable für Tester und geben Sie Ihre eigene E-Mail-Adresse sowie andere optionale E-Mail-Adressen an, die Sie ausprobieren möchten.

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "[e-mail]",
  "[e-mail]",
]

2. Wende die Ruby-Methode Array#join an, um das app_testers-Array in einen durch Kommas getrennten String umzuwandeln, den der testers-Parameter erwartet. Übergeben Sie das Ergebnis dann an den Parameter testers von firebase_app_distribution..

lane :distribute do
    build
    firebase_app_distribution(
        app: firebase_app_id,
        release_notes: "Try out this app!"
        testers: app_testers.join(","),
    )
end

Ihre Fastfile sollte jetzt so aussehen:

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "[e-mail]",
  "[e-mail]",
]

default_platform(:ios)

lane :build do
    get_certificates()
    get_provisioning_profile(adhoc: true)
    build_app(export_method: "ad-hoc")
end

lane :distribute do
    build
    firebase_app_distribution(
        app: firebase_app_id,
        release_notes: "Try out this app!",
        testers: app_testers.join(","),
    )
end

3. Führen Sie die Fahrspur noch einmal aus.

$ fastlane distribute

Sobald Sie die Testphase gestartet haben, erhalten die von Ihnen hinzugefügten Tester eine Einladungs-E-Mail von App Distribution, in der sie über die neue Version informiert werden. In der Firebase Console sehen Sie jetzt die Tester, die Sie dem Release Ihrer App hinzugefügt haben.

Da Sie Ihre E-Mail-Adresse angegeben haben, erhalten Sie eine E-Mail von der Firebase App-Bereitstellung, in der Sie zum Testen der App eingeladen werden. Sie sind jetzt der erste Tester! Fahren Sie mit dem folgenden Abschnitt fort, um sich als Tester auf Ihrem Testgerät einzurichten.

Testgerät registrieren

Als Tester müssen Sie sich auf Ihrem Testgerät bei Google anmelden, um auf App-Releases zugreifen zu können, zu deren Test Sie eingeladen wurden. Da Ihr Test-Build eine Ad-hoc-Version ist, müssen Sie auch Ihr Testgerät registrieren, indem Sie das Firebase-Profil installieren. Danach können Sie über die Web-App „App Distribution Tester“ auf Releases zugreifen, die für Sie verfügbar sind. Verwenden Sie dazu das Web-Clip, das dem Startbildschirm Ihres Geräts hinzugefügt wurde.

1. Öffnen Sie auf Ihrem iOS-Testgerät die E-Mail, die von der Firebase App Distribution gesendet wurde, und tippen Sie auf den Link Jetzt starten. Öffne den Link in Safari.
2. Sie befinden sich jetzt in der Web-App für App Distribution Tester. Melden Sie sich auf der angezeigten Seite mit Ihrem Google-Konto an und tippen Sie auf Einladung annehmen.

3. Sie sehen jetzt die Releases, zu denen Sie eingeladen wurden. Tippen Sie unter einer der Versionen auf Gerät registrieren.

4. Laden Sie auf Aufforderung das Firebase-Profil herunter und installieren Sie es dann in den Einstellungen.

Durch die Installation des Profils erhält Firebase die Berechtigung,

• Registrieren Sie das Testgerät, indem Sie die eindeutige Geräte-ID (UDID) des Geräts erfassen.

Firebase sendet allen Inhabern und Bearbeitern des Firebase-Projekts eine E-Mail mit der UDID des Testgeräts.

• Installieren Sie einen Webclip auf dem Startbildschirm des Testgeräts. Über den Webclip wird die App Distribution Tester-Web-App geöffnet, über die Sie alle Ihre Test-Apps installieren und darauf zugreifen können.

In der App Distribution-Tester-Web-App ist Ihr Testgerät jetzt für die Veröffentlichung Ihrer App registriert.

Hinweis:Wenn Sie dieses Gerät bereits in der Vergangenheit Ihrem Entwicklerkonto hinzugefügt haben, wurde es möglicherweise bereits in das Bereitstellungsprofil aufgenommen. In diesem Fall wird hier bereits die Schaltfläche „Herunterladen“ angezeigt.

Nachdem Sie die UDID Ihres Testgeräts mit Firebase geteilt haben, können Sie jetzt als Entwickler fortfahren. Auf dem Tab Tester des Dashboards für die App-Verteilung werden Ihre Testerinformationen jetzt unter der Veröffentlichung Ihrer App mit dem Status „Akzeptiert“ angezeigt:

Im nächsten Abschnitt fügen Sie dem Bereitstellungsprofil Ihrer App die Geräte-UDID hinzu und erstellen dann eine Version Ihrer App, die mit Ihrem Testgerät funktioniert.

UDIDs der Testergeräte exportieren

Als Entwickler erhalten Sie eine E-Mail von Firebase mit der UDID des Testgeräts. Mit der App-Bereitstellung können Sie mehrere neue Geräte-UDIDs gleichzeitig erfassen, indem Sie sie direkt aus der Firebase Console als Rohtextdatei exportieren.

1. Wenn Sie alle UDIDs exportieren möchten, öffnen Sie den Tab Tester und Gruppen.

2. Klicken Sie auf Apple-UDIDs exportieren.

Die Datei sollte die UDID Ihres Testgeräts enthalten.

Device ID            Device Name                            Device Platform
1234567890     [e-mail] - iPhone SE 2nd Gen        ios

Die UDIDs können auch über die Befehlszeile mit fastlane exportiert werden. Das wird im nächsten Abschnitt erläutert.

6. Bereitstellungsprofil Ihrer App aktualisieren und neu erstellen

Fügen Sie nun die UDID Ihres Testgeräts dem Bereitstellungsprofil Ihrer App hinzu, erstellen Sie eine Version Ihrer App, die für Ihr Gerät funktioniert, und verteilen Sie die neue Version.

UDID-Export-Lane hinzufügen

1. Fügen Sie oben in der Fastfile eine weitere Variable hinzu und legen Sie einen Dateipfad fest, in den die UDIDs der Geräte Ihrer Tester heruntergeladen werden.

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "[e-mail]",
  "[e-mail]",
]
tester_udids_file = "tester_udids.txt"

2. Richten Sie eine neue Spur ein, in der die UDID-Exportaktion des App Distribution-Plug-ins verwendet wird, um die UDIDs der Tester herunterzuladen, genau wie Sie es über die Console getan haben.

lane :download_udids do
    firebase_app_distribution_get_udids(
        app: firebase_app_id,
        output_file: tester_udids_file,
    )
end

3. Führen Sie die folgende Lane aus, um die UDIDs herunterzuladen.

$ fastlane download_udids

4. Drucken Sie die heruntergeladene Datei aus, die die UDIDs der Testgeräte enthalten sollte.

$ cat tester_udids.txt

Geräte zur Apple Developer Console hinzufügen

1. Erstellen Sie die folgende Spur, um die UDIDs Ihrer Geräteliste in der Apple Developer Console hinzuzufügen, damit Sie sie mit der register_devices-Aktion von fastlane Ihrem Bereitstellungsprofil hinzufügen können:

lane :add_new_devices do
    register_devices(devices_file: tester_udids_file)
end

2. Führen Sie dann die Fahrspur aus:

$ fastlane add_new_devices

Die neuen Geräte sollten dann in der Geräteliste der Entwicklerkonsole angezeigt werden.

Geräte zum Bereitstellungsprofil hinzufügen

1. Fügen Sie dem Schritt für das Bereitstellungsprofil in Ihrer build-Lane das Argument force hinzu, damit bei jedem Build neue Geräte erkannt werden.

lane :build do
    get_certificates()
    get_provisioning_profile(adhoc: true, force: true)
    build_app(export_method: "ad-hoc")
end

Weitere Ausführung der Spur zum Erstellen und Hochladen

Aktualisieren Sie jetzt die distribute-Bahn mit den neuen Bahnen, um die Geräte dem Bereitstellungsprofil hinzuzufügen, die App neu zu erstellen und dann zu verteilen.

1. Neue Fahrstreifen über distribute aufrufen:

lane :distribute do
    download_udids
    add_new_devices
    build
    firebase_app_distribution(
        app: "1:123456789:ios:abcd1234",
        release_notes: "Try out this app!"
        testers: app_testers.join(","),
    )
end

2. Führen Sie die distribute-Leiter aus:

$ fastlane distribute

Ihre Fastfile sollte jetzt so aussehen:

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "[e-mail]",
  "[e-mail]",
]
tester_udids_file = "tester_udids.txt"

default_platform(:ios)

lane :build do
    get_certificates()
    get_provisioning_profile(adhoc: true, force: true)
    build_app(export_method: "ad-hoc")
end

lane :distribute do
    download_udids
    add_new_devices
    build
    firebase_app_distribution(
        app: firebase_app_id,
        release_notes: "Try out this app!",
        testers: app_testers.join(","),
    )
end

lane :download_udids do
    firebase_app_distribution_get_udids(
        app: firebase_app_id,
        output_file: tester_udids_file,
    )
end

lane :add_new_devices do
    register_devices(devices_file: tester_udids_file)
end

Release vom Testgerät herunterladen

Da Ihre App jetzt die UDIDs der Testgeräte enthält, können sie auf den Testgeräten installiert werden.

1. Kehren Sie auf Ihrem Testgerät über den Link in der E-Mail oder das Symbol auf dem Startbildschirm des Geräts zur Web-App „App Distribution Tester“ zurück.

Wenn Sie die UDID-Codelab-App aufrufen, sehen Sie, dass die Version zum Download bereit ist.

2. Wenn du ein physisches Gerät verwendest, klicke auf „Herunterladen“, installiere die App und starte sie.

Hinweis:Release-Downloads funktionieren nur auf physischen Geräten. Wenn Sie einen Simulator verwenden, funktioniert der Download nicht. Sie können aber trotzdem prüfen, ob die Einrichtung funktioniert hat, indem Sie prüfen, ob die Schaltfläche „Herunterladen“ in der App Distribution Tester-Webanwendung angezeigt wird.

7. Glückwunsch

Sie haben jetzt App Distribution und fastlane konfiguriert, um den Vorabveröffentlichungstest zu automatisieren. Wenn Sie jetzt zusätzliche Tester einladen oder Ihre App ihre UDIDs hinzufügen möchten, müssen Sie nur einen Befehl ausführen: fastlane distribute.

Sie müssen also nicht mehr einzeln UDIDs von Testern erfassen oder die Gerätelisten oder Nutzerverwaltungsprofile in der Apple Developer Console aktualisieren. Sie müssen nicht einmal Xcode öffnen.

Dieser Workflow lässt sich ganz einfach so einrichten, dass er stündlich oder täglich in Ihrer Continuous-Integration-Umgebung ausgeführt wird.

Weitere Informationen

• Informationen zu den Funktionen von Firebase App Distribution, einschließlich unseres In-App-SDKs für iOS
• Weitere Informationen zu fastlane
• Codesignatur Ihres Teams mit match verwalten
• fastlane in Ihre CI-Umgebung einbinden