Questa pagina è stata tradotta dall'API Cloud Translation.

Distribuisci le 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 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 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 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 di 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 App Distribution.

2. Inizia

Imposta la corsia preferenziale

App Distribution si integra con fastlane per consentirti di automatizzare la distribuzione delle versioni preliminari della tua app. App Distribution si integra con la tua configurazione fastlane .

Installa e configura fastlane .
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 .

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 l'installazione tramite npm .

Una volta installata la CLI, l'esecuzione firebase --version dovrebbe riportare una versione 12.0.0 o successiva:

$ firebase --version
12.0.0

3. Crea la tua app con fastlane

Crea la tua app

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>")

Crea la tua prima corsia e usa l'azione build_app di fastlane (nota anche come gym ) per costruire la tua app aggiungendo quanto segue al tuo ./fastlane/Fastfile :

default_platform(:ios)

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

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

Imposta 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

[Facoltativo] Se non hai mai eseguito la tua app prima, esegui il seguente comando per creare la tua app nella console per sviluppatori Apple:

$ fastlane produce --skip_itc

Infine, crea la tua app eseguendo la corsia.

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

$ fastlane build

Se riscontri problemi, consulta 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

Accedi a Firebase.
Nella console Firebase, crea o aggiungi un nuovo progetto, quindi assegna al progetto il nome "UDID Export Codelab".

Non è necessario abilitare Google Analytics per questo progetto.

Fai clic su Crea progetto .

Aggiungi la tua app iOS al progetto

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

Saltare i passaggi successivi, quindi fare clic su Continua alla console . Successivamente aggiungerai gli SDK alla tua app.

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

Abilita la distribuzione delle app

Nella sezione Rilascio e monitoraggio, fai clic su Distribuzione app .
Dopo aver accettato i termini, fai clic su "Inizia" per abilitare App Distribution per la tua app.

Imposta una distribuzione in fastlane

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

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

$ fastlane add_plugin firebase_app_distribution

Conferma che il plug-in è installato:

$ fastlane

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

Dopo aver confermato che il plug-in è 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.

Esegui il seguente comando per connettere la CLI al tuo account Google:

$ firebase login

Quando il comando stampa un collegamento di autenticazione, aprire il collegamento in un browser.
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.

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 di Ruby per definire le variabili.

firebase_app_id = "<your_app_id>"

Aggiungi una nuova corsia chiamata distribute che chiama la corsia di compilazione, quindi distribuisce la tua app utilizzando l'operazione firebase_app_distribution .

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

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.

5. Invita i tester a scaricare la tua app

Quando un tester accetta un invito a testare una build ad hoc, gli viene richiesta l'autorizzazione a condividere il proprio UDID. Se sono d'accordo, App Distribution raccoglie le informazioni sul loro 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

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 facoltativi che vorresti provare.

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

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

Percorri di nuovo la 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 di 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 con la sezione seguente per configurare 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 anche registrare il dispositivo di test installando il profilo Firebase. Successivamente, è possibile accedere alle versioni che diventano disponibili dall'app Web del tester di App Distribution, utilizzando il clip Web aggiunto alla schermata iniziale del dispositivo.

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.
Ora sei nell'app Web del tester di App Distribution. Nella pagina visualizzata, accedi con il tuo account Google e tocca Accetta invito.

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

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

L'installazione del profilo autorizza Firebase a:

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

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

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

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

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

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

Esporta gli UDID del dispositivo del tester

In qualità di sviluppatore, riceverai un'email 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.

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

Fai clic su Esporta UDID Apple .

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

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 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 corsia di esportazione UDID

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 tuoi tester.

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

Imposta 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

Eseguire la corsia seguente per scaricare gli UDID.

$ fastlane download_udids

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

$ cat tester_udids.txt

Aggiunta di dispositivi alla console per sviluppatori Apple

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

Quindi, esegui 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

Aggiungi l'argomento force al passaggio del profilo di provisioning nella tua 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 costruire e caricare

Ora aggiornerai la corsia distribute con le nuove corsie per aggiungere i dispositivi al profilo di provisioning, ricostruire l'app e quindi distribuirla.

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

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 = [
  "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, questi possono essere installati sui dispositivi di test.

Sul dispositivo di prova, torna all'app Web del tester di 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.

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

7. Congratulazioni

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

Quindi non è più necessario raccogliere individualmente 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 essere eseguito su base 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ù su fastlane
Gestisci la firma del codice del tuo team con match
Integra fastlane nel tuo CI