Ruby no desenvolvimento mobile: Fastlane, CI/CD e automação

O que é Ruby?

Ruby é uma linguagem dinâmica interpretada de código aberto criada por Yukihiro Matsumoto em 1995. O princípio fundamental do Ruby é a "simplicidade ideal" (princípio da menor surpresa). A linguagem é conhecida por blocos (closures), abordagem puramente orientada a objetos (tudo é um objeto, incluindo números) e um poderoso sistema de metaprogramação.

O Ruby é executado no interpretador YARV (Yet Another Ruby VM) com compilação JIT desde a versão 3.1. A versão atual Ruby 3.4 (2025) inclui decoradores, um analisador Prism melhorado e suporte experimental a tipos via RBS. RubyGems — o gerenciador de pacotes — contém mais de 200.000 gems.

Ruby on Rails é o framework web mais famoso construído com Ruby, mas no desenvolvimento mobile o Ruby é usado de forma diferente. Seu principal nicho é o Fastlane: um ecossistema de scripts e gems Ruby para automatizar todas as etapas do ciclo de vida de um aplicativo mobile — desde a assinatura de código até a publicação nas lojas.

Fundamentos da sintaxe Ruby para Fastlane

Trabalhar com Fastlane requer apenas conhecimento básico de Ruby: métodos, blocos do-end, símbolos (:symbol) e sintaxe de hashes { key: value }. Ao contrário do Python, o Ruby usa end para fechar blocos em vez de indentação. Métodos podem ser chamados sem parênteses — isso é ativamente usado no DSL do Fastlane.

# Sintaxe básica do Ruby usada no Fastlane
def download_assets(version, platform: "ios")
  paths = {
    ios: "ios/Assets.car",
    android: "android/app/src/main/assets"
  }
  url = "https://cdn.example.com/assets/#{version}/#{paths[platform.to_sym]}"
  puts "Downloading from: #{url}"

  unless File.exist?("temp/assets")
    Dir.mkdir("temp/assets")
  end
  result = system("curl -o temp/assets.zip #{url}")
  raise "Download failed" unless result
end

download_assets("1.2.3", platform: "android")

No exemplo, o método download_assets recebe um argumento version e um parâmetro nomeado opcional platform (padrão "ios"). A interpolação de strings com #{...} insere valores diretamente nas strings. unless é o oposto de if — executa o código quando a condição é falsa.

Fastlane: automação de compilações mobile com Ruby

Fastlane é uma ferramenta de código aberto escrita em Ruby. Instalada via gem install fastlane, ela fornece um conjunto de comandos para automatizar as tarefas mais rotineiras do desenvolvedor mobile: criar capturas de tela, assinar código, publicar no TestFlight e no Google Play Console.

Fastlane consiste em ferramentas: sigh (gerenciamento de certificados), match (sincronização de certificados em equipes), gym (compilações iOS), gradle (compilações Android), deliver (publicação iOS), supply (publicação Android), snapshot (capturas de tela), scan (testes). Todas as ferramentas são acessíveis a partir de um único Fastfile.

Em projetos grandes, o Fastlane lida com mais de 50 ações em um único pipeline: incremento de versão, download de assets de CDN, compilação, assinatura, upload para App Store Connect, envio de notificações no Slack. Todo o pipeline é executado com um único comando: fastlane release.

Fastfile: configuração do pipeline de compilação

Fastfile é um arquivo DSL semelhante ao Ruby que descreve uma sequência de ações (lanes). Cada lane é uma tarefa separada: beta (compilação de teste), release, screenshots. Lanes podem chamar outras lanes com parâmetros passados.

# Fastfile — configuração do pipeline de compilação do aplicativo iOS
fastlane_version "2.220.0"

default_platform :ios

platform :ios do
  desc "Compilação e implantação do build do TestFlight"
  lane :beta do |options|
    increment_build_number(
      build_number: options[:build]
    )
    match(type: :appstore)
    gym(
      scheme: "MyApp",
      export_method: "app-store",
      configuration: "Release"
    )
    upload_to_testflight(
      app_identifier: "com.example.myapp"
    )
    slack(
      message: "Build #{options[:build]} enviado para o TestFlight"
    )
  end
end

A lane beta executa sequencialmente: incrementar número da compilação (increment_build_number), sincronizar certificados (match), compilar arquivo (gym), enviar para TestFlight (upload_to_testflight) e enviar notificação no Slack. O parâmetro :build é passado para a lane como um argumento nomeado.

Configuração Android no Fastfile

Fastlane suporta ambas as plataformas em um único Fastfile. Para Android, use uma lane dentro de platform :android com as ações gradle, supply e google_play_track_version_codes.

platform :android do
  desc "Compilação de APK e publicação no Google Play Internal Testing"
  lane :beta do
    gradle(
      task: "assemble",
      build_type: "Release",
      flavor: "Production"
    )
    supply(
      track: "internal",
      apk_paths: ["app/build/outputs/apk/release/app-release.apk"]
    )
  end
end

Ações principais do Fastlane para iOS e Android

Fastlane inclui mais de 200 ações integradas. Abaixo estão as mais importantes para o desenvolvimento mobile, organizadas por categoria.

Match: gerenciamento seguro de certificados

match é uma gem do Fastlane para sincronizar certificados iOS e perfis de provisionamento entre desenvolvedores. Todos os segredos são armazenados em um repositório Git criptografado ou S3. O Match gera automaticamente certificados se estiverem faltando e os renova no vencimento.

# Inicializando match para um novo projeto
$ fastlane match init

# Criação e sincronização de certificados da App Store
$ fastlane match appstore

# Criação de certificados de Development para a equipe
$ fastlane match development

# Renovação de todos os certificados no vencimento
$ fastlane match --force

O Match armazena chaves privadas com uma frase secreta conhecida apenas pelos desenvolvedores. Cada desenvolvedor clona o repositório de certificados e executa match para instalar os perfis atuais. Os certificados da Apple são válidos por 1 ano; o Match os renova automaticamente.

Integração do Fastlane com sistemas CI/CD

Fastlane integra-se com qualquer plataforma CI/CD: GitHub Actions, GitLab CI, CircleCI, Bitrise, Jenkins e Xcode Cloud (via xcode-build). O Fastlane é executado no CI usando fastlane <lane_name> e retorna um código de erro se alguma etapa falhar.

A configuração para GitHub Actions inclui instalar Ruby, fastlane e executar a lane via bundle exec fastlane. Compilações iOS exigem um runner macOS. Compilações Android podem usar ubuntu-latest, que é mais barato.

# .github/workflows/deploy.yml — CI/CD com Fastlane
name: Deploy Mobile App
on:
  push:
    branches: [main]

jobs:
  ios-deploy:
    runs-on: macos-14
    steps:
      - uses: actions/checkout@v4
      - uses: ruby/setup-ruby@v1
        with:
          ruby-version: "3.3"
      - run: bundle install
      - run: bundle exec fastlane beta
      - env:
          MATCH_PASSWORD: ${{ secrets.MATCH_PASSWORD }}

O workflow é executado ao fazer push para main. O runner macOS executa bundle exec fastlane beta do Fastfile. MATCH_PASSWORD é passada através de GitHub Secrets para descriptografia de certificados. Após a conclusão da lane, uma ação do Slack envia uma notificação.

Ruby Gems e plugins do Fastlane

RubyGems é o gerenciador de pacotes do Ruby. O Fastlane é estendido através de plugins — gems que adicionam novas ações. O plugin fastlane-plugin-versioning gerencia versões, fastlane-plugin-firebase_app_distribution envia compilações para o Firebase. Existem mais de 500 plugins Fastlane no GitHub.

O Gemfile na raiz do projeto fixa as versões de todas as dependências para compilações reproduzíveis. bundle install instala gems a partir do Gemfile.lock. As gems essenciais para desenvolvimento mobile incluem: fastlane, cocoapods (dependências iOS), xcodeproj (manipulação de .xcodeproj).

# Gemfile para um projeto mobile
source "https://rubygems.org"

gem "fastlane", "~> 2.220"

plugins_path = File.join(File.dirname(__FILE__), 'fastlane', 'Pluginfile')
eval_gemfile(plugins_path) if File.exist?(plugins_path)

Fastlane vs alternativas: comparação de abordagens

Fastlane não é a única ferramenta de automação. Vamos compará-la com as principais alternativas com base em critérios importantes para uma equipe mobile.

Fastlane continua sendo a ferramenta mais flexível para pipelines complexos. Bitrise é conveniente para equipes sem um desenvolvedor Ruby. Xcode Cloud funciona para projetos iOS simples. GitHub Actions é ideal se a equipe já usa GitHub.