Fastlane — o que é, ferramentas e automação de compilação de aplicativos móveis

O que é Fastlane e como ele automatiza compilações móveis

Fastlane é uma ferramenta de automação de compilações móveis, escrita em Ruby e distribuída sob licença MIT. Ela automatiza tarefas rotineiras do desenvolvedor móvel: compilação do aplicativo, execução de testes, criação de capturas de tela, assinatura de código e envio de binários para a App Store ou Google Play. Em vez de 15 a 20 comandos manuais, o desenvolvedor executa um único comando fastlane com o nome do cenário.

Fastlane funciona como uma camada de abstração sobre os utilitários do Xcode (xcodebuild, xcrun) e do Android SDK (gradlew, apksigner, bundletool), fornecendo uma interface unificada para ambas as plataformas. Isso é especialmente valioso para equipes que mantêm versões iOS e Android do mesmo aplicativo — Fastfiles idênticos podem descrever compilações para ambas as plataformas com diferenças mínimas nos parâmetros.

De acordo com o GitHub, Fastlane tem mais de 39 mil estrelas e é o padrão de automação no desenvolvimento móvel. A ferramenta é mantida pela comunidade e pela Google — Fastlane está integrado ao Firebase como a forma recomendada de enviar aplicativos Android para o Google Play Console.

Arquitetura do Fastlane: Actions, Lanes e ferramentas

A arquitetura do Fastlane é construída em três níveis: actions (comandos básicos), lanes (cenários) e ferramentas (utilitários especializados). Actions são funções individuais do Fastlane, cada uma executando uma ação específica: criar captura de tela, compilar IPA, enviar para o TestFlight. Lanes combinam várias actions em um cenário sequencial, descrito no Fastfile.

Fastlane Actions

Actions são os blocos de construção do Fastlane. Cada action aceita parâmetros e executa uma única tarefa. Por exemplo, a action gym compila o aplicativo iOS, scan executa testes, pilot envia o build para o TestFlight. No total, o Fastlane possui mais de 200 actions integradas, com documentação disponível para cada uma através do comando fastlane action [nome].

Se as actions integradas não forem suficientes, o desenvolvedor pode criar uma custom action em Ruby e conectá-la no Fastfile. Custom actions são distribuídas através de plugins Fastlane, publicados no Rubygems e instalados através do arquivo FastfilePlugin na raiz do projeto.

Lanes e sua composição

Lane é um cenário de automação nomeado que combina várias actions em uma sequência lógica. Lane pode chamar outras lanes (private lanes), passar parâmetros e tratar erros. Isso permite construir uma hierarquia de cenários: lane básica de compilação, lane de deploy, lane de ciclo CI/CD completo.

Principais ferramentas do Fastlane: scan, gym, match, deliver

Fastlane inclui um conjunto de ferramentas especializadas, cada uma resolvendo uma tarefa específica de automação móvel. As ferramentas são executadas como actions dentro de lanes ou diretamente da linha de comando. Vamos analisar quatro ferramentas principais que cobrem as necessidades básicas de CI/CD para iOS e Android.

Scan simplifica a execução de testes do Xcode, selecionando automaticamente o simulador adequado e formatando o relatório. Gym compila o aplicativo com flags de compilação ideais e suporta exportOptions.plist para diferentes tipos de build (development, adhoc, appstore). Deliver permite enviar não apenas o binário, mas também capturas de tela, descrição, versões e preços através de um único arquivo de metadados.

A ferramenta Match merece atenção especial — ela resolve o problema de armazenamento e sincronização de certificados iOS em equipe. Match criptografa e armazena certificados e perfis de provisionamento em um repositório Git, e os desenvolvedores os obtêm automaticamente ao executar fastlane match. Isso elimina a configuração manual de cada estação de trabalho.

Snapshot: geração de capturas de tela

Snapshot é uma ferramenta para criação automática de capturas de tela de aplicativos móveis em diferentes dispositivos e idiomas. Snapshot executa testes de UI em simuladores iOS, capturando a tela em cada etapa do teste. Os resultados são salvos no diretório fastlane/screenshots e podem ser enviados para App Store Connect através do deliver.

Para Android, o screengrab desempenha função similar em emuladores Android. Ambas as ferramentas suportam localização — as capturas de tela são criadas para cada idioma, simplificando a preparação de materiais para publicação em lojas de aplicativos multilíngues.

Configuração do Fastlane para aplicativos iOS

Para projetos iOS, o Fastlane é configurado através do Gemfile (instalação da gem fastlane) e do Fastfile no diretório fastlane. A configuração inicial é feita com o comando fastlane init, que cria a estrutura básica de diretórios, solicita os dados da App Store Connect e gera um modelo de Fastfile com lanes principais.

O comando principal para iOS é fastlane match, que deve ser executado primeiro para obter certificados e perfis de provisionamento. Após a assinatura bem-sucedida, o Fastlane pode compilar o aplicativo (gym), executar testes (scan) e enviar o binário (pilot ou deliver).

# Fastfile para aplicativo iOS
default_platform(:ios)

lane :build do
  cocoapods
  scan(scheme: 'App', devices: ['iPhone 15'])
  gym(scheme: 'App', export_method: 'app-store')
end

lane :deploy do
  match(type: 'appstore')
  build
  pilot(skip_waiting_for_build_processing: true)
  slack(message: 'Nova versão enviada para o TestFlight')
end

Para trabalhar com TestFlight, use a action pilot — ela envia o IPA e gerencia testadores. Fastlane suporta upload_to_testflight (sinônimo de pilot) e lida automaticamente com a espera do processamento do build pela Apple, que pode levar de 5 a 30 minutos.

Configuração do Fastlane para aplicativos Android

Para projetos Android, o Fastlane é configurado de forma similar, mas em vez das ferramentas do Xcode, são usados Gradle e Android SDK. Fastlane para Android suporta compilação de APK e AAB, assinatura via apksigner ou jarsigner, execução de testes instrumentais e envio para Google Play Console através da action Supply.

A principal diferença é que a compilação Android não requer gerenciamento de certificados via match (a assinatura Android é gerenciada através de Keystore, armazenado separadamente). Fastlane para Android usa a action gradle para executar qualquer tarefa Gradle e a action supply para trabalhar com o Google Play.

# Fastfile para aplicativo Android
default_platform(:android)

lane :build do
  gradle(task: 'clean assembleRelease')
  gradle(task: 'testReleaseUnitTest')
end

lane :deploy do
  build
  supply(
    track: 'internal',
    aab: 'app/build/outputs/bundle/release/app-release.aab'
  )
end

Para trabalhar com o Google Play Console, é necessária uma conta de serviço Google Cloud com acesso à API Google Play. Fastlane aceita a chave JSON da conta de serviço através da variável de ambiente SUPPLY_JSON_KEY ou do parâmetro json_key na action supply. O track de publicação pode ser internal, alpha, beta ou production.

Integração do Fastlane com sistemas CI/CD

Fastlane integra-se com qualquer sistema CI/CD que possa executar scripts Ruby: Jenkins, Travis CI, GitHub Actions, GitLab CI, Bitrise e CircleCI. A integração resume-se à instalação da gem fastlane e à execução do comando fastlane [lane_name] na etapa de script do pipeline.

Para CI/CD, é importante configurar variáveis de ambiente para armazenar dados sensíveis: MATCH_PASSWORD (senha de criptografia dos certificados), FASTLANE_USER (Apple ID), FASTLANE_PASSWORD (senha do Apple ID). No Travis CI, as variáveis são criptografadas com travis encrypt; no GitHub Actions, através de Secrets do repositório.

A prática recomendada é usar fastlane match em CI/CD com a flag readonly para evitar alterações acidentais no repositório de certificados. Para Android, use o Keystore codificado em Base64 e armazenado em uma variável de ambiente, que é decodificado e salvo em um arquivo temporário na etapa before_install.

Fastlane Match: gerenciamento de certificados e perfis

Fastlane Match é uma ferramenta para automatizar o gerenciamento de certificados iOS e perfis de provisionamento, uma das funcionalidades mais valiosas do Fastlane para equipes. Match cria um repositório Git criptografado (ou usa um existente) onde armazena todos os certificados e perfis, sincronizando-os entre desenvolvedores e servidores CI/CD.

Match suporta cinco tipos de perfis: development, adhoc, appstore, enterprise e developer_id. Cada tipo é armazenado em um diretório separado dentro do repositório. O comando fastlane match development instala certificados de desenvolvimento na máquina local, enquanto fastlane match appstore instala perfis da App Store para compilação em CI.

# Uso do Match no Fastfile
lane :setup_signing do
  match(
    type: 'appstore',
    readonly: true,
    git_branch: 'main'
  )
end

lane :update_profiles do
  match(
    type: 'development',
    force: true,
    app_identifier: ['com.example.app', 'com.example.app.watchkitapp']
  )
end

A segurança do Match é garantida por criptografia de todos os arquivos antes do commit no Git. A senha de criptografia é definida através da variável de ambiente MATCH_PASSWORD e deve ser a mesma para todos os membros da equipe. Match usa OpenSSL para criptografia e não armazena a senha em texto claro no repositório.