Distribuisci le tue build iOS pre-release più velocemente con App Distribution e Fastlane

1. Prima di iniziare

In questo codelab, scoprirai come utilizzare Firebase App Distribution e il relativo plug-in fastlane per distribuire un'app per iOS ai tester, raccogliere gli UDID dei dispositivi di test e registrarli nel profilo di provisioning della tua app, in modo da poter mettere rapidamente a disposizione dei tester le build ad hoc.

Obiettivi didattici

• Come caricare e distribuire un'app iOS di pre-release (ad hoc) ai tester utilizzando Firebase App Distribution e fastlane.
• Come registrarsi come tester e scaricare l'app distribuita su un dispositivo di test.
• Come registrare rapidamente i dispositivi di test esportandone gli UDID con il plug-in fastlane di App Distribution.
• Come aggiornare il profilo di provisioning dell'app e ricaricarlo per la distribuzione.

Che cosa ti serve

• Un Account Google
• Un computer Apple con Xcode 11.7 o versioni successive installate
• Un'app iOS pre-release Ad Hoc creata in Xcode
• Un account sviluppatore Apple a pagamento
• Un dispositivo iOS fisico per i test.

L' app simulatore per iOS funziona per la maggior parte del codelab, ma i simulatori non possono scaricare le release.

Puoi comunque verificare che la configurazione abbia funzionato controllando che il pulsante "Scarica" venga visualizzato nell'app web App Distribution Tester.

2. Inizia

Configura fastlane

App Distribution si integra con fastlane per consentirti di automatizzare la distribuzione delle build pre-release della tua app. App Distribution si integra con la configurazione di fastlane.

1. Installa e configura fastlane.
2. Esegui fastlane init nella directory principale del progetto durante la configurazione e scegli "Configurazione manuale". Vedrai una sottodirectory denominata fastlane che contiene Fastfile, Appfile e Pluginfile, che utilizzerai per configurare fastlane.

Installa l'interfaccia a riga di comando di Firebase

Dovrai anche installare l'interfaccia a riga di comando di Firebase. Se utilizzi macOS o Linux, puoi eseguire il seguente comando cURL:

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

Se utilizzi Windows, leggi le istruzioni di installazione per ottenere un file binario autonomo o per installare il programma tramite npm.

Dopo aver installato la CLI, l'esecuzione di firebase --version dovrebbe segnalare una versione di 12.0.0 o successiva:

$ firebase --version
12.0.0

3. Crea la tua app con fastlane

Creare l'app

1. Imposta alcune variabili globali per fastlane in ./fastlane/Appfile. Includi l'ID della tua app e il tuo ID Apple:

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

2. Crea la tua prima corsia e utilizza l'azione build_app di fastlane (nota anche come gym) per creare la tua app aggiungendo quanto segue a ./fastlane/Fastfile:

default_platform(:ios)

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

3. Firma l'app per la distribuzione.

Per questo codelab, gestirai la tua certificazione e il tuo profilo utilizzando get_certificates (noto anche come cert), che genera certificati di firma localmente e archivia tutto nel portachiavi macOS. In genere, però, ti consigliamo di utilizzare fastlane sync_code_signing action (noto anche come match) per gestire in sicurezza i certificati e i profili di firma del codice del tuo team.

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

4. Configura un profilo di provisioning per la tua app utilizzando l'azione get_provisioning_profile (nota anche come sigh). In questo modo puoi condividere la tua app con i tester.

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

5. [Facoltativo] Se non hai mai eseguito l'app, esegui il seguente comando per crearla nella console per sviluppatori Apple:

$ fastlane produce --skip_itc

6. Infine, crea l'app eseguendo la corsia.

Ti verranno chiesti il tuo ID Apple, la password (memorizzata nel Portachiavi) e l'ID pacchetto della tua app.

$ fastlane build

In caso di problemi, consulta la guida alla risoluzione dei problemi di fastlane.

4. Carica la tua app su Firebase

Ora che hai creato l'app, puoi caricarla su App Distribution.

Crea e configura un progetto Firebase

1. Accedi a Firebase.
2. Nella Console Firebase, crea o aggiungi un nuovo progetto e poi assegnagli il nome "Codelab di esportazione di UDID".

Non è necessario abilitare Google Analytics per questo progetto.

3. Fai clic su Crea progetto.

Aggiungere l'app per iOS al progetto

1. Fai clic sull'icona per iOS per creare una nuova app Firebase per iOS e inserisci l'ID bundle dell'app.

2. Salta i passaggi successivi, quindi fai clic su Continua su Console. Aggiungerai gli SDK alla tua app in un secondo momento.

Il progetto e l'app sono ora disponibili nella pagina Panoramica del progetto.

Abilitare la distribuzione di app

1. Nella sezione Rilascia e monitora, fai clic su Distribuzione app.
2. Dopo aver accettato i termini, fai clic su "Inizia" per attivare la distribuzione di app per la tua app.

Configurare una distribuzione in fastlane

1. Esegui il seguente comando dalla directory principale del progetto iOS per aggiungere la distribuzione di app alla configurazione di fastlane.

Se il comando ti chiede un'opzione, seleziona Opzione 3: RubyGems.org:

$ fastlane add_plugin firebase_app_distribution

2. Verifica che il plug-in sia installato:

$ fastlane

L'output dovrebbe mostrare fastlane-plugin-firebase_app_distribution nell'elenco dei plug-in installati.

3. Dopo aver verificato che il plug-in sia installato, scegli l'opzione 0 per annullare.

Autenticare il progetto Firebase

Per utilizzare il plug-in fastlane, devi prima autenticare il tuo progetto Firebase.

1. Esegui il seguente comando per connettere la CLI al tuo Account Google:

$ firebase login

2. Quando il comando stampa un link di autenticazione, apri il link in un browser.
3. Quando richiesto, accedi al tuo Account Google e concedi l'autorizzazione ad accedere al tuo progetto Firebase.

Distribuire l'app

Ora puoi distribuire l'app.

1. Nella parte superiore di ./fastlane/Fastfile, definisci una variabile denominata firebase_app_id. Sostituisci <your_app_id> con l'ID app Firebase dell'app che hai creato (lo trovi nella pagina Impostazioni progetto).

Fastfile è scritto in Ruby, quindi utilizza la sintassi di Ruby per definire le variabili.

firebase_app_id = "<your_app_id>"

2. Aggiungi una nuova corsia denominata distribute che chiami la corsia di compilazione e poi distribuisci l'app utilizzando l'azione firebase_app_distribution.

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

3. Esegui la nuova corsia per compilare l'app e creare una distribuzione.

$ fastlane distribute

A questo punto, il file Fastfile dovrebbe avere il seguente aspetto:

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

Dopo aver aggiornato la Console Firebase, vedrai la nuova release per la tua app.

5. Invitare i tester a scaricare la tua app

Quando un tester accetta un invito a testare una build ad hoc, gli viene chiesta l'autorizzazione a condividere il proprio UDID. Se accetta, App Distribution raccoglie le informazioni sul dispositivo e ti invia una notifica via email. In questa sezione, ti aggiungerai come tester per scaricare e testare l'app che hai distribuito.

Aggiungere te stesso come tester alla release

1. Sotto firebase_app_id nella parte superiore del Fastfile, crea una variabile per contenere i tester e includi il tuo indirizzo email, nonché altri indirizzi email facoltativi che vuoi provare.

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

2. Applica il metodo Array#join di Ruby per trasformare l'array app_testers in una stringa separata da virgole, come previsto dal parametro testers. Quindi, passa il risultato al parametro testers di 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

A questo punto, il tuo file Fastfile dovrebbe avere il seguente aspetto:

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

3. Esegui di nuovo la corsia.

$ fastlane distribute

Una volta eseguita la corsia, i tester che hai aggiunto riceveranno un'email di invito da App Distribution che li informerà della nuova release disponibile. Nella Console Firebase, ora puoi vedere i tester che hai aggiunto alla release della tua app.

Poiché hai incluso il tuo indirizzo email, riceverai un'email da Firebase App Distribution che ti invita a testare l'app. Ora sei il primo tester. Continua con la sezione di seguito per configurare il tester sul tuo dispositivo di test.

Registrare il dispositivo di test

In qualità di tester, dovrai accedere a Google sul tuo dispositivo di test per accedere alle release dell'app che ti è stato chiesto di testare. Poiché la build di test è una release ad hoc, dovrai anche registrare il dispositivo di test installando il profilo Firebase. In seguito, potrai accedere alle release disponibili dall'app web App Distribution Tester utilizzando il clip web aggiunto alla schermata Home del tuo dispositivo.

1. Sul dispositivo di test iOS, apri l'email inviata da Firebase App Distribution e tocca il link Inizia. Assicurati di aprire il link in Safari.
2. Ora sei nell'app web App Distribution Tester. Nella pagina visualizzata, accedi con il tuo Account Google e tocca Accetta invito.

3. Ora puoi vedere le release a cui hai ricevuto un invito. Tocca Registra dispositivo in una delle release.

4. Quando richiesto, scarica il profilo Firebase e installalo nell'app Impostazioni.

L'installazione del profilo concede a Firebase l'autorizzazione a:

• Registra il dispositivo di test raccogliendo l'ID dispositivo univoco (UDID).

Firebase invia a tutti i proprietari e gli editor del progetto Firebase un'email che include l'UDID del dispositivo di test.

• Installa un clip web nella schermata Home del dispositivo di test. Il clip web apre l'app web App Distribution Tester, che ti consente di installare e accedere a tutte le tue app di test.

Nell'app web per tester di App Distribution, il dispositivo di test è ora registrato per la release dell'app.

Ora che hai condiviso l'UDID del tuo dispositivo di test con Firebase, puoi riprendere come sviluppatore. Nella scheda Tester della dashboard di App Distribution, le informazioni del tester ora vengono visualizzate sotto la release dell'app con lo stato "Accettato":

Nella sezione successiva, aggiungerai l'UDID del dispositivo al profilo di provisioning dell'app e poi creerai una versione dell'app che funzioni con il dispositivo di test.

Esportare gli UDID dei dispositivi di test

In qualità di sviluppatore, riceverai un'email da Firebase contenente l'UDID del dispositivo di test. Come opzione, la distribuzione di app semplifica la raccolta di più UDID di nuovi dispositivi contemporaneamente consentendoti di esportarli direttamente dalla console Firebase come file di testo non elaborato.

1. Per esportare tutti gli UDID, apri la scheda Tester e gruppi.

2. Fai clic su Esporta UDID Apple.

Il file deve contenere l'UDID del dispositivo di test.

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

Gli UDID possono essere esportati anche dalla riga di comando utilizzando fastlane, come farai nella sezione successiva.

6. Aggiorna il profilo di provisioning dell'app e ricostruiscilo

Ora dovrai aggiungere l'UDID del dispositivo di test al profilo di provisioning dell'app, ricreare una versione dell'app che funzioni per il tuo dispositivo e distribuire la nuova versione.

Aggiungi una corsia di esportazione UDID

1. Aggiungi un'altra variabile nella parte superiore del file Fastfile e impostala sul percorso del file in cui verranno scaricati gli UDID dei dispositivi dei tester.

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

2. Configura una nuova corsia che utilizzi l'azione di esportazione degli UDID del plug-in di distribuzione di app per scaricare gli UDID dei tester, proprio come hai fatto dalla console.

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

3. Esegui il seguente comando per scaricare gli UDID.

$ fastlane download_udids

4. Stampa il file scaricato, che dovrebbe contenere gli UDID del dispositivo di test.

$ cat tester_udids.txt

Aggiungi dispositivi ad Apple Developer Console

1. Crea la seguente corsia per aggiungere gli UDID all'elenco dei dispositivi nella console per sviluppatori Apple, in modo da poterli aggiungere al profilo di provisioning utilizzando l'azione register_devices di fastlane:

lane :add_new_devices do
    register_devices(devices_file: tester_udids_file)
end

2. Quindi, esegui la corsia:

$ fastlane add_new_devices

Dovresti vedere i nuovi dispositivi nell'elenco dei dispositivi della Console per gli sviluppatori.

Aggiungere dispositivi al profilo di provisioning

1. Aggiungi l'argomento force al passaggio del profilo di provisioning nella corsia build per forzarlo a rilevare i nuovi dispositivi ogni volta che esegui la compilazione.

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

Eseguire di nuovo la corsa per compilare e caricare

Ora aggiorna la corsia distribute con le nuove corsie per aggiungere i dispositivi al profilo di provisioning, ricreare l'app e poi distribuirla.

1. Chiama le nuove corsie da 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

2. Esegui la corsia distribute:

$ fastlane distribute

A questo punto, il tuo file Fastfile dovrebbe avere il seguente aspetto:

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

Scaricare la release dal dispositivo di test

Ora che la tua app include gli UDID dei dispositivi di test, questi possono essere installati sui dispositivi di test.

1. Sul dispositivo di test, torna all'app web App Distribution Tester utilizzando il link nell'email o l'icona nella schermata Home del dispositivo.

Quando accedi all'app codelab UDID, puoi vedere che la release è pronta per il download.

2. Se utilizzi un dispositivo fisico, premi Download, quindi installa ed esegui l'app.

7. Complimenti

Ora hai configurato App Distribution e fastlane per automatizzare la procedura di test pre-release. Ora, quando vuoi invitare altri tester o aggiungere i loro UDID alla tua app, devi eseguire un solo comando: fastlane distribute.

Non dovrai più raccogliere singolarmente gli UDID dei tester o accedere all'Apple Developer Console per aggiornare gli elenchi di dispositivi o i profili di provisioning. Non è nemmeno necessario aprire Xcode.

Questo flusso di lavoro è facile da configurare per l'esecuzione ogni ora o ogni giorno nell'ambiente di integrazione continua.

Per approfondire

• Esplora le funzionalità di Firebase App Distribution, incluso il nostro SDK in-app per iOS
• Scopri di più su fastlane
• Gestire la firma del codice del team con match
• Eseguire l'integrazione di fastlane nella tua CI