Fastfile: essentie, structuur en het instellen van automatisering in mobiele ontwikkeling

Wat is Fastfile en waarom is het nodig

Fastfile — is het belangrijkste Fastlane-configuratiebestand, geschreven in Ruby en geplaatst in de fastlane-directory in de projectroot. Het definieert alle automatiseringsscenario’s (lanes) voor het bouwen, testen, ondertekenen van code en leveren van de applicatie. Fastfile vervangt tientallen bash-scripts, Makefile en handmatige instructies met een enkele declaratieve beschrijving van de CI/CD-pipeline.

De noodzaak voor Fastfile ontstaat wanneer een project herhaalbare builds vereist op verschillende ontwikkelaarsmachines en CI/CD-servers. In plaats van dat elke ontwikkelaar handmatig de omgeving configureert, legt Fastfile alle stappen vast in code die in Git kan worden geversioneerd, beoordeeld en hergebruikt tussen projecten. Eén Fastfile garandeert dat de build op de ontwikkelaarsmachine identiek is aan de build op de CI/CD-server.

Fastfile ondersteunt platforms via de default_platform-richtlijn. In één Fastfile kunnen scenario’s voor iOS, Android en macOS worden beschreven, gegroepeerd in platform :ios en platform :android blokken. Dit is bijzonder handig voor cross-platform projecten waarbij iOS- en Android-builds dezelfde implementatielogica hebben maar verschillende bouwtools.

Structuur van Fastfile: lanes, actions en parameters

Fastfile bestaat uit drie hoofdelementen: platformdeclaratie (default_platform), definitie van lanes en configuratie van hulpfuncties. Elke lane begint met het trefwoord lane, gevolgd door de scenarionaam (Ruby-symbool), de body met een reeks actions en foutafhandelingsblokken error, success of ensure.

Actions in Fastfile — zijn aanroepen van ingebouwde Fastlane-functies met parameters in de vorm van een Hash. Bijvoorbeeld gym(scheme: 'App', export_method: 'app-store') start de build van een iOS-applicatie met de opgegeven parameters. Elke action retourneert een resultaat dat in een variabele kan worden opgeslagen en in volgende actions kan worden gebruikt — dit maakt het mogelijk om voorwaardelijke logica binnen een lane te bouwen.

Fastfile ondersteunt omgevingsvariabelen via het standaard ENV-mechanisme in Ruby. Gevoelige gegevens (wachtwoorden, tokens, sleutels) mogen niet in Fastfile worden opgeslagen — gebruik omgevingsvariabelen van het CI/CD-systeem of een .env-bestand dat aan .gitignore is toegevoegd. Fastlane laadt automatisch .env-bestanden uit de fastlane-directory bij het opstarten.

Appfile en Matchfile

Samen met Fastfile bevinden zich in de fastlane-directory aanvullende configuratiebestanden. Appfile bevat de applicatie-identificatoren (app_identifier), Apple ID en Team ID — deze gegevens worden automatisch ingevuld in alle actions, waardoor herhaling in elke lane wordt vermeden. Matchfile slaat instellingen op voor match: Git-repository-URL, profieltypen en coderingssleutel.

Het verdelen van de configuratie over meerdere bestanden vereenvoudigt het onderhoud van projecten met verschillende omgevingen. Voor staging en production kunnen bijvoorbeeld aparte takken in de Matchfile-repository worden gemaakt of parameters worden overschreven via omgevingsvariabelen in het CI/CD-systeem.

# Basisstructuur van 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 van Fastfile: lanes schrijven

De syntax van Fastfile is gebaseerd op Ruby DSL (Domain Specific Language), speciaal ontworpen voor de leesbaarheid van automatiseringsscenario’s. Een lane wordt gedeclareerd via de constructie lane :name do ... end, waarbij name een Ruby-symbool is dat het commando fastlane name wordt voor uitvoering vanuit de terminal of een CI/CD-systeem.

Binnen een lane kunnen conditionele operatoren van Ruby worden gebruikt: if, unless, case voor logische vertakking. Ook zijn each- en while-lussen beschikbaar voor het verwerken van waardearrays. Fastlane biedt speciale methoden before_all, after_all en error-blokken voor het afhandelen van gebeurtenissen in de levenscyclus van een lane.

Lane-parameters worden doorgegeven via de options-hash. Bij uitvoering van fastlane build --option_name value komt de waarde terecht in options[:option_name] binnen de lane. Standaardwaarden kunnen worden ingesteld via optional: true en type-validatie voor controle van de doorgegeven parametertypes.

# Lane met parameters en voorwaardelijke logica
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

Voorbeeld Fastfile voor iOS-levering

Een volledige Fastfile voor een iOS-project bevat lanes voor het installeren van afhankelijkheden, testen, bouwen en implementeren naar TestFlight en de App Store. Laten we een voorbeeld bekijken dat het typische CI/CD-proces van commit tot publicatie in TestFlight voor intern testen behandelt.

# Fastfile voor iOS CI/CD-levering
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 geüpload naar TestFlight voor intern testen'
  )
end

In dit voorbeeld wordt het before_all-blok uitgevoerd vóór elke lane en installeert het afhankelijkheden. Lane tests start UI- en unittesten op twee apparaten. Lane build_appstore ondertekent de code via match en bouwt een IPA met bitcode. Lane deploy_testflight combineert alle stappen voor volledige levering.

Implementeren met meerdere targets

Projecten met meerdere targets (hoofdapplicatie, watchOS, widget, Notification Service Extension) vereisen aparte lanes voor elk target. In Fastfile kan een universele lane :deploy_target worden gemaakt die de schemanaam en het buildpad als parameter accepteert. Dit maakt het mogelijk om implementatie voor alle extensies uit te voeren via fastlane deploy_target scheme:Widget.

Gebruik voor het organiseren van meerdere targets een array van schema’s en een each-lus binnen de lane. Fastlane ondersteunt parallel bouwen van meerdere schema’s via de vlag parallel: true, wat de totale CI/CD-pipelinetime verkort voor applicaties met extensies.

Voorbeeld Fastfile voor Android-build

Fastfile voor een Android-project gebruikt gradle action voor het uitvoeren van Gradle-taken en supply action voor publicatie in Google Play. In tegenstelling tot iOS heeft Android geen match nodig, maar gebruikt het Keystore voor ondertekening, dat buiten de repository wordt opgeslagen en via omgevingsvariabelen wordt doorgegeven.

# Fastfile voor 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

Voor Android-ondertekening van de applicatie configureert u signingConfigs in build.gradle en geeft u Keystore-parameters door via omgevingsvariabelen: ANDROID_KEYSTORE_PATH, ANDROID_KEYSTORE_PASSWORD, ANDROID_KEY_ALIAS en ANDROID_KEY_PASSWORD. Fastlane gebruikt automatisch de systeem-apksigner voor het ondertekenen van de gebouwde AAB of APK.

Android-ondertekening in Fastfile

Gebruik voor het configureren van Android-ondertekening in Fastfile de action sign_android of vertrouw op signingConfigs in build.gradle. Fastlane integreert met apksigner via Gradle — het doorgeven van de SIGNING_CONFIG-vlag in gradle task activeert ondertekening met parameters uit omgevingsvariabelen. Dit maakt het ondertekenen van AAB-bestanden mogelijk voordat ze naar Google Play Console worden geüpload.

Gebruik voor veilige opslag van Keystore in CI/CD Base64-codering en omgevingsvariabelen. Fastlane ondersteunt de action setup_keystore, die Keystore uit een variabele decodeert en opslaat in een tijdelijk bestand in de before_all-fase. Na voltooiing van de lane wordt het tijdelijke bestand automatisch verwijderd om certificaatlekkage te voorkomen.

Private lanes en groepen gebruiken

Private lanes (privéscenario’s) — zijn lanes die niet direct vanaf de commandoregel kunnen worden aangeroepen, maar wel beschikbaar zijn voor aanroep vanuit andere lanes binnen Fastfile. Een private lane wordt gedeclareerd via de constructie private_lane :name do ... end en wordt gebruikt voor het inkapselen van herhaalde stappen die geen betekenis hebben als zelfstandige scenario’s.

Private lanes zijn ideaal voor het groeperen van herhaalde logica: installatie van afhankelijkheden, omgevingsconfiguratie, verzenden van meldingen. U kunt bijvoorbeeld een private lane :setup_signing maken die vanuit meerdere implementatie-lanes wordt aangeroepen, maar niet beschikbaar mag zijn voor directe uitvoering door de ontwikkelaar om fouten te voorkomen.

# Private lane en groepering
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

Groeperen van lanes via platformblokken maakt het mogelijk om scenario’s voor iOS en Android te scheiden in één Fastfile. De constructie platform :ios do ... end en platform :android do ... end isoleert lanes van het betreffende platform, en gemeenschappelijke private lanes kunnen buiten de platformblokken worden geplaatst voor hergebruik.

Parameters doorgeven aan lanes

Het parameter-mechanisme van Fastfile maakt lanes flexibel en herbruikbaar. Parameters worden bij uitvoering via de commandoregel doorgegeven: fastlane build scheme:App export_method:appstore. Binnen de lane zijn waarden beschikbaar via de options-hash die als argument aan het lane-blok wordt doorgegeven.

Fastlane ondersteunt getypeerde parameters met validatie via OptionalHash. U kunt het waardetype (String, Boolean, Integer), standaardwaarde en beschrijving instellen voor automatische documentatiegeneratie. Ook zijn omgevingsvariabelen beschikbaar als alternatieve manier om parameters door te geven, wat handig is voor CI/CD-systemen.

# Parameters met typevalidatie
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: "Build #{options[:scheme]} is voltooid")
end

# Uitvoering: fastlane build scheme:MyApp export_method:appstore

Het wordt aanbevolen om standaardwaarden te gebruiken voor alle optionele parameters, zodat een lane kan worden uitgevoerd zonder expliciet elk argument op te geven. Controleer voor verplichte parameters de aanwezigheid van de waarde aan het begin van de lane en onderbreek de uitvoering met een duidelijke foutmelding via UI.user_error!.