Fastfile: podstata, struktura a nastavení automatizace v mobilním vývoji

Co je Fastfile a k čemu slouží

Fastfile je hlavní konfigurační soubor Fastlane, napsaný v jazyce Ruby a umístěný v adresáři fastlane v kořenu projektu. Definuje všechny scénáře automatizace (lanes) pro sestavení, testování, podepisování kódu a doručení aplikace. Fastfile nahrazuje desítky bash skriptů, Makefile a ručních instrukcí jednotným deklarativním popisem CI/CD pipeline.

Potřeba Fastfile vzniká, když projekt vyžaduje opakovatelná sestavení na různých vývojářských počítačích a CI/CD serverech. Místo ručního nastavování prostředí každým vývojářem Fastfile fixuje všechny kroky v kódu, který lze verzovat v Gitu, kontrolovat a znovu používat mezi projekty. Jednotný Fastfile zaručuje, že sestavení na vývojářském počítači je identické se sestavením na CI/CD serveru.

Fastfile podporuje platformy přes direktivu default_platform. V jednom Fastfile lze popsat scénáře pro iOS, Android a macOS, seskupené do bloků platform :ios a platform :android. To je obzvláště výhodné pro multiplatformní projekty, kde iOS a Android sestavení sdílejí společnou logiku nasazení, ale používají různé nástroje pro sestavení.

Struktura Fastfile: lanes, actions a parametry

Fastfile se skládá ze tří hlavních prvků: deklarace platformy (default_platform), definice lanes a nastavení pomocných funkcí. Každé lane začíná klíčovým slovem lane, následovaným názvem scénáře (symbol Ruby), tělem s posloupností actions a bloky zpracování chyb error, success nebo ensure.

Actions ve Fastfile jsou volání vestavěných funkcí Fastlane s parametry ve formátu Hash. Například gym(scheme: 'App', export_method: 'app-store') spouští sestavení iOS aplikace s uvedenými parametry. Každé action vrací výsledek, který lze uložit do proměnné a použít v následujících actions – to umožňuje vytvářet podmíněnou logiku uvnitř lane.

Fastfile podporuje proměnné prostředí přes standardní mechanismus ENV v Ruby. Citlivá data (hesla, tokeny, klíče) by neměla být uložena ve Fastfile – používejte proměnné prostředí CI/CD systému nebo soubor .env, který je přidán do .gitignore. Fastlane automaticky načítá .env soubory z adresáře fastlane při spuštění.

Appfile a Matchfile

Spolu s Fastfile jsou v adresáři fastlane umístěny další konfigurační soubory. Appfile obsahuje identifikátory aplikace (app_identifier), Apple ID a Team ID – tato data jsou automaticky dosazena do všech actions, čímž odpadá opakování v každém lane. Matchfile ukládá nastavení pro match: URL Git repozitáře, typ profilů a šifrovací klíč.

Rozdělení konfigurace do více souborů zjednodušuje údržbu projektů s různými prostředími. Například pro staging a production lze vytvořit samostatné větve v repozitáři Matchfile nebo přepsat parametry pomocí proměnných prostředí v CI/CD systému.

# Základní struktura Fastfile
default_platform(:ios)

lane :build_and_test do
  cocoapods
  scan(scheme: 'App', devices: ['iPhone 15'])
  gym(scheme: 'App')
end

lane :deploy do
  match(type: 'appstore')
  build_and_test
  pilot(skip_waiting_for_build_processing: true)
end

Syntaxe Fastfile: psaní lanes

Syntaxe Fastfile je založena na Ruby DSL (Domain Specific Language), speciálně navrženém pro čitelnost scénářů automatizace. Lane je deklarováno konstrukcí lane :název do ... end, kde název je symbol Ruby, který se stává příkazem fastlane název pro spuštění z terminálu nebo CI/CD systému.

Uvnitř lane lze používat podmíněné operátory Ruby: if, unless, case pro větvení logiky. Dále jsou k dispozici cykly each a while pro zpracování polí hodnot. Fastlane poskytuje speciální metody before_all, after_all a error bloky pro zpracování událostí životního cyklu lane.

Parametry lane se předávají přes options hash. Při spuštění fastlane build --option_name value se hodnota dostane do options[:option_name] uvnitř lane. Lze nastavit výchozí hodnoty přes optional: true a type validaci pro kontrolu typů předávaných parametrů.

# Lane s parametry a podmíněnou logikou
lane :build do |options|
  scheme = options[:scheme] || 'App'
  export_method = options[:export_method] || 'development'

  match(type: export_method)

  if export_method == 'appstore'
    gym(scheme: scheme, export_method: 'app-store')
    pilot(skip_waiting_for_build_processing: true)
  else
    gym(scheme: scheme, export_method: export_method)
  end
end

Příklad Fastfile pro iOS doručení

Plnohodnotný Fastfile pro iOS projekt zahrnuje lanes pro instalaci závislostí, testování, sestavení a nasazení do TestFlight a App Store. Podívejme se na příklad, který pokrývá typický CI/CD proces od commitu po publikaci do TestFlight pro interní testování.

# Fastfile pro iOS CI/CD doručení
default_platform(:ios)

before_all do
  cocoapods(try_repo_update_on_error: true)
  setup_travis if ENV['TRAVIS']
end

lane :tests do
  scan(
    scheme: 'App',
    devices: ['iPhone 15', 'iPad Pro 12.9'],
    output_directory: './test_reports'
  )
end

lane :build_appstore do
  match(type: 'appstore', readonly: true)
  gym(
    scheme: 'App',
    export_method: 'app-store',
    include_bitcode: true
  )
end

lane :deploy_testflight do
  build_appstore
  pilot(
    skip_waiting_for_build_processing: true,
    distribute_external: false
  )
  slack(
    message: 'Sestavení nahráno do TestFlight pro interní testování'
  )
end

V tomto příkladu se blok before_all provádí před každým lane a instaluje závislosti. Lane tests spouští UI a Unit testy na dvou zařízeních. Lane build_appstore podepisuje kód přes match a sestavuje IPA s bitcode. Lane deploy_testflight kombinuje všechny kroky pro kompletní doručení.

Nasazení s více cíli

Projekty s více cíli (hlavní aplikace, watchOS, widget, Notification Service Extension) vyžadují samostatná lanes pro každý cíl. Ve Fastfile lze vytvořit univerzální lane :deploy_target, které přijímá název schématu a cestu k sestavení jako parametr. To umožňuje spouštět nasazení pro všechna rozšíření přes fastlane deploy_target scheme:Widget.

Pro organizaci více cílů použijte pole schémat a cyklus each uvnitř lane. Fastlane podporuje paralelní sestavení více schémat přes přepínač parallel: true, což zkracuje celkový čas CI/CD pipeline pro aplikace s rozšířeními.

Příklad Fastfile pro Android sestavení

Fastfile pro Android projekt používá gradle action pro spouštění Gradle úloh a supply action pro publikaci do Google Play. Na rozdíl od iOS Android nevyžaduje match, ale používá Keystore pro podepisování, který je uložen mimo repozitář a předáván přes proměnné prostředí.

# Fastfile pro Android CI/CD sestavení
default_platform(:android)

lane :build_release do
  gradle(task: 'clean')
  gradle(task: 'bundleRelease')
  gradle(task: 'assembleRelease')
end

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

Pro podepsání Android aplikace nastavte signingConfigs v build.gradle a předejte parametry Keystore přes proměnné prostředí: ANDROID_KEYSTORE_PATH, ANDROID_KEYSTORE_PASSWORD, ANDROID_KEY_ALIAS a ANDROID_KEY_PASSWORD. Fastlane automaticky používá systémový apksigner pro podepsání sestaveného AAB nebo APK.

Podepsání Android ve Fastfile

Pro nastavení podepisování Android ve Fastfile použijte action sign_android nebo se spolehněte na signingConfigs v build.gradle. Fastlane se integruje s apksigner přes Gradle – předání přepínače SIGNING_CONFIG do gradle úlohy aktivuje podepisování s parametry z proměnných prostředí. To umožňuje podepisovat AAB soubory před nahráním do Google Play Console.

Pro bezpečné uložení Keystore v CI/CD používejte Base64 kódování a proměnné prostředí. Fastlane podporuje action setup_keystore, které dekóduje Keystore z proměnné a uloží jej do dočasného souboru ve fázi before_all. Po dokončení lane je dočasný soubor automaticky smazán, aby se zabránilo úniku certifikátů.

Použití private lanes a skupin

Private lanes (uzavřené scénáře) jsou lanes, které nelze volat přímo z příkazového řádku, ale jsou dostupné pro volání z jiných lanes uvnitř Fastfile. Private lane se deklaruje konstrukcí private_lane :název do ... end a používá se pro zapouzdření opakujících se kroků, které nedávají smysl jako samostatné scénáře.

Private lanes jsou ideální pro seskupování opakující se logiky: instalace závislostí, nastavení prostředí, odesílání notifikací. Například lze vytvořit private lane :setup_signing, které je voláno z několika lane nasazení, ale nemělo by být přístupné pro přímé spuštění vývojářem, aby se předešlo chybám.

# Private lane a seskupování
default_platform(:ios)

private_lane :setup_signing do |options|
  match(
    type: options[:type],
    readonly: true,
    verbose: false
  )
end

lane :beta do
  setup_signing(type: 'adhoc')
  gym(export_method: 'ad-hoc')
  pilot(distribute_external: true)
end

lane :release do
  setup_signing(type: 'appstore')
  gym(export_method: 'app-store')
  deliver(
    force: true,
    submit_for_review: true
  )
end

Seskupování lanes přes platform bloky umožňuje oddělit scénáře pro iOS a Android v jednom Fastfile. Konstrukce platform :ios do ... end a platform :android do ... end izoluje lanes příslušné platformy, zatímco společná private lanes lze umístit mimo bloky platform pro znovupoužití.

Předávání parametrů do lanes

Mechanismus parametrů Fastfile umožňuje učinit lanes flexibilními a znovu použitelnými. Parametry se předávají při spuštění přes příkazový řádek: fastlane build scheme:App export_method:appstore. Uvnitř lane jsou hodnoty přístupné přes options hash, který je předán do bloku lane jako argument.

Fastlane podporuje typované parametry s validací přes OptionalHash. Lze nastavit typ hodnoty (String, Boolean, Integer), výchozí hodnotu a popis pro automatické generování dokumentace. Dále jsou k dispozici proměnné prostředí jako alternativní způsob předávání parametrů, vhodný pro CI/CD systémy.

# Parametry s validací typů
lane :build do |options|
  gym(
    scheme: options[:scheme],
    export_method: options[:export_method] || 'development',
    include_bitcode: options[:include_bitcode] || false,
    output_name: options[:output_name]
  )
  slack(message: "Sestavení #{options[:scheme]} dokončeno")
end

# Spuštění: fastlane build scheme:MyApp export_method:appstore

Doporučuje se používat výchozí hodnoty pro všechny volitelné parametry, aby lane mohlo být spuštěno bez explicitního uvedení každého argumentu. Pro povinné parametry zkontrolujte přítomnost hodnoty na začátku lane a přerušte provádění srozumitelnou chybovou zprávou přes UI.user_error!.