Fastfile: innebörd, struktur och konfigurering av automatisering inom mobilutveckling

Vad är Fastfile och varför behövs det

Fastfile är huvudkonfigurationsfilen för Fastlane, skriven i Ruby och placerad i katalogen fastlane i projektroten. Den definierar alla automatiseringsscenarier (lanes) för att bygga, testa, signera kod och leverera appen. Fastfile ersätter dussintals bash-skript, Makefile och manuella instruktioner med en enda deklarativ beskrivning av CI/CD-pipeline.

Behovet av Fastfile uppstår när projektet kräver repeterbara byggen på olika utvecklardatorer och CI/CD-servrar. Istället för att varje utvecklare manuellt konfigurerar miljön, fixerar Fastfile alla steg i kod som kan versionshanteras i Git, granskas och återanvändas mellan projekt. Enhetlig Fastfile garanterar att bygget på utvecklardatorn är identiskt med bygget på CI/CD-servern.

Fastfile stöder plattformar via direktivet default_platform. I en Fastfile kan scenarier för iOS, Android och macOS beskrivas, grupperade i block platform :ios och platform :android. Detta är särskilt praktiskt för plattformsoberoende projekt där iOS- och Android-byggen delar gemensam distributionslogik men använder olika byggverktyg.

Struktur för Fastfile: lanes, actions och parametrar

Fastfile består av tre huvudelement: plattformsdeklaration (default_platform), lanes-definitioner och konfiguration av hjälpfunktioner. Varje lane börjar med nyckelordet lane, följt av scenariots namn (Ruby-symbol), kropp med sekvens av actions och felhanteringsblock error, success eller ensure.

Actions i Fastfile är anrop till inbyggda Fastlane-funktioner med parametrar i Hash-format. Till exempel startar gym(scheme: 'App', export_method: 'app-store') bygget av iOS-appen med angivna parametrar. Varje action returnerar ett resultat som kan lagras i en variabel och användas i efterföljande actions – detta möjliggör villkorslogik inuti lane.

Fastfile stöder miljövariabler via standardmekanismen ENV i Ruby. Känslig data (lösenord, tokens, nycklar) bör inte lagras i Fastfile – använd miljövariabler från CI/CD-systemet eller .env-fil som läggs till i .gitignore. Fastlane laddar automatiskt .env-filer från katalogen fastlane vid start.

Appfile och Matchfile

Tillsammans med Fastfile i katalogen fastlane finns ytterligare konfigurationsfiler. Appfile innehåller applikationsidentifierare (app_identifier), Apple ID och Team ID – dessa data sätts automatiskt in i alla actions, vilket eliminerar upprepning i varje lane. Matchfile lagrar inställningar för match: URL till Git-repository, typ av profiler och krypteringsnyckel.

Uppdelning av konfiguration i flera filer förenklar underhåll av projekt med olika miljöer. Till exempel kan separata grenar skapas i Matchfile-repositoryt för staging och production, eller parametrar kan åsidosättas via miljövariabler i CI/CD-systemet.

# Grundläggande struktur för 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 för Fastfile: skriva lanes

Syntaxen för Fastfile är baserad på Ruby DSL (Domain Specific Language), speciellt utformad för läsbarhet av automatiseringsscenarier. Lane deklareras med konstruktionen lane :namn do ... end, där namnet är en Ruby-symbol som blir kommandot fastlane namn för start från terminalen eller CI/CD-systemet.

Inuti lane kan Ruby-villkorsoperatorer användas: if, unless, case för logisk förgrening. Även looparna each och while finns tillgängliga för bearbetning av värdearrayer. Fastlane tillhandahåller speciella metoder before_all, after_all och error-block för hantering av lane-livscykelhändelser.

Lane-parametrar överförs via options-hash. Vid körning av fastlane build --option_name value hamnar värdet i options[:option_name] inuti lane. Standardvärden kan ställas in via optional: true och type-validering för att kontrollera typer av överförda parametrar.

# Lane med parametrar och villkorslogik
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

Exempel på Fastfile för iOS-leverans

En fullfjädrad Fastfile för iOS-projekt inkluderar lanes för installation av beroenden, testning, bygge och distribution till TestFlight och App Store. Låt oss titta på ett exempel som täcker en typisk CI/CD-process från commit till publicering i TestFlight för intern testning.

# Fastfile för iOS CI/CD-leverans
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: 'Bygget uppladdat till TestFlight för intern testning'
  )
end

I detta exempel körs blocket before_all före varje lane och installerar beroenden. Lanes tests kör UI- och Unit-tester på två enheter. Lanes build_appstore signerar koden via match och bygger IPA med bitcode. Lanes deploy_testflight kombinerar alla steg för fullständig leverans.

Distribution med flera mål

Projekt med flera mål (huvudapp, watchOS, widget, Notification Service Extension) kräver separata lanes för varje mål. I Fastfile kan ett universellt lane :deploy_target skapas som tar emot schemanamn och byggsökväg som parameter. Detta gör det möjligt att köra distribution för alla tillägg via fastlane deploy_target scheme:Widget.

För organisering av flera mål, använd en array av scheman och en each-loop inuti lane. Fastlane stöder parallellbyggen av flera scheman via flaggan parallel: true, vilket minskar den totala tiden för CI/CD-pipeline för appar med tillägg.

Exempel på Fastfile för Android-bygge

Fastfile för Android-projekt använder gradle action för att köra Gradle-uppgifter och supply action för publicering till Google Play. Till skillnad från iOS kräver Android inte match, men använder Keystore för signering, som lagras utanför repository och överförs via miljövariabler.

# Fastfile för Android CI/CD-bygge
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

För Android-signering av appen, konfigurera signingConfigs i build.gradle och överför Keystore-parametrar via miljövariabler: ANDROID_KEYSTORE_PATH, ANDROID_KEYSTORE_PASSWORD, ANDROID_KEY_ALIAS och ANDROID_KEY_PASSWORD. Fastlane använder automatiskt systemets apksigner för att signera den byggda AAB- eller APK-filen.

Android-signering i Fastfile

För att konfigurera Android-signering i Fastfile, använd action sign_android eller lita på signingConfigs i build.gradle. Fastlane integreras med apksigner via Gradle – överföring av flaggan SIGNING_CONFIG till gradle-uppgiften aktiverar signering med parametrar från miljövariabler. Detta gör det möjligt att signera AAB-filer före uppladdning till Google Play Console.

För säker lagring av Keystore i CI/CD, använd Base64-kodning och miljövariabler. Fastlane stöder action setup_keystore som avkodar Keystore från variabeln och sparar i en temporär fil i before_all-steget. Efter lane-slutförande raderas den temporära filen automatiskt för att förhindra läckage av certifikat.

Använda private lanes och grupper

Private lanes (privata scenarier) är lanes som inte kan anropas direkt från kommandoraden men är tillgängliga för anrop från andra lanes inuti Fastfile. Private lane deklareras med konstruktionen private_lane :namn do ... end och används för att kapsla in repeterande steg som inte är meningsfulla som fristående scenarier.

Private lanes är idealiska för gruppering av repeterande logik: installation av beroenden, miljökonfiguration, skicka notifieringar. Till exempel kan ett private lane :setup_signing skapas som anropas från flera distributions-lanes men inte bör vara tillgängligt för direkt start av utvecklaren för att undvika fel.

# Private lane och gruppering
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

Gruppering av lanes via platform-block gör det möjligt att separera scenarier för iOS och Android i en Fastfile. Konstruktionen platform :ios do ... end och platform :android do ... end isolerar lanes för respektive plattform, medan gemensamma private lanes kan placeras utanför plattformsblocken för återanvändning.

Överföra parametrar till lanes

Mekanismen för parametrar i Fastfile gör lanes flexibla och återanvändbara. Parametrar överförs vid start via kommandoraden: fastlane build scheme:App export_method:appstore. Inuti lane är värdena tillgängliga via options-hashen som skickas till lane-blocket som argument.

Fastlane stöder typsäkra parametrar med validering via OptionalHash. Man kan ställa in värdetyp (String, Boolean, Integer), standardvärde och beskrivning för automatisk generering av dokumentation. Även miljövariabler finns tillgängliga som ett alternativt sätt att överföra parametrar, vilket är praktiskt för CI/CD-system.

# Parametrar med typvalidering
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: "Bygg #{options[:scheme]} slutförd")
end

# Körning: fastlane build scheme:MyApp export_method:appstore

Det rekommenderas att använda standardvärden för alla valfria parametrar så att lane kan köras utan att varje argument anges explicit. För obligatoriska parametrar, kontrollera förekomsten av värdet i början av lane och avbryt körningen med ett tydligt felmeddelande via UI.user_error!.