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

1. Prima di iniziare

4cddd34bd261cea0.png

In questo codelab imparerai come utilizzare Firebase App Distribution e il suo plug-in fastlane per distribuire un'app iOS ai tester, raccogliere gli UDID dei dispositivi di test e registrarli nel profilo di provisioning della tua app, in modo da poter ottenere rapidamente build Ad Hoc nei tester ' mani.

Cosa imparerai

  • Come caricare e distribuire un'app iOS 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 esportando gli UDID dei dispositivi di test con il plug-in fastlane di App Distribution.
  • Come aggiornare il profilo di provisioning dell'app e ricaricarlo per la distribuzione.

Di cosa avrai bisogno

  • Un account Google
  • Una macchina Apple con XCode 11.7+ installato
  • Un'app iOS pre-release ad hoc integrata in Xcode
  • Un account sviluppatore Apple a pagamento
  • Un dispositivo iOS fisico per il test.

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

Puoi comunque verificare che la configurazione abbia funzionato verificando che il pulsante "Download" venga visualizzato nell'app Web del tester di distribuzione app.

2. Inizia

Prepara la corsia preferenziale

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

  1. Installa e configura Fastlane .
  2. Esegui fastlane init nella directory principale del tuo progetto durante l'installazione e scegli "Installazione manuale". Vedrai una sottodirectory chiamata fastlane che contiene Fastfile , Appfile e Pluginfile , che utilizzerai per configurare fastlane .

3. Crea la tua app con Fastlane

Crea la tua app

  1. Imposta alcune variabili globali per Fastlane nel tuo ./fastlane/Appfile ./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>")
  1. Crea la tua prima corsia e usa l'azione build_app di fastlane (nota anche come gym ) per creare la tua app aggiungendo quanto segue al tuo ./fastlane/Fastfile :
default_platform(:ios)

lane :build do
    build_app(export_method: "ad-hoc")
end
  1. Firma la tua app per la distribuzione.

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

lane :build do
    get_certificates()
    build_app(export_method: "ad-hoc")
end
  1. Configura un profilo di provisioning per la tua app usando l'azione get_provisioning_profile (nota anche come sigh ). Ciò ti consente di condividere la tua app con i tester.
lane :build do
    get_certificates()
    get_provisioning_profile(adhoc: true)
    build_app(export_method: "ad-hoc")
end
  1. [Facoltativo] Se non hai mai eseguito la tua app prima, esegui il comando seguente per creare la tua app nella console per sviluppatori Apple:

$ fastlane produce --skip_itc

  1. Infine, crea la tua app eseguendo la corsia.

Ti verrà chiesto di inserire il tuo ID Apple, la password (che è memorizzata nel tuo portachiavi) e l'ID bundle della tua app.

$ fastlane build

In caso di problemi, consultare la guida alla risoluzione dei problemi di Fastlane .

4. Carica la tua app su Firebase

Ora che hai creato la tua app, sei pronto per caricarla su App Distribution.

Crea e configura un progetto Firebase

  1. Accedi a Firebase.
  2. Nella console Firebase, crea o aggiungi un nuovo progetto, quindi denomina il tuo progetto "UDID Export Codelab".

Non è necessario abilitare Google Analytics per questo progetto.

  1. Fare clic su Crea progetto .

Aggiungi la tua app iOS al progetto

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

9c26c130a6c42212.png

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

Il tuo progetto e la tua app sono ora disponibili nella pagina Panoramica del progetto .

66f79cc8a97fa8e9.png

Abilita distribuzione app

  1. Nella sezione Rilascio e monitoraggio, fai clic su Distribuzione app .
  2. Dopo aver accettato i termini, fai clic su "Inizia" per abilitare la distribuzione dell'app per la tua app.

460213326c2784ae.png

Imposta una distribuzione in corsia preferenziale

  1. Esegui il comando seguente dalla radice del tuo progetto iOS per aggiungere App Distribution alla tua configurazione Fastlane .

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

$ fastlane add_plugin firebase_app_distribution

  1. Conferma che il plugin è installato:

$ fastlane

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

  1. Dopo aver confermato l'installazione del plug-in, scegli l'opzione 0 per annullare.

Autentica il tuo progetto Firebase

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

  1. Esegui il seguente comando:

$ fastlane run firebase_app_distribution_login

  1. Quando il comando stampa un collegamento di autenticazione, aprire il collegamento in un browser.
  2. Quando richiesto, accedi al tuo account Google e concedi l'autorizzazione per accedere al tuo progetto Firebase.

Copia il codice risultante dal browser di accesso e incollalo nella riga di comando.

  1. L'azione di accesso stampa quindi un token di aggiornamento, che il plug-in App Distribution utilizza per autenticarsi con Firebase:

dbd61c40c4131158.png

  1. Passa il token impostando la variabile di ambiente FIREBASE_TOKEN :

$ export FIREBASE_TOKEN= <token>

Distribuisci la tua app

Ora sei pronto per distribuire la tua app.

  1. Nella parte superiore del tuo ./fastlane/Fastfile , definisci una variabile chiamata firebase_app_id . Sostituisci <your_app_id> con l'ID app Firebase per l'app che hai creato (può essere trovato nella pagina delle impostazioni del progetto ).

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

firebase_app_id = "<your_app_id>"
  1. Aggiungi una nuova corsia denominata distribute che chiama la corsia di compilazione, quindi distribuisce la tua 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
  1. Esegui la nuova corsia per creare la tua app e creare una distribuzione.

$ fastlane distribute

A questo punto, il tuo Fastfile dovrebbe essere simile al seguente:

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 versione per la tua app.

c59dc1a94de3bf3c.png

5. Invita i tester a scaricare la tua app

Quando un tester accetta un invito a testare una build ad hoc, gli viene chiesto il permesso di condividere il proprio UDID. Se accettano, App Distribution raccoglie le informazioni sul dispositivo e ti avvisa via e-mail. In questa sezione ti aggiungerai come tester per scaricare e testare l'app che hai distribuito.

Aggiungi te stesso come tester alla versione

  1. Sotto firebase_app_id nella parte superiore del tuo Fastfile, crea una variabile per contenere i tester e includi il tuo indirizzo email, così come altri indirizzi email opzionali che vorresti provare.
firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "your@email.com",
  "another@email.com",
]
  1. 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 Fastfile dovrebbe assomigliare a questo:

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. Corri di nuovo in corsia.

$ fastlane distribute

Una volta eseguita la corsia, i tester che hai aggiunto riceveranno un'e-mail di invito da App Distribution che li informa della nuova versione disponibile. Nella console Firebase, ora puoi vedere i tester che hai aggiunto durante il rilascio della tua app.

2e0fc9603b868af8.png

Poiché hai incluso il tuo indirizzo e-mail, riceverai un'e-mail da Firebase App Distribution che ti invita a testare l'app. Ora sei il primo tester! Continua la sezione seguente per impostare come tester sul tuo dispositivo di test.

Registra il tuo dispositivo di prova

In qualità di tester, dovrai accedere a Google sul tuo dispositivo di prova per accedere alle versioni dell'app che sei stato invitato a testare. Poiché la tua build di test è una versione Ad Hoc, dovrai registrare anche il tuo dispositivo di test installando il profilo Firebase. Successivamente, è possibile accedere alle versioni che diventano disponibili dall'app Web del tester di distribuzione app, utilizzando il clip Web aggiunto alla schermata iniziale del dispositivo.

  1. Sul tuo dispositivo di prova iOS, apri l'e-mail inviata da Firebase App Distribution e tocca il link Inizia . Assicurati di aprire il collegamento in Safari.
  2. Ora sei nell'app Web del tester di distribuzione app. Nella pagina visualizzata, accedi con il tuo account Google e tocca Accetta invito.

d833407de251b89f.png

  1. Ora puoi vedere le pubblicazioni a cui sei stato invitato. Tocca Registra dispositivo in una delle versioni.

fd141215e54a938d.png

  1. Quando richiesto, scarica il profilo Firebase, quindi installa il profilo nell'app Impostazioni.

L'installazione del profilo autorizza Firebase a:

  • Registrare il dispositivo di prova raccogliendo l'ID dispositivo univoco (UDID) del dispositivo.

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

  • Installa una clip web nella schermata iniziale del dispositivo di prova. La clip Web apre l'app Web del tester di distribuzione app, che consente di installare e accedere a tutte le app di test.

Nell'app Web del tester di distribuzione dell'app, il tuo dispositivo di prova è ora registrato per il rilascio dell'app.

fe93d649dfa25877.png

Ora che hai condiviso l'UDID del tuo dispositivo di prova su Firebase, puoi riprendere come sviluppatore. Nella scheda Tester della dashboard Distribuzione app , le informazioni sul tester ora vengono visualizzate nella versione dell'app con lo stato "Accettato":

7b9f665a63a384cf.png

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

Esporta gli UDID del tuo dispositivo di test

In qualità di sviluppatore, riceverai un'e-mail da Firebase contenente l'UDID del dispositivo di prova. Come opzione, App Distribution semplifica la raccolta di più UDID di nuovi dispositivi contemporaneamente consentendo di esportarli direttamente dalla console Firebase come file di testo non elaborato.

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

241a9936898a2fc0.png

  1. Fai clic su Esporta UDID Apple .

bcf0c26c522d9b4e.png

Il file dovrebbe 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 anche essere esportati dalla riga di comando utilizzando fastlane , cosa che farai nella prossima sezione.

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

Ora aggiungerai l'UDID del tuo dispositivo di prova al profilo di provisioning della tua app, ricostruirai una versione della tua app che funzioni per il tuo dispositivo e distribuirai la nuova versione.

Aggiungi la corsia di esportazione UDID

  1. Aggiungi un'altra variabile nella parte superiore del tuo Fastfile e impostala su un percorso di file in cui verranno scaricati gli UDID del dispositivo dei tester.
firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "your@email.com",
  "another@email.com",
]
tester_udids_file = "tester_udids.txt"
  1. Configura una nuova corsia che utilizzi l'azione di esportazione UDID del plug-in App Distribution per scaricare gli UDID del 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
  1. Esegui la corsia seguente per scaricare gli UDID.

$ fastlane download_udids

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

$ cat tester_udids.txt

Aggiungi dispositivi alla console per sviluppatori Apple

  1. Crea la corsia seguente per aggiungere gli UDID all'elenco dei dispositivi nella console per sviluppatori Apple, in modo da poterli aggiungere al tuo profilo di provisioning utilizzando l'azione register_devices di fastlane :
lane :add_new_devices do
    register_devices(devices_file: tester_udids_file)
end
  1. Quindi, corri la corsia:

$ fastlane add_new_devices

Dovresti quindi vedere i nuovi dispositivi nell'elenco dei dispositivi della tua console per sviluppatori .

Aggiungi dispositivi al tuo profilo di provisioning

  1. Aggiungi l'argomento force al passaggio del profilo di provisioning nella tua corsia di build , per forzarlo a raccogliere nuovi dispositivi ogni volta che crei.
lane :build do
    get_certificates()
    get_provisioning_profile(adhoc: true, force: true)
    build_app(export_method: "ad-hoc")
end

Riesegui la corsia per creare e caricare

Ora aggiornerai la tua corsia di distribute con le nuove corsie per aggiungere i dispositivi al profilo di provisioning, ricostruire l'app e quindi 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
  1. Esegui la corsia di distribute :

$ fastlane distribute

A questo punto, il tuo Fastfile dovrebbe assomigliare a questo:

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

Scarica la versione dal dispositivo di prova

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

e275f73d57cc8fb1.png

  1. Sul dispositivo di prova, torna all'app Web del tester di distribuzione app utilizzando il collegamento nell'e-mail o l'icona nella schermata iniziale del dispositivo.

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

dad6d03b6ad78746.png

  1. Se sei su un dispositivo fisico, premi download, quindi installa ed esegui l'app!

7. Congratulazioni

Ora hai configurato la distribuzione delle app e la corsia preferenziale per automatizzare il processo di test pre-rilascio. Ora, quando vuoi invitare altri tester o aggiungere i loro UDID alla tua app, devi eseguire solo un comando: fastlane distribute .

Quindi non dovrai più raccogliere UDID individualmente dai tester o accedere alla console per sviluppatori Apple per aggiornare elenchi di dispositivi o profili di provisioning. Non hai nemmeno bisogno di aprire XCode!

Questo flusso di lavoro è facile da configurare per l'esecuzione oraria o giornaliera nel tuo ambiente di integrazione continua.

Ulteriori letture