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

1. Prima di iniziare

In questo codelab imparerai come utilizzare Firebase App Distribution e il relativo plug- in fastlane per distribuire un'app iOS ai tester, raccogliere gli UDID del dispositivo 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 prova.
• 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 della tua 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 i 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

Imposta la corsia veloce

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 tua configurazione fastlane .

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

Installa la CLI di Firebase

Dovrai inoltre installare la CLI 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 installarlo tramite npm .

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

$ firebase --version
12.0.0

3. Costruisci la tua app con Fastlane

Crea la tua app

1. Imposta alcune variabili globali per fastlane nel tuo ./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 al tuo ./fastlane/Fastfile :

default_platform(:ios)

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

3. 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 certificati di firma localmente e memorizza 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

4. Configura un profilo di provisioning per la tua app utilizzando 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

5. [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

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

Ti verrà richiesto l'ID Apple, la password (che è memorizzata nel portachiavi) e l'ID del bundle della tua app.

$ fastlane build

In caso di problemi, consultare la guida alla risoluzione dei problemi 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 chiama il progetto "UDID Export Codelab".

Non è necessario abilitare Google Analytics per questo progetto.

3. 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.

2. Salta i passaggi successivi, quindi fai clic su Continua sulla 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 .

Abilita la distribuzione delle app

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

Imposta una distribuzione in fastlane

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

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

$ fastlane add_plugin firebase_app_distribution

2. Conferma che il plugin sia installato:

$ fastlane

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

3. Dopo aver confermato che il plugin è installato, 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 comando seguente per connettere la CLI al tuo account Google:

$ firebase login

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

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 (è disponibile nella pagina delle impostazioni del progetto ).

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

firebase_app_id = "<your_app_id>"

2. Aggiungi una nuova corsia chiamata distribute che richiama 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

3. Esegui la nuova corsia per creare la tua app e creare una distribuzione.

$ fastlane distribute

A questo punto il tuo Fastfile dovrebbe assomigliare 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 della tua app.

5. Invita 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 sono d'accordo, App Distribution raccoglie le informazioni sul loro dispositivo e ti invia una notifica 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 trattenere i tester e includi il tuo indirizzo email, così come altri indirizzi email opzionali che desideri provare.

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "[e-mail]",
  "[e-mail]",
]

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 Fastfile dovrebbe assomigliare a questo:

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "[e-mail]",
  "[e-mail]",
]

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. Percorri di nuovo la corsia.

$ fastlane distribute

Una volta eseguita la corsia, i tester aggiunti 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 nella versione 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 la sezione seguente per configurarti come tester sul tuo dispositivo di prova.

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 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 App Distribution, 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 collegamento Inizia . Assicurati di aprire il collegamento in Safari.
2. Ora ti trovi nell'app Web del tester di distribuzione app. Nella pagina visualizzata, accedi con il tuo account Google e tocca Accetta invito.

3. Ora puoi vedere le versioni a cui sei stato invitato. Tocca Registra dispositivo sotto una delle versioni.

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

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

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

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

• Installa una clip web sulla schermata iniziale del dispositivo di prova. Il clip Web apre l'app Web del tester App Distribution, che ti consente di installare e accedere a tutte le tue app di test.

Nell'app Web del tester App Distribution, il tuo dispositivo di test è ora registrato per la versione dell'app.

Nota: se hai già aggiunto questo dispositivo al tuo account sviluppatore in passato, potrebbe essere già stato incluso nel profilo di provisioning e qui vedrai già un pulsante "Download".

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

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 test.

Esporta gli UDID del dispositivo tester

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 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 dovrebbe contenere l'UDID del tuo dispositivo di prova.

Device ID            Device Name                            Device Platform
1234567890     [e-mail] - iPhone SE 2nd Gen        ios

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

6. Aggiorna il profilo di provisioning della tua 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 file in cui verranno scaricati gli UDID dei dispositivi dei tuoi tester.

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "[e-mail]",
  "[e-mail]",
]
tester_udids_file = "tester_udids.txt"

2. Configura una nuova corsia che utilizza 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

3. Eseguire la corsia seguente per scaricare gli UDID.

$ fastlane download_udids

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

$ cat tester_udids.txt

Aggiungi dispositivi alla console per sviluppatori Apple

1. Crea la seguente corsia per aggiungere gli UDID all'elenco dei tuoi 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

2. Quindi, percorri 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 corsia 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 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

2. Esegui la corsia distribute :

$ fastlane distribute

A questo punto il tuo Fastfile dovrebbe assomigliare a questo:

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "[e-mail]",
  "[e-mail]",
]
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 dei dispositivi di test, è possibile installarli sui dispositivi di test.

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

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

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

Nota: i download delle versioni funzionano solo su dispositivi fisici. Se utilizzi un simulatore, il download non funzionerà, ma puoi comunque verificare che la configurazione abbia funzionato verificando che il pulsante "Download" sia visualizzato nell'app Web del tester App Distribution.

7. Congratulazioni

Ora hai configurato App Distribution e fastlane per automatizzare il processo di test pre-rilascio. Ora, quando desideri invitare altri tester o aggiungere i loro UDID alla tua app, dovrai eseguire solo un comando: fastlane distribute .

Quindi non è più necessario raccogliere individualmente gli UDID 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

• Esplora le funzionalità di Firebase App Distribution , incluso il nostro SDK in-app per iOS
• Scopri di più sulla corsia veloce
• Gestisci la firma del codice del tuo team con match
• Integra Fastlane nel tuo CI