Fastlane: automazione iOS su Cruise Control

Realizzare software per iOS non è solo scrivere codice Objective-C o Swift: implica sapere come funziona UIKit, come vengono realizzati i certificati, come pubblicare la tua app nello store, come gestire le recensioni delle app e altro ancora. Se trovi stancante questo eterno elenco di attività, un po' di automazione nel tuo flusso di lavoro è esattamente ciò di cui hai bisogno.

Scopri Fastlane, lo strumento progettato per farti risparmiare minuti o addirittura ore in ogni distribuzione.

Fastlane ti aiuta ad automatizzare il processo di invio di build beta a Crashlytics, TestFlight, App Store e molto altro.

In questo articolo imparerai come utilizzare Fastlane per automatizzare il flusso di lavoro di distribuzione delle app iOS. Sebbene ci concentreremo sull'aspetto iOS di questo strumento, Fastlane funziona ugualmente bene per l'automazione dello sviluppo Android.

Iniziare con Fastlane

Ci sono diversi metodi di installazione tra cui puoi scegliere, a seconda di quello che trovi più semplice. Se hai installato e configurato Homebrew, l'installazione di Fastlane richiede un solo comando:

 brew cask install fastlane

Altrimenti, essendo Fastlane uno strumento basato su Ruby, gem è sempre un'opzione:

 sudo gem install fastlane -NV

Oppure puoi sempre scaricare Fastlane dal sito ufficiale.

Dopo aver installato Fastlane, esegui fastlane init nella directory del tuo progetto e segui le istruzioni.

Automazione della distribuzione

Con Fastlane installato, ora puoi scrivere script Ruby per indicare passo dopo passo cosa devi fare per portare la tua distribuzione dove vuoi. Questo viene fatto utilizzando azioni, strumenti e corsie.

Strumenti, azioni e plug-in Fastlane

Fastlane funziona grazie agli strumenti al centro che ti aiutano a creare la tua app. Oltre agli strumenti di compilazione, ci sono oltre 170 integrazioni integrate con servizi come Crashlytics, HockeyApp, TestFlight e altri plug-in realizzati e pubblicati da terze parti in modo da poterti connettere ad altri servizi e altro ancora.

Fondamentalmente, ottieni gli strumenti principali che ti consentono di svolgere una varietà di attività: dall'acquisizione di schermate automatizzate all'inquadratura e al caricamento nello store, ti consente di eseguire automaticamente tutti i test prima di creare l'app.

Le azioni sono gli strumenti principali di Fastlane e i plug-in sono un modo per aggiungere azioni di terze parti alla configurazione di Fastlane.

Corsie

Fastlane utilizza corsie che essenzialmente raggruppano un elenco di azioni o plug-in in modo sequenziale in modo da poter ottenere lo stesso risultato ogni volta.

Quando si esegue una corsia, ogni azione esporterà una variabile di ambiente e le seguenti azioni otterranno automaticamente queste variabili per mantenere il processo in corso. Ad esempio, l'utilizzo dell'azione gym comporterà la generazione del percorso del file .ipa e l'utilizzo crashlytics accederà a questa posizione .ipa per caricare questo file nel sistema di distribuzione del servizio beta.

Utilizzo di Fastlane con iOS

Stai iniziando con un nuovo cliente Toptal che desidera un'app molto semplice. Il design è già fatto e l'app può essere codificata in poche settimane. Il passaggio successivo è iniziare a codificarlo e, durante il processo di iterazione, invierai un'app beta ogni due settimane al cliente in modo che possa vedere i tuoi progressi e darti un feedback su come funzionano le cose.

Ogni volta che invii una versione beta al client, eseguirai una checklist di base: firmare l'app, caricarla su un servizio beta, aggiungere una nuova versione, ecc. Aggiungi a questo le cose che devi fare una volta (ogni anno): firma di certificati, firma di certificati di notifica push (se necessario) e altro ancora.

Con Fastlane, ora tutto questo può accadere automaticamente!

Invio a Crashlytics Beta

Ad esempio, devi creare certificati di firma e profili di provisioning per condividere la tua app tramite Crashlytics Beta.

Fastlane ha un'azione chiamata match che, una volta impostata, esegue le seguenti operazioni:

1. Crea certificati di firma della distribuzione.
2. Crea un profilo di provisioning ad hoc (allegato al certificato dal n. 1).
3. Salva il certificato e il profilo da #1 e #2 in un repository Git, crittografato utilizzando OpenSSL.

La configurazione è semplice.

Innanzitutto, esegui fastlane match init per iniziare e, una volta impostato il repository Git, chiama semplicemente fastlane match adhoc per ottenere un profilo di provisioning ad hoc o esegui fastlane match appstore App Store per ottenere un certificato App Store.

I vantaggi dell'utilizzo di match sono che puoi sincronizzare i certificati molto facilmente tra computer e tra compagni di squadra senza dover più revocare i certificati e la velocità che guadagni. L'esecuzione di fastlane match appstore ti dà un certificato in un paio di secondi.

Bene, ora abbiamo i certificati e il provisioning di cui abbiamo bisogno, facciamo un rilascio a Crashlytics.

Un flusso di lavoro tipico per inviare la tua app a Crashlytics di Fabric include i seguenti passaggi:

1. Creare i certificati di firma della distribuzione.
2. Crea un profilo di provisioning ad hoc (allegato al certificato dal n. 1).
3. Imposta la tua app per utilizzare il profilo di provisioning dal n. 2.
4. Archivia la tua app.
5. Apri Fabric e segui i passaggi per inviare l'app ai beta tester.

Fastlane sostituisce il compito con questo:

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

Ora, l'esecuzione di fastlane beta dal tuo terminale avvierà questo script.

Questo chiamerà prima match , un'azione che gestisce la creazione e l'aggiornamento di certificati di firma e profili di provisioning, quindi chiamerà gym , un'azione che crea e pacchettizza l'app per te, utilizzando gli stessi certificati e profili creati in precedenza, e infine crashlytics , che è prenderò questo .ipa firmato e lo caricherò sul servizio Crashlytics.

Tutti questi passaggi vengono chiamati, sempre, nello stesso ordine, rendendo il file risultante più prevedibile e riducendo gli errori.

 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!

Quindi questa era una configurazione di base su come eseguire Fastlane per inviare la tua app a Crashlytics. Cos'altro possiamo automatizzare?

Versioni build incrementali

Possiamo, ad esempio, impostare che ogni volta che invieremo una beta, vogliamo aumentare il numero di versione della build.

Ciò può essere ottenuto utilizzando un'azione chiamata increment_build_number che può essere chiamata da un terminale tramite la fastlane run increment_build_number o utilizzata inline nella nostra corsia beta:

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

Congratulazioni! Ora hai uno script di distribuzione automatizzato che incrementa anche il numero di versione della build. L'unico avvertimento è che, una volta chiamata questa corsia, i file verranno modificati nel progetto (o, almeno, quelli che incorporano il numero di build).

Nel caso in cui avessi comunque intenzione di eseguire il commit di quella modifica nel repository, c'è un'azione per questo: commit_version_bump . Questa azione salva i file con il nuovo numero di versione.

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

Questo eseguirà il commit dei file con un messaggio di commit come questo "Version Bump to 27".

Crashlytics a TestFlight

Bene, se sei arrivato così lontano, puoi avere una distribuzione automatizzata in Crashlytics in pochissimo tempo che ti farà risparmiare innumerevoli ore a lungo termine. La parte migliore è che se invece volessi inviare la tua app a TestFlight, tutto ciò che dovresti fare è cambiare crashlytics in pilot .

Oppure puoi creare una corsia separata per questo:

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

Automazione iOS resa semplice

Fastlane è semplice e facile da usare. Ma apporta un valore straordinario al tuo normale flusso di lavoro di sviluppo iOS risparmiandoti dal fare cose umili e ore del tuo tempo che avresti finito per sprecare.

Spero che troverai utile questa introduzione a Fastlane. Puoi consultare la documentazione ufficiale per saperne di più su Fastlane, in particolare l'elenco delle azioni se stai cercando ispirazione su ciò che potresti automatizzare per i tuoi progetti iOS attuali e futuri.