Distribuez vos builds iOS préliminaires plus rapidement avec App Distribution et Fastlane

1. Avant de commencer

4cddd34bd261cea0.png

Dans cet atelier de programmation, vous allez apprendre à utiliser Firebase App Distribution et son plug-in fastlane pour distribuer une application iOS à des testeurs, collecter les UDID des appareils de test et les enregistrer dans le profil de provisionnement de votre application. Vous pourrez ainsi mettre rapidement des versions ad hoc à la disposition des testeurs.

Points abordés

  • Découvrez comment importer et distribuer une application iOS en version préliminaire (ad hoc) à des testeurs à l'aide de Firebase App Distribution et de fastlane.
  • Découvrez comment vous inscrire en tant que testeur et télécharger l'application distribuée sur un appareil de test.
  • Découvrez comment enregistrer rapidement des appareils de test en exportant leurs UDID avec le plug-in fastlane d'App Distribution.
  • Découvrez comment mettre à jour le profil de provisionnement de votre application et le réimporter pour la distribution.

Prérequis

  • Un compte Google
  • Un ordinateur Apple avec XCode 11.7 ou version ultérieure installé
  • Application iOS Ad Hoc en version préliminaire créée dans Xcode
  • Un compte de développeur Apple payant
  • Un appareil iOS physique pour les tests.

L' application de simulateur iOS fonctionnera pour la majeure partie de l'atelier de programmation, mais les simulateurs ne peuvent pas télécharger de versions.

Vous pouvez toujours vérifier que la configuration a fonctionné en vous assurant que le bouton "Télécharger" s'affiche dans l'application Web de testeurs App Distribution.

2. Commencer

Configurer fastlane

App Distribution s'intègre à fastlane pour vous permettre d'automatiser la distribution des versions préliminaires de votre application. App Distribution s'intègre à votre configuration fastlane.

  1. Installez et configurez fastlane.
  2. Exécutez fastlane init dans le répertoire racine de votre projet lors de la configuration, puis sélectionnez "Configuration manuelle". Vous verrez un sous-répertoire appelé fastlane contenant Fastfile, Appfile et Pluginfile, que vous utiliserez pour configurer fastlane.

Installer la CLI Firebase

Vous devrez également installer la CLI Firebase. Si vous utilisez macOS ou Linux, vous pouvez exécuter la commande cURL suivante :

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

Si vous utilisez Windows, consultez les instructions d'installation pour obtenir un fichier binaire autonome ou pour installer l'outil via npm.

Une fois la CLI installée, l'exécution de firebase --version devrait renvoyer une version 12.0.0 ou ultérieure :

$ firebase --version
12.0.0

3. Compiler votre application avec fastlane

Créer votre application

  1. Définissez des variables globales pour fastlane dans votre fichier ./fastlane/Appfile.. Incluez l'ID de votre application et votre identifiant Apple :
app_identifier("<your app's bundle identifier>")
apple_id("<your Apple id>")
  1. Créez votre premier couloir et utilisez l'action build_app de fastlane (également appelée gym) pour compiler votre application en ajoutant les éléments suivants à votre ./fastlane/Fastfile :
default_platform(:ios)

lane :build do
    build_app(export_method: "ad-hoc")
end
  1. Signez votre application pour la distribuer.

Pour cet atelier de programmation, vous allez gérer votre propre certification et votre propre profil à l'aide de get_certificates (également appelé cert), qui génère des certificats de signature en local et stocke tout dans votre trousseau macOS. Toutefois, vous préférerez généralement utiliser fastlane sync_code_signing action (également appelé match) pour gérer de manière sécurisée les certificats et profils de signature de code de votre équipe.

lane :build do
    get_certificates()
    build_app(export_method: "ad-hoc")
end
  1. Configurez un profil de provisionnement pour votre application à l'aide de l'action get_provisioning_profile (également appelée sigh). Cela vous permet de partager votre application avec des testeurs.
lane :build do
    get_certificates()
    get_provisioning_profile(adhoc: true)
    build_app(export_method: "ad-hoc")
end
  1. [Facultatif] Si vous n'avez jamais exécuté votre application auparavant, exécutez la commande suivante pour la créer dans la console de développement Apple :

$ fastlane produce --skip_itc

  1. Enfin, compilez votre application en exécutant la voie.

Vous serez invité à saisir votre identifiant Apple, votre mot de passe (qui est stocké dans votre trousseau d'accès) et l'ID du bundle de votre application.

$ fastlane build

Si vous rencontrez des problèmes, veuillez consulter le guide de dépannage fastlane.

4. Importer votre application dans Firebase

Maintenant que vous avez créé votre application, vous pouvez l'importer dans App Distribution.

Créer un projet Firebase

  1. Connectez-vous à la console Firebase à l'aide de votre compte Google.
  2. Cliquez sur le bouton pour créer un projet, puis saisissez un nom (par exemple, UDID Export Codelab).
  3. Cliquez sur Continuer.
  4. Si vous y êtes invité, lisez et acceptez les Conditions d'utilisation de Firebase, puis cliquez sur Continuer.
  5. (Facultatif) Activez l'assistance IA dans la console Firebase (appelée "Gemini dans Firebase").
  6. Pour cet atelier de programmation, vous n'avez pas besoin de Google Analytics. Désactivez donc l'option Google Analytics.
  7. Cliquez sur Créer un projet, attendez que votre projet soit provisionné, puis cliquez sur Continuer.

Ajoutez votre application iOS au projet.

  1. Cliquez sur l'icône iOS pour créer une application iOS Firebase, puis saisissez l'ID du bundle de votre application.

9c26c130a6c42212.png

  1. Ignorez les étapes suivantes, puis cliquez sur Continue to console (Accéder à la console). Vous ajouterez des SDK à votre application ultérieurement.

Votre projet et votre application sont désormais disponibles sur la page Présentation du projet.

66f79cc8a97fa8e9.png

Activer App Distribution

  1. Dans la section "Release & Monitor" (Publier et surveiller), cliquez sur App Distribution (Distribution d'applications).
  2. Après avoir accepté les conditions, cliquez sur "Premiers pas" pour activer App Distribution pour votre application.

460213326c2784ae.png

Configurer une distribution dans fastlane

  1. Exécutez la commande suivante à partir de la racine de votre projet iOS pour ajouter App Distribution à votre configuration fastlane.

Si la commande vous invite à choisir une option, sélectionnez Option 3 : RubyGems.org :

$ fastlane add_plugin firebase_app_distribution

  1. Vérifiez que le plug-in est installé :

$ fastlane

Le résultat doit afficher fastlane-plugin-firebase_app_distribution dans la liste des plug-ins installés.

  1. Après avoir confirmé que le plug-in est installé, sélectionnez l'option 0 pour annuler.

Authentifier votre projet Firebase

Pour utiliser le plug-in fastlane, vous devez d'abord authentifier votre projet Firebase.

  1. Exécutez la commande suivante pour connecter la CLI à votre compte Google :

$ firebase login

  1. Lorsque la commande affiche un lien d'authentification, ouvrez-le dans un navigateur.
  2. Lorsque vous y êtes invité, connectez-vous à votre compte Google et autorisez l'accès à votre projet Firebase.

Distribuer votre application

Vous êtes maintenant prêt à distribuer votre application.

  1. En haut de votre ./fastlane/Fastfile, définissez une variable appelée firebase_app_id. Remplacez <your_app_id> par l'ID d'application Firebase de l'application que vous avez créée (vous le trouverez sur la page Paramètres du projet).

Fastfile est écrit en Ruby. Utilisez donc la syntaxe Ruby pour définir les variables.

firebase_app_id = "<your_app_id>"
  1. Ajoutez une voie nommée distribute qui appelle la voie de compilation, puis distribuez votre application à l'aide de l'action firebase_app_distribution.
lane :distribute do
    build
    firebase_app_distribution(
        app: firebase_app_id,
        release_notes: "Try out this app!",
    )
end
  1. Exécutez la nouvelle voie pour compiler votre application et créer une distribution.

$ fastlane distribute

À ce stade, votre Fastfile devrait se présenter comme suit :

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

Après avoir actualisé la console Firebase, vous verrez la nouvelle version de votre application.

c59dc1a94de3bf3c.png

5. Inviter des testeurs à télécharger votre application

Lorsqu'un testeur accepte une invitation à tester une version ad hoc, il est invité à autoriser le partage de son UDID. S'il accepte, App Distribution collecte les informations sur son appareil et vous envoie une notification par e-mail. Dans cette section, vous allez vous ajouter en tant que testeur pour télécharger et tester l'application que vous avez distribuée.

Vous ajouter en tant que testeur de la version

  1. Sous firebase_app_id en haut de votre Fastfile, créez une variable pour stocker les testeurs et incluez votre propre adresse e-mail, ainsi que d'autres adresses e-mail facultatives que vous souhaitez essayer.
firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "your@email.com",
  "another@email.com",
]
  1. Appliquez la méthode Array#join de Ruby pour transformer le tableau app_testers en chaîne de caractères séparée par des virgules, ce que le paramètre testers attend. Transmettez ensuite le résultat au paramètre testers de 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

À ce stade, votre Fastfile devrait se présenter comme suit :

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "your@email.com",
  "another@email.com",
]

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
  1. Exécutez à nouveau la voie.

$ fastlane distribute

Une fois le canal exécuté, les testeurs que vous avez ajoutés recevront un e-mail d'invitation d'App Distribution les informant de la nouvelle version disponible. Dans la console Firebase, vous pouvez désormais voir les testeurs que vous avez ajoutés à la version de votre application.

2e0fc9603b868af8.png

Comme vous avez inclus votre adresse e-mail, vous recevrez un e-mail de Firebase App Distribution vous invitant à tester l'application. Vous êtes désormais le premier testeur ! Poursuivez avec la section ci-dessous pour configurer votre appareil de test en tant que testeur.

Enregistrer votre appareil de test

En tant que testeur, vous devez vous connecter à Google sur votre appareil de test pour accéder aux versions de l'application que vous avez été invité à tester. Étant donné que votre version de test est une version ad hoc, vous devez également enregistrer votre appareil de test en installant le profil Firebase. Vous pourrez ensuite accéder aux versions disponibles dans l'application Web de testeurs App Distribution à l'aide du webclip ajouté à l'écran d'accueil de votre appareil.

  1. Sur votre appareil de test iOS, ouvrez l'e-mail envoyé par Firebase App Distribution, puis appuyez sur le lien Commencer. Veillez à ouvrir le lien dans Safari.
  2. Vous êtes maintenant dans l'application Web de testeurs App Distribution. Sur la page qui s'affiche, connectez-vous avec votre compte Google et appuyez sur Accepter l'invitation.

d833407de251b89f.png

  1. Vous pouvez désormais voir les versions auxquelles vous avez été invité. Appuyez sur Enregistrer l'appareil sous l'une des versions.

fd141215e54a938d.png

  1. Lorsque vous y êtes invité, téléchargez le profil Firebase, puis installez-le dans l'application Paramètres.

L'installation du profil donne à Firebase l'autorisation de :

  • Enregistrez l'appareil de test en collectant son identifiant unique (UDID).

Firebase envoie un e-mail à tous les propriétaires et éditeurs du projet Firebase, qui inclut l'UDID de l'appareil de test.

  • Installez un extrait Web sur l'écran d'accueil de l'appareil de test. Le web clip ouvre l'application Web de testeur App Distribution, qui vous permet d'installer et d'accéder à toutes vos applications de test.

Dans l'application Web de testeurs App Distribution, votre appareil de test est désormais enregistré pour la version de votre application.

fe93d649dfa25877.png

Maintenant que vous avez partagé l'UDID de votre appareil de test avec Firebase, vous pouvez reprendre votre rôle de développeur. Dans l'onglet Testeurs du tableau de bord App Distribution, les informations sur vos testeurs s'affichent désormais sous la version de votre application avec l'état "Accepté" :

7b9f665a63a384cf.png

Dans la section suivante, vous ajouterez l'UDID de l'appareil au profil de provisionnement de votre application, puis vous créerez une version de votre application qui fonctionne avec votre appareil de test.

Exporter les UDID des appareils de vos testeurs

En tant que développeur, vous recevrez un e-mail de Firebase contenant l'UDID de l'appareil de test. App Distribution vous permet de collecter facilement plusieurs UDID de nouveaux appareils à la fois en les exportant directement depuis la console Firebase sous forme de fichier texte brut.

  1. Pour exporter tous les UDID, ouvrez l'onglet Testeurs et groupes.

241a9936898a2fc0.png

  1. Cliquez sur Exporter les UDID Apple.

bcf0c26c522d9b4e.png

Le fichier doit contenir l'UDID de votre appareil de test.

Device ID            Device Name                            Device Platform
1234567890     udid.codelab.tester@gmail.com - iPhone SE 2nd Gen        ios

Vous pouvez également exporter les UDID à partir de la ligne de commande à l'aide de fastlane, comme vous le ferez dans la section suivante.

6. Mettre à jour le profil de provisionnement de votre application et la recompiler

Vous allez maintenant ajouter l'UDID de votre appareil de test au profil de provisionnement de votre application, recompiler une version de votre application qui fonctionne pour votre appareil et distribuer la nouvelle version.

Ajouter une voie d'exportation d'UDID

  1. Ajoutez une autre variable en haut de votre Fastfile et définissez-la sur un chemin d'accès au fichier où les UDID des appareils de vos testeurs seront téléchargés.
firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "your@email.com",
  "another@email.com",
]
tester_udids_file = "tester_udids.txt"
  1. Configurez une voie qui utilise l'action d'exportation d'UDID du plug-in App Distribution pour télécharger les UDID des testeurs, comme vous l'avez fait depuis la console.
lane :download_udids do
    firebase_app_distribution_get_udids(
        app: firebase_app_id,
        output_file: tester_udids_file,
    )
end
  1. Exécutez la voie suivante pour télécharger les UDID.

$ fastlane download_udids

  1. Imprimez le fichier téléchargé, qui doit contenir les UDID des appareils de test.

$ cat tester_udids.txt

Ajouter des appareils à la console de développement Apple

  1. Créez la voie suivante pour ajouter les UDID à la liste des appareils dans la console de développeur Apple. Vous pourrez ensuite les ajouter à votre profil de provisionnement à l'aide de l'action register_devices de fastlane  :
lane :add_new_devices do
    register_devices(devices_file: tester_udids_file)
end
  1. Exécutez ensuite la voie :

$ fastlane add_new_devices

Vous devriez alors voir les nouveaux appareils dans la liste des appareils de votre console pour les développeurs.

Ajouter des appareils à votre profil de provisionnement

  1. Ajoutez l'argument force à l'étape du profil de provisionnement dans votre voie build afin de forcer la récupération de nouveaux appareils à chaque compilation.
lane :build do
    get_certificates()
    get_provisioning_profile(adhoc: true, force: true)
    build_app(export_method: "ad-hoc")
end

Exécuter à nouveau la voie pour compiler et importer

Vous allez maintenant mettre à jour votre voie distribute avec les nouvelles voies afin d'ajouter les appareils au profil de provisionnement, de recompiler l'application, puis de la distribuer.

  1. Appelez les nouvelles voies à partir de distribute :
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
  1. Exécutez la voie distribute :

$ fastlane distribute

À ce stade, votre Fastfile devrait se présenter comme suit :

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "your@email.com",
  "another@email.com",
]
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

Télécharger la version depuis l'appareil de test

Maintenant que votre application inclut les UDID des appareils de test, elle peut être installée sur ces appareils.

e275f73d57cc8fb1.png

  1. Sur votre appareil de test, revenez à l'application Web de testeurs App Distribution en utilisant le lien dans l'e-mail ou l'icône sur l'écran d'accueil de l'appareil.

Lorsque vous accédez à l'application de l'atelier de programmation UDID, vous pouvez voir que la version est prête à être téléchargée.

dad6d03b6ad78746.png

  1. Si vous utilisez un appareil physique, appuyez sur "Télécharger", puis installez et exécutez l'application.

7. Félicitations

Vous avez maintenant configuré App Distribution et fastlane pour automatiser votre processus de test des versions préliminaires. Désormais, lorsque vous souhaitez inviter des testeurs supplémentaires ou ajouter leurs UDID à votre application, il vous suffit d'exécuter une seule commande : fastlane distribute.

Vous n'aurez donc plus besoin de collecter individuellement les UDID des testeurs ni d'accéder à la console de développement Apple pour mettre à jour les listes d'appareils ou les profils de provisionnement. Vous n'avez même pas besoin d'ouvrir Xcode.

Ce workflow est facile à configurer pour s'exécuter toutes les heures ou tous les jours dans votre environnement d'intégration continue.

Documentation complémentaire