Fastlane: Automatización de iOS en Cruise Control

Post escrito orignalmente por Francisco Reynolds en Toptal

Hacer software para iOS es más que escribir código Objective-C o Swift: implica conocer cómo funciona UIKit, cómo se hacen los certificados, cómo publicar su aplicación en la tienda, cómo lidiar con las revisiones de las aplicaciones y más. Si te parece agotadora esta eterna lista de tareas, algo de automatización en su flujo de trabajo es exactamente lo que necesita.

Conoce Fastlane, la herramienta diseñada para ahorrarte minutos o incluso horas en cada implementación.

Fastlane te ayuda a automatizar el proceso de envío de compilaciones beta a Crashlytics, TestFlight, App Store y mucho más.

En este artículo, aprenderás cómo puede usar Fastlane para automatizar el flujo de trabajo de implementación de su aplicación iOS. Aunque nos centraremos en el aspecto de iOS de esta herramienta, Fastlane funciona igual de bien para la automatización del desarrollo de Android.

Primeros pasos con Fastlane

Hay varios métodos de instalación entre los que puedes elegir, según lo que encuentres más fácil. Si tienes Homebrew instalado y configurado, la instalación de Fastlane solo requiere un comando:

brew cask install fastlane

De lo contrario, Fastlane es una herramienta basada en Ruby, gem es siempre una opción:

sudo gem install fastlane -NV

O bien, siempre puedes descargar Fastlane del sitio web oficial.

Una vez que hayas instalado Fastlane, ejecuta fastlane init en tu directorio de proyectos y sigue las instrucciones.

Automatización de implementación

Con Fastlane instalado, ahora puedes escribir scripts de Ruby para indicar paso a paso lo que necesita hacer para obtener su implementación donde la desees. Esto se hace usando acciones, herramientas y carriles.

Fastlane Herramientas, acciones y complementos

Fastlane funciona teniendo herramientas en su núcleo que lo ayudan a construir tu aplicación. Además de las herramientas de compilación, existen más de 170 integraciones integradas con servicios como Crashlytics, HockeyApp, TestFlight y más complementos que terceros hacen y publican para que pueda conectarse a otros servicios y más.

En esencia, obtienes las principales herramientas que te permiten realizar una variedad de tareas: desde tomar capturas de pantalla automáticas hasta enmarcarlas y cargarlas en la tienda, te permiten ejecutar todas sus pruebas automáticamente antes de crear la aplicación.

Acciones son las herramientas principales que tiene Fastlane, y los complementos son una forma de agregar acciones de terceros a su configuración de Fastlane.

Carriles

Fastlane utiliza carriles que básicamente agrupan una lista de acciones o complementos secuencialmente para que pueda obtener el mismo resultado cada vez.

Al ejecutar un carril, cada acción exportará una variable de entorno, y las siguientes acciones obtendrán automáticamente estas variables para mantener el proceso en marcha. Por ejemplo, el uso de la acción gym dará como resultado la ruta del archivo .ipa que se está generando, y el uso de crashlytics accederá a esta ubicación .ipa para cargar este archivo en su sistema de distribución de servicio beta.

Usando Fastlane con iOS

Estás comenzando con un nuevo cliente de Toptal que quiere una aplicación muy simple. El diseño ya está hecho y la aplicación se puede codificar en unas pocas semanas. El siguiente paso es comenzar a codificarlo, y durante el proceso de iteración, enviarás una aplicación beta cada dos semanas al cliente para que puedan ver su progreso y darte feeedback sobre cómo funcionan las cosas.

Cada vez que envíes una versión beta al cliente, tendrás que ir a través de una lista de comprobación básica: firmar la aplicación, cargarla en un servicio beta, agregarle una nueva versión, etc. Agregar a esto las cosas que tiene que hacer una vez (cada año): firma de certificados, firma de certificados de notificación de inserción (si es necesario) y más.

¡Con Fastlane, todo esto ahora puede suceder automáticamente!

Enviando a Crashlytics Beta

Por ejemplo, necesitas crear certificados de firma y perfiles de aprovisionamiento para compartir tu aplicación a través de Crashlytics Beta.

Fastlane tiene una acción llamada match que, una vez que la configura, hace lo siguiente:

1. Crea certificados de firma de distribución.
2. Crea un perfil de aprovisionamiento ad-hoc (adjunto al certificado del n. ° 1).
3. Guarda el certificado y el perfil de # 1 y # 2 en un repositorio de Git, encriptado usando OpenSSL.

La configuración es simple.

Primero, ejecuta fastlane match init para comenzar y, una vez que configura tu repositorio de Git, simplemente llama a fastlane match adhoc para obtener un perfil de provisión ad-hoc o ejecuta fastlane match appstore para obtener un certificado de App Store.

Las ventajas de usar match son que puedes sincronizar los certificados muy fácilmente entre computadoras — y entre compañeros de equipo — sin tener que revocar más los certificados, y la velocidad que obtienes. Simplemente ejecutando fastlane match appstore le entrega un certificado en un par de segundos.

Bueno, ahora tenemos los certificados y el aprovisionamiento que necesitamos, hagamos un lanzamiento a Crashlytics.

Un flujo de trabajo típico para enviar su aplicación a Crashlytics de Fabric incluye los siguientes pasos:

1. Crea los certificados de firma de distribución.
2. Crea un perfil de aprovisionamiento ad-hoc (adjunto al certificado del n. ° 1).
3. Configura tu aplicación para usar el perfil de aprovisionamiento desde # 2.
4. Archiva tu aplicación.
5. Abre Fabric y sigue los pasos para enviar la aplicación a los beta testers.

Fastlane reemplaza la tarea con esto:

platform :ios do
  lane :beta do
    match(type: “adhoc”)
    gym
    crashlytics
  end
end

Ahora, ejecutando fastlane beta desde tu terminal se iniciará esta secuencia de comandos.

En primer lugar, se ejecutará match, una acción que maneja la creación y actualización de certificados de firma y perfiles de aprovisionamiento, luego se llama gym, una acción que crea y empaqueta la aplicación para ti, utilizando los mismos certificados y perfiles creados anteriormente, y finalmente, crashlytics, que tomará este .ipa firmado y lo cargará al servicio de Crashlytics.

Todos estos pasos se llaman, siempre, en el mismo orden, lo que hace que el archivo resultante sea más predecible y reduce los errores.

MacBook-Pro:TestProject user$ fastlane beta

+------+-------------------------------------+-------------+
|                     fastlane summary                     |
+------+-------------------------------------+-------------+
| Step | Action                              | Time (in s) |
+------+-------------------------------------+-------------+
| 1    | Verifying required fastlane version | 0           |
| 2    | match                               | 57          |
| 3    | gym                                 | 592         |
| 4    | crashlytics                         | 195         |
+------+-------------------------------------+-------------+

[20:25:13]: ¡fastlane.tools acaba de salvarte 14 minutos! 🎉

 Esa era una configuración básica de cómo ejecutar Fastlane para enviar su aplicación a Crashlytics. ¿Qué más podemos automatizar?

Incremento de las versiones de compilación

Podemos, por ejemplo, establecer que cada vez que enviemos una versión beta, queremos aumentar el número de versión de compilación.

Esto se puede lograr usando una acción llamada increment_build_number que se puede invocar desde un terminal mediante fastlane run increment_build_number o usar en línea en nuestro carril beta:

platform :ios do
  lane :beta do
    increment_build_number
    match(type: “adhoc”)
    gym
    crashlytics
  end
end

¡Felicitaciones! Ahora tienes un script de despliegue automatizado que también incrementa su número de versión de compilación. La única advertencia es que, una vez que llames a este carril, vas a tener archivos modificados en tu proyecto (o, al menos, los que incorporan el número de compilación).

En caso de que planeara realizar ese cambio en el repositorio de todos modos, hay una acción para eso: commit_version_bump. Esta acción confirma los archivos con el nuevo número de versión.

platform :ios do
  lane :beta do
    increment_build_number
    match(type: "adhoc")
    gym
    crashlytics
    commit_version_bump(
     xcodeproj:"myProject.xcodeproj",
   )
  end
end

Esto enviará archivos con un mensaje de confirmación como este “Version Bump to 27”.

Crashlytics para TestFlight

Bueno, si llegaste hasta aquí, puedes tener una implementación automatizada en Crashlytics en muy poco tiempo que te ahorrará innumerables horas en el largo plazo. La mejor parte de esto es que si quieres enviar tu aplicación a TestFlight, todo lo que tienes que hacer es cambiar crashlytics por pilot.

O bien, puedes crear un carril separado para eso:

platform :ios do
  lane :beta-testflight do
    increment_build_number
    match(type: "adhoc")
    gym
    pilot
    commit_version_bump(
     xcodeproj:"myProject.xcodeproj",
   )
  end
end

iOS Automatización hecha simple

Fastlane es simple y fácil de usar. Sin embargo, aporta un valor increíble a su flujo de trabajo de desarrollo de iOS habitual al evitar que haga cosas insignificantes y horas de su tiempo que hubiera terminado desperdiciando.

Espero que encuentres útil esta introducción a Fastlane. Puedes consultar la documentación oficial para obtener más información sobre Fastlane, especialmente la lista de acciones si estás buscando inspiración sobre lo que podría automatizar para tus proyectos iOS actuales y futuros.