Fastlane: Automação iOS no Cruise Control

Fazer software para iOS é mais do que apenas escrever código Objective-C ou Swift: envolve saber como o UIKit funciona, como os certificados são feitos, como publicar seu aplicativo na loja, como lidar com avaliações de aplicativos e muito mais. Se você achar essa lista de tarefas eternas cansativa, alguma automação em seu fluxo de trabalho é exatamente o que você precisa.

Conheça o Fastlane, a ferramenta projetada para economizar minutos ou até horas em cada implantação.

Fastlane ajuda você a automatizar o processo de envio de versões beta para Crashlytics, TestFlight, App Store e muito mais.

Neste artigo, você aprenderá como usar o Fastlane para automatizar o fluxo de trabalho de implantação do aplicativo iOS. Embora nos concentremos no aspecto iOS desta ferramenta, Fastlane funciona igualmente bem para automação de desenvolvimento Android.

Introdução ao Fastlane

Existem vários métodos de instalação que você pode escolher, dependendo do que achar mais fácil. Se você tiver o Homebrew instalado e configurado, instalar o Fastlane leva apenas um comando:

 brew cask install fastlane

Caso contrário, Fastlane sendo uma ferramenta baseada em Ruby, gem é sempre uma opção:

 sudo gem install fastlane -NV

Ou você sempre pode baixar o Fastlane do site oficial.

Depois de instalar o Fastlane, execute fastlane init no diretório do projeto e siga as instruções.

Automação de implantação

Com o Fastlane instalado, agora você pode escrever scripts Ruby para indicar passo a passo o que você precisa fazer para obter sua implantação onde deseja. Isso é feito usando ações, ferramentas e pistas.

Ferramentas, ações e plug-ins do Fastlane

O Fastlane funciona com ferramentas em seu núcleo que ajudam você a criar seu aplicativo. Além das ferramentas de compilação, existem mais de 170 integrações integradas com serviços como Crashlytics, HockeyApp, TestFlight e mais plugins que terceiros criam e publicam para que você possa se conectar a outros serviços e muito mais.

Em sua essência, você obtém as principais ferramentas que permitem realizar uma variedade de tarefas: desde tirar capturas de tela automatizadas até enquadrá-las e carregá-las na loja, permite executar todos os seus testes automaticamente antes de criar o aplicativo.

As ações são as principais ferramentas que o Fastlane possui e os plug-ins são uma maneira de adicionar ações de terceiros à sua configuração do Fastlane.

Pistas

O Fastlane usa lanes que agrupam essencialmente uma lista de ações ou plugins sequencialmente para que você possa obter o mesmo resultado todas as vezes.

Ao executar uma pista, cada ação exportará uma variável de ambiente e as ações a seguir obterão automaticamente essas variáveis ​​para manter o processo em andamento. Por exemplo, usar a ação gym resultará na geração do caminho do arquivo .ipa , e usar crashlytics acessará esse local .ipa para fazer upload desse arquivo para seu sistema de distribuição de serviço beta.

Usando Fastlane com iOS

Você está começando com um novo cliente Toptal que deseja um aplicativo muito simples. O design já está pronto e o aplicativo pode ser codificado em algumas semanas. O próximo passo é começar a codificá-lo e, durante o processo de iteração, você enviará um aplicativo beta a cada duas semanas ao cliente para que ele possa ver seu progresso e fornecer feedback sobre como as coisas estão funcionando.

Toda vez que você enviar uma versão beta para o cliente, você passará por uma lista de verificação básica: assinar o aplicativo, carregá-lo em um serviço beta, adicionar uma nova versão a ele etc. Adicione a isso as coisas que você precisa fazer uma vez (todo ano): assinatura de certificados, assinatura de certificados de notificação por push (se necessário) e muito mais.

Com Fastlane, tudo isso agora pode acontecer automaticamente!

Enviando para o Crashlytics Beta

Por exemplo, você precisa criar certificados de assinatura e perfis de provisionamento para compartilhar seu aplicativo por meio do Crashlytics Beta.

Fastlane tem uma ação chamada match que, uma vez configurada, faz o seguinte:

1. Crie certificados de assinatura de distribuição.
2. Crie um perfil de provisionamento ad-hoc (anexado ao certificado de #1).
3. Salve o certificado e o perfil de #1 e #2 em um repositório Git, criptografado usando OpenSSL.

A configuração é simples.

Primeiro, execute fastlane match init para começar e, depois de definir seu repositório Git, basta chamar o fastlane match adhoc para obter um perfil de provisionamento ad-hoc ou executar fastlane match appstore para obter um certificado da App Store.

As vantagens de usar o match são que você pode sincronizar os certificados com muita facilidade entre computadores - e entre colegas de equipe - sem precisar revogar mais os certificados e a velocidade que você ganha. Basta executar fastlane match appstore para obter um certificado em alguns segundos.

Bem, agora que temos os certificados e o provisionamento de que precisamos, vamos fazer um lançamento para o Crashlytics.

Um fluxo de trabalho típico para enviar seu aplicativo ao Crashlytics da Fabric inclui as seguintes etapas:

1. Crie os certificados de assinatura de distribuição.
2. Crie um perfil de provisionamento ad-hoc (anexado ao certificado de #1).
3. Configure seu aplicativo para usar o perfil de provisionamento de #2.
4. Arquive seu aplicativo.
5. Abra o Fabric e siga as etapas para enviar o aplicativo para testadores beta.

Fastlane substitui a tarefa por isso:

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

Agora, a execução do fastlane beta do seu terminal iniciará este script.

Isso primeiro chamará match , uma ação que lida com a criação e atualização de certificados de assinatura e perfis de provisionamento, depois chamará gym , uma ação que compila e empacota o aplicativo para você, usando os mesmos certificados e perfis criados antes e, finalmente, crashlytics , que é vai pegar este .ipa assinado e carregá-lo no serviço Crashlytics.

Todas essas etapas são chamadas, sempre, na mesma ordem, tornando o arquivo resultante mais previsível e reduzindo erros.

 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 just saved you 14 minutes!

Então, essa foi uma configuração básica de como executar o Fastlane para enviar seu aplicativo para o Crashlytics. O que mais podemos automatizar?

Incrementando versões de compilação

Podemos, por exemplo, definir que cada vez que enviarmos um beta, queremos aumentar o número da versão de compilação.

Isso pode ser alcançado usando uma ação chamada increment_build_number que pode ser chamada de um terminal por fastlane run increment_build_number ou usado inline em nossa pista beta:

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

Parabéns! Agora você tem um script de implantação automatizada que também incrementa o número da versão de compilação. A única ressalva é que, uma vez que você chamar essa pista, você terá arquivos alterados em seu projeto (ou, pelo menos, aqueles que incorporam o número da compilação).

Caso você estivesse planejando submeter essa mudança ao repositório de qualquer maneira, existe uma ação para isso: commit_version_bump . Esta ação confirma os arquivos com o novo número de versão.

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

Isso fará o commit de arquivos com uma mensagem de commit como esta “Version Bump to 27”.

Crashlytics para TestFlight

Bem, se você chegou até aqui, pode ter uma implantação automatizada no Crashlytics em um tempo muito curto, o que economizará inúmeras horas a longo prazo. A melhor parte disso é que, se você quiser enviar seu aplicativo para TestFlight, tudo o que você precisa fazer é alterar crashlytics para pilot .

Ou você pode criar uma faixa separada para isso:

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

Automação iOS simplificada

Fastlane é simples e fácil de usar. Mas traz um valor incrível ao seu fluxo de trabalho regular de desenvolvimento do iOS, evitando que você faça coisas braçais e horas do seu tempo que você acabaria desperdiçando.

Espero que você ache útil esta introdução ao Fastlane. Você pode conferir a documentação oficial para saber mais sobre o Fastlane, especialmente a lista de ações, se estiver procurando alguma inspiração sobre o que pode automatizar para seus projetos iOS atuais e futuros.