Distribuye tus compilaciones para iOS previas al lanzamiento más rápido con App Distribution y fastlane

1. Antes de comenzar

4cddd34bd261cea0.png

En este codelab, aprenderás a usar Firebase App Distribution y su complemento fastlane para distribuir una app para iOS a los verificadores, recopilar UDID de dispositivos de prueba y registrarlos en el perfil de aprovisionamiento de tu app, de modo que puedas entregar compilaciones ad hoc a los verificadores con mayor rapidez.

Qué aprenderás

  • Cómo subir y distribuir una app para iOS previa al lanzamiento (ad hoc) a los verificadores con Firebase App Distribution y fastlane
  • Cómo registrarse como verificador y descargar la app distribuida en un dispositivo de prueba
  • Cómo registrar rápidamente dispositivos de prueba exportando los UDID de dispositivos de prueba con el complemento fastlane de App Distribution
  • Cómo actualizar el perfil de aprovisionamiento de tu app y volver a subirlo para su distribución

Requisitos

  • Una Cuenta de Google
  • Una máquina Apple con Xcode 11.7 o una versión posterior instalada
  • Una app para iOS previa al lanzamiento Ad Hoc compilada en Xcode
  • Una cuenta de desarrollador de Apple pagada
  • Un dispositivo iOS físico para realizar pruebas

La app del simulador de iOS funcionará para la mayor parte del codelab, pero los simuladores no pueden descargar versiones.

Aun así, puedes verificar que la configuración funcionó comprobando que el botón "Descargar" aparezca en la aplicación web para verificadores de App Distribution.

2. Comenzar

Configura fastlane

App Distribution se integra en fastlane para permitirte automatizar la distribución de compilaciones previas al lanzamiento de tu app. App Distribution se integra en tu configuración de fastlane.

  1. Instala y configura fastlane.
  2. Ejecuta fastlane init en el directorio raíz de tu proyecto durante la configuración y elige "Configuración manual". Verás un subdirectorio llamado fastlane que contiene Fastfile, Appfile y Pluginfile, que usarás para configurar fastlane.

Instala Firebase CLI

También deberás instalar Firebase CLI. Si usas macOS o Linux, puedes ejecutar el siguiente comando cURL:

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

Si usas Windows, lee las instrucciones de instalación para obtener un archivo binario independiente o instalarlo a través de npm.

Una vez que hayas instalado la CLI, al ejecutar firebase --version, se debería informar una versión de 12.0.0 o posterior:

$ firebase --version
12.0.0

3. Compila tu app con fastlane

Compila tu app

  1. Configura algunas variables globales para fastlane en tu ./fastlane/Appfile.. Incluye el ID de tu app y tu Apple ID:
app_identifier("<your app's bundle identifier>")
apple_id("<your Apple id>")
  1. Crea tu primer carril y usa la acción build_app de fastlane (también conocida como gym) para compilar tu app. Para ello, agrega lo siguiente a tu ./fastlane/Fastfile:
default_platform(:ios)

lane :build do
    build_app(export_method: "ad-hoc")
end
  1. Firma tu app para distribuirla.

En este codelab, administrarás tu propia certificación y perfil con get_certificates (también conocido como cert), que genera certificados de firma de forma local y almacena todo en tu Llavero de macOS. Sin embargo, por lo general, querrás usar fastlane sync_code_signing action (también conocido como match) para administrar de forma segura los certificados y perfiles de firma de código de tu equipo.

lane :build do
    get_certificates()
    build_app(export_method: "ad-hoc")
end
  1. Configura un perfil de aprovisionamiento para tu app con la acción get_provisioning_profile (también conocida como sigh). Esto te permite compartir tu app con los verificadores.
lane :build do
    get_certificates()
    get_provisioning_profile(adhoc: true)
    build_app(export_method: "ad-hoc")
end
  1. [Opcional] Si nunca ejecutaste tu app, ejecuta el siguiente comando para crearla en la consola para desarrolladores de Apple:

$ fastlane produce --skip_itc

  1. Por último, ejecuta el carril para compilar tu app.

Se te solicitarán tu ID de Apple, tu contraseña (que se almacena en tu Llavero) y el ID del paquete de tu app.

$ fastlane build

Si tienes algún problema, consulta la guía de solución de problemas de fastlane.

4. Sube tu app a Firebase

Ahora que compilaste tu app, puedes subirla a App Distribution.

Crea y configura un proyecto de Firebase

  1. Accede a Firebase.
  2. En Firebase console, crea o agrega un proyecto nuevo y, luego, asígnale el nombre "UDID Export Codelab".

No es necesario que habilites Google Analytics en este proyecto.

  1. Haz clic en Crear proyecto.

Agrega tu app para iOS al proyecto

  1. Haz clic en el ícono de iOS para crear una nueva app para iOS de Firebase y, luego, ingresa el ID del paquete de tu app.

9c26c130a6c42212.png

  1. Omite los siguientes pasos y, luego, haz clic en Ir a la consola. Agregarás los SDKs a tu app más adelante.

Tu proyecto y tu app ahora están disponibles en la página Project Overview.

66f79cc8a97fa8e9.png

Habilita App Distribution

  1. En la sección Release & Monitor, haz clic en Distribución de la app.
  2. Después de aceptar las condiciones, haz clic en “Comenzar” para habilitar App Distribution en tu app.

460213326c2784ae.png

Configura una distribución en fastlane

  1. Ejecuta el siguiente comando desde la raíz de tu proyecto de iOS para agregar App Distribution a tu configuración de fastlane.

Si el comando te muestra una opción, selecciona Option 3: RubyGems.org:

$ fastlane add_plugin firebase_app_distribution

  1. Confirma que el complemento esté instalado:

$ fastlane

El resultado debería mostrar fastlane-plugin-firebase_app_distribution en la lista de complementos instalados.

  1. Después de confirmar que el complemento está instalado, elige la opción 0 para cancelar.

Autentica tu proyecto de Firebase

Para usar el complemento de fastlane, primero debes autenticar tu proyecto de Firebase.

  1. Ejecuta el siguiente comando para conectar la CLI a tu Cuenta de Google:

$ firebase login

  1. Cuando el comando imprima un vínculo de autenticación, ábrelo en un navegador.
  2. Cuando se te solicite, accede a tu Cuenta de Google y otorga permiso para acceder a tu proyecto de Firebase.

Distribuye tu app

Ahora puedes distribuir tu app.

  1. En la parte superior de tu ./fastlane/Fastfile, define una variable llamada firebase_app_id. Reemplaza <your_app_id> por el ID de la app de Firebase de la app que creaste (puedes encontrarlo en la página de configuración del proyecto).

El Fastfile está escrito en Ruby, por lo que debes usar la sintaxis de Ruby para definir variables.

firebase_app_id = "<your_app_id>"
  1. Agrega un carril nuevo llamado distribute que llame al carril de compilación y, luego, distribuye tu app con la acción firebase_app_distribution.
lane :distribute do
    build
    firebase_app_distribution(
        app: firebase_app_id,
        release_notes: "Try out this app!",
    )
end
  1. Ejecuta el nuevo carril para compilar tu app y crear una distribución.

$ fastlane distribute

En este punto, tu Fastfile debería verse de la siguiente manera:

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

Después de actualizar Firebase console, verás la versión nueva de tu app.

c59dc1a94de3bf3c.png

5. Invita a verificadores a descargar tu app

Cuando un verificador acepta una invitación para probar una compilación ad hoc, se le solicita permiso para compartir su UDID. Si acepta, App Distribution recopila la información de su dispositivo y te notifica por correo electrónico. En esta sección, te agregarás como verificador para descargar y probar la app que distribuiste.

Agrega tu cuenta como verificador de la versión

  1. En firebase_app_id, en la parte superior de tu Fastfile, crea una variable para almacenar verificadores y, luego, incluye tu propia dirección de correo electrónico, así como otras direcciones de correo electrónico opcionales que quieras probar.
firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "your@email.com",
  "another@email.com",
]
  1. Aplica el método Array#join de Ruby para convertir el array app_testers en una cadena separada por comas, que es lo que espera el parámetro testers. Luego, pasa el resultado al parámetro testers de 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

En este punto, tu Fastfile debería verse así:

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. Vuelve a ejecutar el carril.

$ fastlane distribute

Una vez que ejecutes el carril, los verificadores que agregaste recibirán un correo electrónico de invitación de App Distribution en el que se les notificará sobre la versión recién disponible. En Firebase console, ahora puedes ver los verificadores que agregaste en la versión de tu app.

2e0fc9603b868af8.png

Como incluiste tu dirección de correo electrónico, recibirás un correo electrónico de Firebase App Distribution en el que se te invitará a probar la app. Ahora eres el primer verificador. Continúa con la siguiente sección para prepararte como verificador en tu dispositivo de prueba.

Registra tu dispositivo de prueba

Como verificador, deberás acceder a Google en tu dispositivo de prueba para acceder a las versiones de la app que se te invitó a probar. Como tu compilación de prueba es una versión ad hoc, también deberás registrar tu dispositivo de prueba instalando el perfil de Firebase. Luego, puedes acceder a las versiones que estén disponibles para ti desde la aplicación web de verificadores de App Distribution, con el clip web que se agrega a la pantalla principal de tu dispositivo.

  1. En tu dispositivo de prueba para iOS, abre el correo electrónico que te envió Firebase App Distribution y presiona el vínculo Comenzar. Asegúrate de abrir el vínculo en Safari.
  2. Ahora estás en la app web para verificadores de App Distribution. En la página que aparece, accede con tu Cuenta de Google y presiona Aceptar invitación.

d833407de251b89f.png

  1. Ahora puedes ver las versiones a las que te invitaron. Presiona Register device en una de las versiones.

fd141215e54a938d.png

  1. Cuando se te solicite, descarga el perfil de Firebase y, luego, instálalo en la app de Configuración.

Cuando se instala el perfil, se otorgan a Firebase los siguientes permisos:

  • Registrar el dispositivo de prueba recopilando su ID de dispositivo único (UDID).

Firebase envía un correo electrónico a todos los propietarios y editores del proyecto de Firebase que incluye el UDID del dispositivo de prueba.

  • Instalar un clip web en la pantalla principal del dispositivo de prueba El clip web abre la app web de verificadores de App Distribution, que te permite instalar y acceder a todas tus apps de prueba.

En la app web para verificadores de App Distribution, tu dispositivo de prueba ahora está registrado para la versión de tu app.

fe93d649dfa25877.png

Ahora que compartiste el UDID de tu dispositivo de prueba con Firebase, puedes continuar como desarrollador. En la pestaña Verificadores del panel de App Distribution, la información del verificador ahora aparece en la versión de tu app con el estado "Aceptado":

7b9f665a63a384cf.png

En la siguiente sección, agregarás el UDID del dispositivo al perfil de aprovisionamiento de tu app y, luego, compilarás una versión de tu app que funcione con tu dispositivo de prueba.

Exporta los UDID de tus dispositivos verificadores

Como desarrollador, recibirás un correo electrónico de Firebase que contendrá el UDID del dispositivo de prueba. Como opción, App Distribution facilita la recopilación de varios UDID de dispositivos nuevos a la vez, ya que te permite exportarlos directamente desde Firebase console como un archivo de texto sin formato.

  1. Para exportar todos los UDID, abre la pestaña Verificadores y grupos.

241a9936898a2fc0.png

  1. Haz clic en Exportar UDIDs de Apple.

bcf0c26c522d9b4e.png

El archivo debe contener el UDID de tu dispositivo de prueba.

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

Los UDID también se pueden exportar desde la línea de comandos con fastlane, lo que harás en la próxima sección.

6. Actualiza el perfil de aprovisionamiento de tu app y vuelve a compilarla

Ahora, agregarás el UDID de tu dispositivo de prueba al perfil de aprovisionamiento de tu app, volverás a compilar una versión de tu app que funcione en tu dispositivo y distribuirás la nueva versión.

Agrega el carril lane de exportación de UDID

  1. Agrega otra variable en la parte superior de tu Fastfile y configúrala en una ruta de acceso al archivo en la que se descargarán los UDID de los dispositivos de tus verificadores.
firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "your@email.com",
  "another@email.com",
]
tester_udids_file = "tester_udids.txt"
  1. Configura un nuevo carril que use la acción de exportación de UDID del complemento de App Distribution para descargar los UDID de los verificadores, tal como lo hiciste desde la consola.
lane :download_udids do
    firebase_app_distribution_get_udids(
        app: firebase_app_id,
        output_file: tester_udids_file,
    )
end
  1. Ejecuta el siguiente carril para descargar los UDID.

$ fastlane download_udids

  1. Imprime el archivo descargado, que debería contener los UDID del dispositivo de prueba.

$ cat tester_udids.txt

Cómo agregar dispositivos a Apple Developer Console

  1. Crea el siguiente carril para agregar los UDID a la lista de dispositivos en la consola de desarrolladores de Apple, de modo que puedas agregarlos a tu perfil de aprovisionamiento con la acción register_devices de fastlane :
lane :add_new_devices do
    register_devices(devices_file: tester_udids_file)
end
  1. Luego, ejecuta el carril:

$ fastlane add_new_devices

Luego, deberías ver los dispositivos nuevos en la lista de dispositivos de la consola para desarrolladores.

Agrega dispositivos a tu perfil de aprovisionamiento

  1. Agrega el argumento force al paso del perfil de aprovisionamiento en tu carril build para obligarlo a seleccionar dispositivos nuevos cada vez que compiles.
lane :build do
    get_certificates()
    get_provisioning_profile(adhoc: true, force: true)
    build_app(export_method: "ad-hoc")
end

Vuelve a ejecutar el carril para compilar y subir

Ahora, actualizarás tu carril distribute con los carriles nuevos para agregar los dispositivos al perfil de aprovisionamiento, volver a compilar la app y, luego, distribuirla.

  1. Llama a los nuevos carriles desde 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. Ejecuta el carril distribute:

$ fastlane distribute

En este punto, tu Fastfile debería verse así:

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

Descarga la versión del dispositivo de prueba

Ahora que tu app incluye los UDID de los dispositivos de prueba, se pueden instalar en ellos.

e275f73d57cc8fb1.png

  1. En el dispositivo de prueba, regresa a la app web de verificadores de App Distribution con el vínculo del correo electrónico o el ícono de la pantalla principal del dispositivo.

Cuando navegues a la app del codelab del UDID, verás que la versión está lista para descargarse.

dad6d03b6ad78746.png

  1. Si usas un dispositivo físico, presiona Descargar y, luego, instala y ejecuta la app.

7. Felicitaciones

Ya configuraste App Distribution y fastlane para automatizar el proceso de pruebas previas al lanzamiento. Ahora, cuando quieras invitar a verificadores adicionales o agregar sus UDID a tu app, solo deberás ejecutar un comando: fastlane distribute.

Por lo tanto, ya no es necesario recopilar los UDID de los verificadores de forma individual ni ir a la consola de Apple Developer para actualizar las listas de dispositivos o los perfiles de aprovisionamiento. Ni siquiera necesitas abrir Xcode.

Este flujo de trabajo es fácil de configurar para que se ejecute cada hora o cada día en tu entorno de integración continua.

Lecturas adicionales