Fastfile: esensya, istraktura at pagsasaayos ng automation sa mobile development

Ano ang Fastfile at bakit ito kailangan

Fastfile — ay ang pangunahing Fastlane configuration file, na nakasulat sa Ruby language at inilalagay sa fastlane directory sa root ng proyekto. Tinutukoy nito ang lahat ng automation scenario (lanes) para sa pagbuo, pagsubok, pag-sign ng code, at pag-deliver ng application. Pinapalitan ng Fastfile ang dose-dosenang bash script, Makefile, at manual na instruksyon ng iisang declarative na paglalarawan ng CI/CD pipeline.

Ang pangangailangan para sa Fastfile ay lumilitaw kapag ang proyekto ay nangangailangan ng repeatable builds sa iba't ibang developer machine at CI/CD server. Sa halip na ang bawat developer ay manu-manong mag-configure ng environment, itinatala ng Fastfile ang lahat ng hakbang sa code na maaaring i-version sa Git, suriin, at muling gamitin sa pagitan ng mga proyekto. Isang Fastfile ay ginagarantiyahan na ang build sa developer machine ay identical sa build sa CI/CD server.

Sinusuportahan ng Fastfile ang platforms sa pamamagitan ng default_platform directive. Sa isang Fastfile ay maaaring ilarawan ang mga scenario para sa iOS, Android, at macOS, na pinapangkat sa mga block na platform :ios at platform :android. Ito ay lalong maginhawa para sa cross-platform na mga proyekto, kung saan ang iOS at Android builds ay may common deployment logic ngunit magkaibang build tools.

Istraktura ng Fastfile: lanes, actions at parameters

Fastfile ay binubuo ng tatlong pangunahing elemento: platform declaration (default_platform), definition ng lanes, at configuration ng auxiliary functions. Bawat lane ay nagsisimula sa keyword na lane, na sinusundan ng pangalan ng scenario (Ruby symbol), body na may sequence ng actions, at error handling blocks na error, success o ensure.

Actions sa Fastfile — ay mga tawag sa built-in na Fastlane functions na may parameters sa anyo ng Hash. Halimbawa, gym(scheme: 'App', export_method: 'app-store') ay naglulunsad ng build ng iOS application na may tinukoy na parameters. Bawat action ay nagbabalik ng resulta na maaaring i-save sa variable at gamitin sa mga susunod na actions — ito ay nagpapahintulot sa pagbuo ng conditional logic sa loob ng lane.

Sinusuportahan ng Fastfile ang environment variables sa pamamagitan ng standard ENV mechanism sa Ruby. Ang sensitibong data (password, token, keys) ay hindi dapat i-imbak sa Fastfile — gumamit ng environment variables ng CI/CD system o .env file na idinagdag sa .gitignore. Awtomatikong nilo-load ng Fastlane ang .env files mula sa fastlane directory kapag nag-start.

Appfile at Matchfile

Kasama ng Fastfile sa fastlane directory ay matatagpuan ang mga karagdagang configuration file. Appfile ay naglalaman ng application identifiers (app_identifier), Apple ID at Team ID — ang data na ito ay awtomatikong pinapalitan sa lahat ng actions, na inaalis ang pag-uulit sa bawat lane. Matchfile ay nag-iimbak ng mga setting para sa match: Git repository URL, uri ng profiles, at encryption key.

Ang paghahati ng configuration sa maraming file ay nagpapadali sa pagpapanatili ng mga proyekto na may iba't ibang environment. Halimbawa, para sa staging at production ay maaaring gumawa ng mga hiwalay na branch sa Matchfile repository o i-override ang parameters sa pamamagitan ng environment variables sa CI/CD system.

# Pangunahing istraktura ng 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

Syntax ng Fastfile: pagsulat ng lanes

Ang syntax ng Fastfile ay batay sa Ruby DSL (Domain Specific Language), na espesyal na idinisenyo para sa readability ng automation scenarios. Ang lane ay dinedeklara sa pamamagitan ng construct na lane :name do ... end, kung saan ang name ay isang Ruby symbol na nagiging command na fastlane name para sa pagpapatakbo mula sa terminal o CI/CD system.

Sa loob ng lane ay maaaring gamitin ang conditional operators ng Ruby: if, unless, case para sa branching ng logic. Available din ang each at while loops para sa pag-process ng arrays ng values. Nagbibigay ang Fastlane ng mga espesyal na method na before_all, after_all, at error blocks para sa pag-handle ng lifecycle events ng lane.

Parameters ng lane ay pinapasa sa pamamagitan ng options hash. Kapag nag-run ng fastlane build --option_name value, ang value ay napupunta sa options[:option_name] sa loob ng lane. Maaaring mag-set ng default values sa pamamagitan ng optional: true at type validation para sa kontrol ng mga uri ng pinapasang parameters.

# Lane na may parameters at conditional logic
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

Halimbawa ng Fastfile para sa iOS delivery

Ang kumpletong Fastfile para sa iOS project ay may kasamang lanes para sa pag-install ng dependencies, pag-test, pag-build, at pag-deploy sa TestFlight at App Store. Tingnan natin ang halimbawa na sumasaklaw sa tipikal na CI/CD process mula commit hanggang publikasyon sa TestFlight para sa internal testing.

# Fastfile para sa iOS CI/CD delivery
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: 'Build na-upload sa TestFlight para sa internal testing'
  )
end

Sa halimbawang ito, ang before_all block ay na-e-execute bago ang bawat lane at nag-i-install ng dependencies. Lane tests ay nagpapatakbo ng UI at Unit tests sa dalawang device. Lane build_appstore ay pumipirma ng code sa pamamagitan ng match at gumagawa ng IPA na may bitcode. Lane deploy_testflight ay pinagsasama ang lahat ng hakbang para sa kumpletong delivery.

Pag-deploy na may maraming target

Ang mga proyekto na may maraming target (main application, watchOS, widget, Notification Service Extension) ay nangangailangan ng hiwalay na lanes para sa bawat target. Sa Fastfile ay maaaring gumawa ng universal lane :deploy_target na tumatanggap ng scheme name at build path bilang parameter. Ito ay nagpapahintulot sa pagpapatakbo ng deploy para sa lahat ng extension sa pamamagitan ng fastlane deploy_target scheme:Widget.

Para sa organisasyon ng maraming target, gumamit ng array ng schemes at each loop sa loob ng lane. Fastlane ay sumusuporta sa parallel build ng maraming scheme sa pamamagitan ng flag na parallel: true, na nagpapababa sa kabuuang oras ng CI/CD pipeline para sa mga application na may extensions.

Halimbawa ng Fastfile para sa Android build

Fastfile para sa Android project ay gumagamit ng gradle action para sa pagpapatakbo ng Gradle tasks at supply action para sa publikasyon sa Google Play. Hindi tulad ng iOS, ang Android ay hindi nangangailangan ng match, ngunit gumagamit ng Keystore para sa pag-sign, na iniimbak sa labas ng repository at pinapasa sa pamamagitan ng environment variables.

# Fastfile para sa Android CI/CD build
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

Para sa Android signing ng application, i-configure ang signingConfigs sa build.gradle at ipasa ang Keystore parameters sa pamamagitan ng environment variables: ANDROID_KEYSTORE_PATH, ANDROID_KEYSTORE_PASSWORD, ANDROID_KEY_ALIAS at ANDROID_KEY_PASSWORD. Awtomatikong ginagamit ng Fastlane ang system apksigner para sa pag-sign ng nabuong AAB o APK.

Android signing sa Fastfile

Para sa pag-configure ng Android signing sa Fastfile, gamitin ang action na sign_android o umasa sa signingConfigs sa build.gradle. Ang Fastlane ay nag-i-integrate sa apksigner sa pamamagitan ng Gradle — ang pagpasa ng SIGNING_CONFIG flag sa gradle task ay nag-a-activate ng signing na may parameters mula sa environment variables. Ito ay nagpapahintulot sa pag-sign ng AAB files bago i-upload sa Google Play Console.

Para sa secure na pag-iimbak ng Keystore sa CI/CD, gumamit ng Base64 encoding at environment variables. Fastlane ay sumusuporta sa action na setup_keystore, na nagde-decode ng Keystore mula sa variable at nagse-save sa temporary file sa before_all stage. Pagkatapos ng lane, ang temporary file ay awtomatikong tatanggalin upang maiwasan ang pagtagas ng certificates.

Paggamit ng private lanes at grupo

Private lanes (pribadong scenario) — ay mga lane na hindi maaaring tawagan nang direkta mula sa command line, ngunit available para sa tawag mula sa ibang lanes sa loob ng Fastfile. Ang private lane ay dinedeklara sa pamamagitan ng construct na private_lane :name do ... end at ginagamit para sa encapsulation ng mga paulit-ulit na hakbang na walang kahulugan bilang standalone scenarios.

Ang private lanes ay perpekto para sa pag-grupo ng paulit-ulit na logic: pag-install ng dependencies, pag-configure ng environment, pagpapadala ng mga notification. Halimbawa, maaaring gumawa ng private lane :setup_signing na tinatawag mula sa ilang deploy lanes, ngunit hindi dapat available para sa direktang pagpapatakbo ng developer upang maiwasan ang mga error.

# Private lane at pag-grupo
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

Pag-grupo ng lanes sa pamamagitan ng platform blocks ay nagpapahintulot sa paghihiwalay ng mga scenario para sa iOS at Android sa iisang Fastfile. Ang construct na platform :ios do ... end at platform :android do ... end ay naghihiwalay ng lanes ng kaukulang platform, at ang mga common private lanes ay maaaring ilagay sa labas ng platform blocks para sa muling paggamit.

Pagpapasa ng parameters sa lanes

Ang mekanismo ng parameters ng Fastfile ay nagpapahintulot sa mga lane na maging flexible at reusable. Ang parameters ay pinapasa sa pag-execute sa pamamagitan ng command line: fastlane build scheme:App export_method:appstore. Sa loob ng lane, ang values ay available sa pamamagitan ng options hash na pinapasa sa lane block bilang argument.

Sinusuportahan ng Fastlane ang typed parameters na may validation sa pamamagitan ng OptionalHash. Maaaring mag-set ng uri ng value (String, Boolean, Integer), default value, at paglalarawan para sa automatic documentation generation. Available din ang environment variables bilang alternatibong paraan ng pagpapasa ng parameters, na maginhawa para sa CI/CD systems.

# Parameters na may type validation
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: "Pagbuo #{options[:scheme]} ay natapos")
end

# Pagpapatakbo: fastlane build scheme:MyApp export_method:appstore

Inirerekomenda na gumamit ng default values para sa lahat ng optional parameters, upang ang lane ay maaaring patakbuhin nang hindi kailangang tukuyin ang bawat argument. Para sa mandatory parameters, suriin ang presensya ng value sa simula ng lane at ihinto ang execution na may malinaw na error message sa pamamagitan ng UI.user_error!.