Fastfile: Wesen, Struktur und Einrichtung der Automatisierung in der mobilen Entwicklung

Was ist Fastfile und warum wird es benötigt

Fastfile ist die Hauptkonfigurationsdatei von Fastlane, geschrieben in Ruby und platziert im Verzeichnis fastlane im Projektstamm. Sie definiert alle Automatisierungsszenarien (Lanes) zum Erstellen, Testen, Codesignieren und Ausliefern der Anwendung. Fastfile ersetzt Dutzende von Bash-Skripten, Makefiles und manuelle Anweisungen durch eine einzige deklarative CI/CD-Pipeline-Beschreibung.

Die Notwendigkeit für Fastfile entsteht, wenn ein Projekt wiederholbare Builds auf verschiedenen Entwicklermaschinen und CI/CD-Servern erfordert. Anstatt dass jeder Entwickler die Umgebung manuell einrichtet, erfasst Fastfile alle Schritte in Code, der in Git versioniert, überprüft und zwischen Projekten wiederverwendet werden kann. Eine einzelne Fastfile stellt sicher, dass der Build auf dem Entwicklerrechner mit dem Build auf dem CI/CD-Server identisch ist.

Fastfile unterstützt Plattformen über die default_platform-Direktive. In einer Fastfile können Szenarien für iOS, Android und macOS beschrieben werden, gruppiert in Blöcke platform :ios und platform :android. Dies ist besonders nützlich für plattformübergreifende Projekte, bei denen iOS- und Android-Builds eine gemeinsame Bereitstellungslogik haben, aber unterschiedliche Build-Tools verwenden.

Fastfile-Struktur: Lanes, Actions und Parameter

Fastfile besteht aus drei Hauptelementen: Plattformdeklaration (default_platform), Lanes-Definitionen und Konfiguration von Hilfsfunktionen. Jede Lane beginnt mit dem Schlüsselwort lane, gefolgt vom Szenarionamen (Ruby-Symbol), dem Rumpf mit einer Aktionssequenz und Fehlerbehandlungsblöcken: error, success oder ensure.

Actions in Fastfile sind Aufrufe integrierter Fastlane-Funktionen mit Parametern als Hash. Beispielsweise startet gym(scheme: 'App', export_method: 'app-store') einen iOS-App-Build mit den angegebenen Parametern. Jede Action gibt ein Ergebnis zurück, das in einer Variable gespeichert und in nachfolgenden Actions verwendet werden kann — dies ermöglicht bedingte Logik innerhalb einer Lane.

Fastfile unterstützt Umgebungsvariablen über den standardmäßigen ENV-Mechanismus von Ruby. Sensible Daten (Passwörter, Tokens, Schlüssel) sollten nicht in Fastfile gespeichert werden — verwenden Sie Umgebungsvariablen des CI/CD-Systems oder eine .env-Datei, die zu .gitignore hinzugefügt wurde. Fastlane lädt beim Start automatisch .env-Dateien aus dem fastlane-Verzeichnis.

Appfile und Matchfile

Zusammen mit Fastfile befinden sich im fastlane-Verzeichnis zusätzliche Konfigurationsdateien. Appfile enthält Anwendungsidentifikatoren (app_identifier), Apple ID und Team ID — diese Daten werden automatisch in alle Actions eingesetzt und vermeiden Wiederholungen in jeder Lane. Matchfile speichert Einstellungen für match: die Git-Repository-URL, den Profiltyp und den Verschlüsselungsschlüssel.

Die Aufteilung der Konfiguration auf mehrere Dateien vereinfacht die Wartung von Projekten mit unterschiedlichen Umgebungen. Beispielsweise können für Staging und Production separate Branches im Matchfile-Repository erstellt oder Parameter über Umgebungsvariablen im CI/CD-System überschrieben werden.

# Grundlegende Fastfile-Struktur
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

Fastfile-Syntax: Lanes schreiben

Die Fastfile-Syntax basiert auf Ruby DSL (Domain Specific Language), die speziell für die Lesbarkeit von Automatisierungsszenarien entwickelt wurde. Eine Lane wird durch die Konstruktion lane :name do ... end deklariert, wobei name ein Ruby-Symbol ist, das zum Befehl fastlane name für die Ausführung über das Terminal oder CI/CD-System wird.

Innerhalb einer Lane können bedingte Ruby-Operatoren verwendet werden: if, unless, case zur Verzweigung der Logik. Für die Verarbeitung von Arrays stehen die Schleifen each und while zur Verfügung. Fastlane bietet spezielle Methoden before_all, after_all und error-Blöcke zur Behandlung von Lane-Lebenszyklus-Ereignissen.

Lane-Parameter werden über den Options-Hash übergeben. Beim Ausführen von fastlane build --option_name value gelangt der Wert in options[:option_name] innerhalb der Lane. Über optional: true und Typvalidierung können Standardwerte festgelegt und die Typen der übergebenen Parameter gesteuert werden.

# Lane mit Parametern und bedingter Logik
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

Fastfile-Beispiel für iOS-Auslieferung

Eine vollständige Fastfile für ein iOS-Projekt enthält Lanes für die Abhängigkeitsinstallation, das Testen, das Erstellen und die Bereitstellung in TestFlight und im App Store. Betrachten wir ein Beispiel, das einen typischen CI/CD-Prozess vom Commit bis zur Veröffentlichung in TestFlight für interne Tests abdeckt.

# Fastfile für iOS CI/CD-Auslieferung
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 für interne Tests in TestFlight hochgeladen'
  )
end

In diesem Beispiel wird der before_all-Block vor jeder Lane ausgeführt und installiert Abhängigkeiten. Die Lane tests führt UI- und Unit-Tests auf zwei Geräten durch. Die Lane build_appstore signiert Code über match und erstellt das IPA mit Bitcode. Die Lane deploy_testflight kombiniert alle Schritte für die vollständige Auslieferung.

Bereitstellung mit mehreren Zielen

Projekte mit mehreren Zielen (Haupt-App, watchOS, Widget, Notification Service Extension) benötigen separate Lanes für jedes Ziel. In Fastfile kann eine universelle Lane :deploy_target erstellt werden, die den Schemanamen und den Build-Pfad als Parameter akzeptiert. Dies ermöglicht die Bereitstellung für alle Erweiterungen über fastlane deploy_target scheme:Widget.

Um mehrere Ziele zu organisieren, verwenden Sie ein Array von Schemata und eine each-Schleife innerhalb der Lane. Fastlane unterstützt paralleles Erstellen mehrerer Schemata über das Flag parallel: true, was die gesamte CI/CD-Pipeline-Zeit für Apps mit Erweiterungen reduziert.

Fastfile-Beispiel für Android-Build

Die Fastfile für Android-Projekte verwendet die gradle-Action zum Ausführen von Gradle-Aufgaben und die supply-Action zum Veröffentlichen im Google Play Store. Im Gegensatz zu iOS benötigt Android kein match, verwendet aber einen Keystore zum Signieren, der außerhalb des Repositorys gespeichert und über Umgebungsvariablen übergeben wird.

# Fastfile für 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

Für das Android-Signieren konfigurieren Sie signingConfigs in build.gradle und übergeben die Keystore-Parameter über Umgebungsvariablen: ANDROID_KEYSTORE_PATH, ANDROID_KEYSTORE_PASSWORD, ANDROID_KEY_ALIAS und ANDROID_KEY_PASSWORD. Fastlane verwendet automatisch den systemeigenen apksigner zum Signieren der erstellten AAB oder APK.

Android-Signierung in Fastfile

Um die Android-Signierung in Fastfile zu konfigurieren, verwenden Sie die sign_android-Action oder verlassen Sie sich auf signingConfigs in build.gradle. Fastlane integriert sich über Gradle mit apksigner — das Übergeben des Flags SIGNING_CONFIG in der Gradle-Aufgabe aktiviert die Signierung mit Parametern aus Umgebungsvariablen. Dies ermöglicht das Signieren von AAB-Dateien vor dem Hochladen in die Google Play Console.

Für die sichere Keystore-Speicherung in CI/CD verwenden Sie Base64-Kodierung und Umgebungsvariablen. Fastlane unterstützt die setup_keystore-Action, die den Keystore aus einer Variable dekodiert und während der before_all-Phase in einer temporären Datei speichert. Nach Abschluss der Lane wird die temporäre Datei automatisch gelöscht, um ein Auslaufen von Zertifikaten zu verhindern.

Verwendung von Private Lanes und Gruppen

Private Lanes sind Lanes, die nicht direkt von der Befehlszeile aus aufgerufen werden können, aber von anderen Lanes innerhalb der Fastfile aufrufbar sind. Eine private Lane wird durch die Konstruktion private_lane :name do ... end deklariert und dient der Kapselung wiederkehrender Schritte, die als eigenständige Szenarien keinen Sinn ergeben.

Private Lanes eignen sich ideal zum Gruppieren wiederkehrender Logik: Abhängigkeitsinstallation, Umgebungseinrichtung, Senden von Benachrichtigungen. Beispielsweise kann eine private Lane :setup_signing erstellt werden, die von mehreren Bereitstellungs-Lanes aufgerufen wird, aber für die direkte Ausführung durch Entwickler nicht verfügbar sein sollte, um Fehler zu vermeiden.

# Private Lane und Gruppierung
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

Die Gruppierung von Lanes über platform-Blöcke ermöglicht die Trennung von iOS- und Android-Szenarien in einer Fastfile. Die Konstruktion platform :ios do ... end und platform :android do ... end isoliert die Lanes der entsprechenden Plattform, während gemeinsame private Lanes zur Wiederverwendung außerhalb der Plattformblöcke platziert werden können.

Parameterübergabe an Lanes

Der Parameter-Mechanismus von Fastfile ermöglicht es, Lanes flexibel und wiederverwendbar zu machen. Parameter werden zur Laufzeit über die Befehlszeile übergeben: fastlane build scheme:App export_method:appstore. Innerhalb der Lane sind die Werte über den options-Hash zugänglich, der dem Lane-Block als Argument übergeben wird.

Fastlane unterstützt typisierte Parameter mit Validierung über OptionalHash. Sie können den Werttyp (String, Boolean, Integer), einen Standardwert und eine Beschreibung zur automatischen Dokumentationsgenerierung angeben. Umgebungsvariablen stehen ebenfalls als alternative Möglichkeit zur Parameterübergabe zur Verfügung, was für CI/CD-Systeme praktisch ist.

# Parameter mit Typvalidierung
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]} abgeschlossen")
end

# Ausführung: fastlane build scheme:MyApp export_method:appstore

Es wird empfohlen, Standardwerte für alle optionalen Parameter zu verwenden, damit eine Lane ausgeführt werden kann, ohne jedes Argument explizit angeben zu müssen. Für erforderliche Parameter überprüfen Sie deren Vorhandensein zu Beginn der Lane und brechen Sie die Ausführung mit einer klaren Fehlermeldung über UI.user_error! ab.