Fastlane : automatisation iOS sur le régulateur de vitesse

Créer un logiciel pour iOS ne se limite pas à écrire du code Objective-C ou Swift : il s'agit de savoir comment UIKit fonctionne, comment les certificats sont créés, comment publier votre application dans le magasin, comment gérer les critiques d'applications, etc. Si vous trouvez cette éternelle liste de tâches fatigante, une certaine automatisation de votre flux de travail est exactement ce dont vous avez besoin.

Découvrez Fastlane, l'outil conçu pour vous faire gagner des minutes voire des heures à chaque déploiement.

Fastlane vous aide à automatiser le processus d'envoi des versions bêta à Crashlytics, TestFlight, l'App Store et bien plus encore.

Dans cet article, vous apprendrez comment vous pouvez utiliser Fastlane pour automatiser le workflow de déploiement de votre application iOS. Bien que nous nous concentrions sur l'aspect iOS de cet outil, Fastlane fonctionne également bien pour l'automatisation du développement Android.

Premiers pas avec Fastlane

Vous pouvez choisir entre plusieurs méthodes d'installation, en fonction de ce que vous trouvez le plus simple. Si Homebrew est installé et configuré, l'installation de Fastlane ne prend qu'une seule commande :

 brew cask install fastlane

Sinon, Fastlane étant un outil basé sur Ruby, gem est toujours une option :

 sudo gem install fastlane -NV

Ou, vous pouvez toujours télécharger Fastlane depuis le site officiel.

Une fois que vous avez installé Fastlane, exécutez fastlane init dans le répertoire de votre projet et suivez les instructions.

Automatisation du déploiement

Avec Fastlane installé, vous pouvez maintenant écrire des scripts Ruby pour indiquer étape par étape ce que vous devez faire pour obtenir votre déploiement là où vous le souhaitez. Cela se fait à l'aide d'actions, d'outils et de voies.

Outils, actions et plugins Fastlane

Fastlane fonctionne en ayant des outils en son cœur qui vous aident à créer votre application. En plus des outils de construction, il existe plus de 170 intégrations intégrées avec des services tels que Crashlytics, HockeyApp, TestFlight et d'autres plugins que des tiers créent et publient afin que vous puissiez vous connecter à d'autres services et plus encore.

À la base, vous obtenez les principaux outils qui vous permettent d'effectuer une variété de tâches : de la prise de captures d'écran automatisées à leur cadrage et à leur téléchargement sur le magasin, il vous permet d'exécuter tous vos tests automatiquement avant de créer l'application.

Les actions sont les outils de base de Fastlane, et les plugins sont un moyen d'ajouter des actions tierces à votre configuration Fastlane.

Voies

Fastlane utilise des voies qui regroupent essentiellement une liste d'actions ou de plugins de manière séquentielle afin que vous puissiez obtenir le même résultat à chaque fois.

Lors de l'exécution d'une voie, chaque action exportera une variable d'environnement, et les actions suivantes obtiendront automatiquement ces variables pour poursuivre le processus. Par exemple, l'utilisation de l'action gym entraînera la génération du chemin du fichier .ipa , et l'utilisation crashlytics à cet emplacement .ipa pour télécharger ce fichier sur son système de distribution de service bêta.

Utiliser Fastlane avec iOS

Vous démarrez avec un nouveau client Toptal qui veut une application très simple. Le design est déjà fait, et l'application peut être codée en quelques semaines. La prochaine étape consiste à commencer à le coder, et pendant votre processus d'itération, vous allez envoyer une application bêta toutes les deux semaines au client afin qu'il puisse voir vos progrès et vous donner des commentaires sur la façon dont les choses fonctionnent.

Chaque fois que vous envoyez une version bêta au client, vous allez passer par une liste de contrôle de base : signer l'application, la télécharger sur un service bêta, y ajouter une nouvelle version, etc. Ajoutez à cela les choses que vous devez faire une fois (tous les ans) : signature de certificats, signature de certificats de notification push (si nécessaire), etc.

Avec Fastlane, tout cela peut désormais se produire automatiquement !

Envoi vers la version bêta de Crashlytics

Par exemple, vous devez créer des certificats de signature et des profils d'approvisionnement pour partager votre application via Crashlytics Beta.

Fastlane a une action appelée match qui, une fois que vous l'avez configurée, fait ce qui suit :

1. Créer des certificats de signature de distribution.
2. Créez un profil d'approvisionnement ad hoc (attaché au certificat de #1).
3. Enregistrez le certificat et le profil de #1 et #2 dans un référentiel Git, chiffré à l'aide d'OpenSSL.

La configuration est simple.

Tout d'abord, exécutez fastlane match init pour commencer et, une fois que vous avez défini votre référentiel Git, appelez simplement fastlane match adhoc pour obtenir un profil de provisionnement ad hoc ou exécutez fastlane match appstore pour obtenir un certificat App Store.

Les avantages de l'utilisation de match sont que vous pouvez synchroniser très facilement les certificats entre ordinateurs - et entre coéquipiers - sans plus avoir à révoquer les certificats, et la vitesse que vous gagnez. Le simple fait d'exécuter fastlane match appstore vous donne un certificat en quelques secondes.

Eh bien, maintenant que nous avons les certificats et le provisionnement dont nous avons besoin, publions Crashlytics.

Un flux de travail typique pour soumettre votre application à Fabric's Crashlytics comprend les étapes suivantes :

1. Créez les certificats de signature de distribution.
2. Créez un profil d'approvisionnement ad hoc (attaché au certificat de #1).
3. Configurez votre application pour utiliser le profil d'approvisionnement de #2.
4. Archivez votre application.
5. Ouvrez Fabric et suivez les étapes pour envoyer l'application aux bêta-testeurs.

Fastlane remplace la corvée par ceci :

 platform :ios do lane :beta do match(type: “adhoc”) gym crashlytics end end

Maintenant, l'exécution de fastlane beta à partir de votre terminal lancera ce script.

Cela appellera d'abord match , une action qui gère la création et la mise à jour des certificats de signature et des profils d'approvisionnement, puis appellera gym , une action qui construit et conditionne l'application pour vous, en utilisant les mêmes certificats et profils créés auparavant, et enfin, crashlytics , qui est va prendre ce .ipa signé et le télécharger sur le service Crashlytics.

Toutes ces étapes sont appelées, toujours, dans le même ordre, ce qui rend le fichier résultant plus prévisible et réduit les erreurs.

 MacBook-Pro:TestProject user$ fastlane beta +------+-------------------------------------+-------------+ | fastlane summary | +------+-------------------------------------+-------------+ | Step | Action | Time (in s) | +------+-------------------------------------+-------------+ | 1 | Verifying required fastlane version | 0 | | 2 | match | 57 | | 3 | gym | 592 | | 4 | crashlytics | 195 | +------+-------------------------------------+-------------+ [20:25:13]: fastlane.tools just saved you 14 minutes!

C'était donc une configuration de base pour savoir comment exécuter Fastlane pour envoyer votre application à Crashlytics. Que pouvons-nous automatiser d'autre ?

Incrémentation des versions de build

Nous pouvons, par exemple, définir qu'à chaque fois que nous allons envoyer une version bêta, nous voulons augmenter le numéro de version de build.

Ceci peut être réalisé en utilisant une action appelée increment_build_number qui peut être appelée à partir d'un terminal par fastlane run increment_build_number ou utilisée en ligne dans notre voie bêta :

 platform :ios do lane :beta do increment_build_number match(type: “adhoc”) gym crashlytics end end

Toutes nos félicitations! Vous disposez maintenant d'un script de déploiement automatisé qui incrémente également votre numéro de version de build. La seule mise en garde est qu'une fois que vous appelez cette voie, vous allez avoir des fichiers modifiés dans votre projet (ou, au moins, ceux qui intègrent le numéro de build).

Au cas où vous envisagiez de toute façon de valider cette modification dans le référentiel, il existe une action pour cela : commit_version_bump . Cette action valide les fichiers avec le nouveau numéro de version.

 platform :ios do lane :beta do increment_build_number match(type: "adhoc") gym crashlytics commit_version_bump( xcodeproj:"myProject.xcodeproj", ) end end

Cela validera les fichiers avec un message de validation comme celui-ci "Version Bump to 27".

Crashlytics à TestFlight

Eh bien, si vous êtes arrivé jusque-là, vous pouvez avoir un déploiement automatisé sur Crashlytics en très peu de temps, ce qui vous fera économiser d'innombrables heures à long terme. La meilleure partie à ce sujet est que si vous vouliez envoyer votre application à TestFlight à la place, tout ce que vous auriez à faire est de changer crashlytics en pilot .

Ou, vous pouvez créer une voie séparée pour cela :

 platform :ios do lane :beta-testflight do increment_build_number match(type: "adhoc") gym pilot commit_version_bump( xcodeproj:"myProject.xcodeproj", ) end end

L'automatisation iOS simplifiée

Fastlane est simple et facile à utiliser. Mais cela apporte une valeur incroyable à votre flux de travail de développement iOS habituel en vous évitant de faire des choses subalternes et des heures de votre temps que vous auriez fini par perdre.

J'espère que cette introduction à Fastlane vous sera utile. Vous pouvez consulter la documentation officielle pour en savoir plus sur Fastlane, en particulier la liste des actions si vous cherchez de l'inspiration sur ce que vous pourriez automatiser pour vos projets iOS actuels et à venir.