Lane — was es ist, Erstellung und Verwendung in Fastlane

Was ist eine Lane in Fastlane

Lane ist der grundlegende Baustein von Fastlane, der ein benanntes Automatisierungsskript definiert. Jede Lane beschreibt eine Sequenz von Aktionen, die ausgeführt werden, um ein bestimmtes Ziel zu erreichen: eine Anwendung bauen, Tests ausführen, einen Build in den Store hochladen oder eine Umgebung einrichten. Eine Lane wird in der Fastdatei deklariert und mit dem Befehl fastlane [Lane_Name] vom Projektstamm aus gestartet.

Das Lane-Konzept ist von Ruby DSL übernommen und gewährleistet die Lesbarkeit der Skripte. Der Entwickler sieht den gesamten CI/CD-Prozess als eine Sequenz von Aktionsaufrufen mit klaren Namen und Parametern. Eine Lane kann einfach (ein Befehl) oder komplex (Verzweigungen, Schleifen, Aufrufe anderer Lanes) sein.

Nach der Ausführung gibt jede Lane ein Ergebnis zurück — ein Objekt mit dem Ausführungsstatus und den Daten der Aktionen. Das Ergebnis kann in anderen Lanes verwendet oder an das CI/CD-System zur Entscheidungsfindung übergeben werden. Wenn eine Aktion in der Lane fehlschlägt, wird die Ausführung der Lane gestoppt und der Error-Block aufgerufen.

Lane-Syntax: Deklaration und Ausführung

Die Deklarationssyntax einer Lane folgt einem einfachen Ruby DSL-Muster: das Schlüsselwort lane, der Skriptname als Ruby-Symbol und ein do ... end-Block mit dem Skriptrumpf. Der Lane-Name muss innerhalb der Plattform eindeutig sein und aus Buchstaben, Ziffern und Unterstrichen bestehen.

Eine Lane wird über die Befehlszeile ausgeführt: fastlane build (für eine Lane namens :build) oder bundle exec fastlane build (wenn Fastlane über Bundler installiert ist). Für plattformspezifische Lanes verwenden Sie fastlane ios build oder fastlane android build.

# Deklaration einer einfachen Lane
lane :test do
  scan(scheme: 'App', devices: ['iPhone 15'])
end

lane :build_and_deploy do
  cocoapods
  test
  gym(scheme: 'App', export_method: 'app-store')
  pilot(skip_waiting_for_build_processing: true)
end

# Ausführen: fastlane build_and_deploy

Eine Lane kann bedingte Logik basierend auf Parametern oder Umgebungsvariablen enthalten. Verwenden Sie if/unless, um Schritte unter bestimmten Bedingungen zu überspringen. Schleifen (each) sind ebenfalls verfügbar, um Arrays zu verarbeiten, was zum Bauen mehrerer Ziele oder App-Schemata in einer einzigen Lane praktisch ist.

Rückgabe eines Werts aus einer Lane

Eine Lane kann einen Wert zurückgeben, der dem aufrufenden Code zur Verfügung steht. Verwenden Sie für die Rückgabe ein standardmäßiges Ruby return oder den letzten Ausdruck im Lane-Block. Der Rückgabewert kann ein String, eine Zahl, ein Hash oder das Ergebnis einer Aktion sein. Dies ermöglicht die Verwendung des Ergebnisses einer Lane in einer anderen Lane zur Entscheidungsfindung.

Zum Beispiel kann eine :get_version-Lane die aktuelle App-Version aus Info.plist zurückgeben, und die :deploy-Lane kann sie verwenden, um eine Slack-Nachricht zu erstellen. Rückgabewerte sind besonders nützlich in privaten Lanes, wo das Ergebnis für die weitere Verarbeitung in der aufrufenden Lane benötigt wird.

Lane-Parameter: Übergabe und Verarbeitung

Lane-Parameter machen Skripte flexibel und wiederverwendbar. Eine Lane akzeptiert Parameter über den Options-Hash, der beim Ausführen von der Befehlszeile übergeben wird: fastlane deploy scheme:AppStore version:2.1.0. Innerhalb der Lane sind die Parameter als options[:scheme] und options[:version] verfügbar.

Für erforderliche Parameter überprüfen Sie das Vorhandensein des Werts am Anfang der Lane und rufen UI.user_error! mit einer klaren Nachricht auf. Für optionale Parameter legen Sie Standardwerte mit dem ||-Operator fest. Fastlane unterstützt auch typisierte Parameter über die options-Methode mit Typ, Standardwert und Beschreibung.

# Lane mit Parameterbehandlung
lane :deploy do |options|
  scheme = options[:scheme]
  version = options[:version] || '1.0.0'
  beta = options[:beta] || false

  UI.user_error!("scheme nicht angegeben") unless scheme

  match(type: beta ? 'adhoc' : 'appstore')
  gym(scheme: scheme, export_method: beta ? 'ad-hoc' : 'app-store')

  if beta
    pilot(distribute_external: true)
  else
    deliver(submit_for_review: true)
  end
end

# Ausführen: fastlane deploy scheme:MyApp beta:true version:2.1.0

Um mit Umgebungsvariablen innerhalb einer Lane zu arbeiten, verwenden Sie ENV['VARIABLE_NAME']. Fastlane lädt automatisch .env-Dateien aus dem fastlane-Verzeichnis. Dies ist der Standardweg, um sensible Daten — API-Schlüssel, Passwörter und Token — in einer CI/CD-Umgebung zu übergeben, ohne sie in der Fastdatei zu speichern.

Parametervalidierung

Für einen zuverlässigen Lane-Betrieb ist die Parametervalidierung bei der Eingabe erforderlich. Verwenden Sie UI.user_error! mit einer Problembeschreibung, wenn ein erforderlicher Parameter fehlt oder einen falschen Typ hat. Fastlane bietet die options-Methode, mit der Sie den Typ (String, Boolean, Integer, Array), den Standardwert und die Beschreibung für jeden Parameter angeben können — die Validierung erfolgt automatisch beim Starten der Lane.

Zusätzlich können Sie Prüfungen über einen verify-Block durchführen: verify do |value| value.length > 0 end für String-Parameter. Bei falschem Format gibt Fastlane eine klare Nachricht mit dem erwarteten Format und dem übergebenen Wert aus, was die Fehlersuche in einer CI/CD-Umgebung vereinfacht.

Kombination von Lanes: before_all, after_all und Fehlerbehandlung

Fastlane bietet Lebenszyklus-Hooks zur Ausführung von Code vor und nach jeder Lane. Der before_all-Block wird vor jeder Lane in einer bestimmten Plattform oder global ausgeführt. Der after_all-Block wird nach erfolgreichem Abschluss einer Lane ausgeführt. Der error-Block wird bei jedem Fehler innerhalb einer Lane ausgeführt.

Hooks ermöglichen die Zentralisierung wiederkehrender Logik: Abhängigkeitseinrichtung in before_all, Senden von Benachrichtigungen in after_all, Bereinigen temporärer Dateien und Fehlerbenachrichtigung im error-Block. Dies reduziert Code-Duplizierung und hält Lanes sauberer.

# Lebenszyklus-Hooks von Lanes
default_platform(:ios)

before_all do
  cocoapods(try_repo_update_on_error: true)
  ensure_git_status_clean
end

after_all do |lane|
  slack(message: "Lane #{lane} erfolgreich abgeschlossen")
end

error do |lane, exception|
  slack(
    message: "Lane #{lane} mit einem Fehler fehlgeschlagen: #{exception}",
    success: false
  )
end

lane :deploy do
  match(type: 'appstore')
  gym(export_method: 'app-store')
  deliver
end

Der error-Block empfängt zwei Argumente: den Namen der Lane (Symbol) und das Ausnahmeobjekt. Innerhalb des Blocks können Sie eine Slack-Benachrichtigung senden, ein Log in eine Datei schreiben oder ein alternatives Wiederherstellungsskript ausführen. Wenn der error-Block erfolgreich abgeschlossen wird, betrachtet Fastlane den Build auf CI/CD-Ebene nicht als fehlgeschlagen.

Private Lanes und Wiederverwendung

Eine Private Lane ist eine Lane, die mit private_lane statt lane deklariert wird, die nicht in der Liste der verfügbaren Befehle angezeigt wird und nicht direkt vom Terminal aus ausgeführt werden kann. Private Lanes dienen der Kapselung wiederkehrender Schritte, die von mehreren öffentlichen Lanes aufgerufen werden.

Private Lanes sind besonders nützlich für komplexe Sequenzen von Aktionen, die in einer streng definierten Reihenfolge ausgeführt werden müssen. Zum Beispiel kann eine private Lane :setup_signing von den Lanes :build_dev, :build_staging und :build_production mit unterschiedlichen Parametern aufgerufen werden, ergibt aber selbst als separater Befehl keinen Sinn.

# Private Lanes zur Wiederverwendung
private_lane :setup_environment do |options|
  cocoapods(try_repo_update_on_error: true)
  match(type: options[:type], readonly: true)
  increment_build_number
end

lane :dev_build do
  setup_environment(type: 'development')
  gym(export_method: 'development')
end

lane :appstore_build do
  setup_environment(type: 'appstore')
  gym(export_method: 'app-store')
  deliver
end

Private Lanes können andere private Lanes aufrufen und bilden eine Abstraktionshierarchie. Es wird empfohlen, die Verschachtelungstiefe auf 2–3 Ebenen zu begrenzen, um die Lesbarkeit der Fastdatei zu erhalten. Dokumentieren Sie jede private Lane mit einem Kommentar, der ihren Zweck und die erwarteten Parameter beschreibt.

Lane-Beispiele für iOS und Android

Betrachten wir praktische Beispiele von Lanes für iOS- und Android-Projekte. iOS-Lanes verwenden typischerweise scan für Tests, match für Zertifikate, gym für das Bauen und pilot oder deliver für die Verteilung. Android-Lanes verwenden gradle für das Bauen, supply für die Veröffentlichung und firebase_test_lab für Cloud-Tests.

// Lane für vollständiges CI/CD einer iOS-App
lane :ci_full_ios do
  scan(scheme: 'App', code_coverage: true)
  gym(scheme: 'App', export_method: 'app-store')
  pilot(distribute_external: true)
  slack(message: 'iOS CI/CD erfolgreich abgeschlossen')
end

/* Lane für vollständiges CI/CD einer Android-App */
lane :ci_full_android do
  gradle(task: 'testReleaseUnitTest')
  gradle(task: 'bundleRelease')
  supply(track: 'internal')
end

Durch die Kombination von Lanes für iOS und Android können Sie einen einheitlichen CI/CD-Prozess für eine plattformübergreifende Anwendung erstellen. Verwenden Sie die Plattformblöcke platform :ios und platform :android, um plattformspezifische Lanes zu gruppieren, und rufen Sie sie von einer gemeinsamen Orchestrator-Lane auf, die die Ausführungsreihenfolge verwaltet.

Beste Praktiken zum Schreiben von Lanes

Beim Schreiben von Lanes wird empfohlen, eine Reihe von Praktiken zu befolgen, die Lesbarkeit, Wartbarkeit und Zuverlässigkeit der Skripte gewährleisten. Die erste Regel ist, dass jede Lane eine Aufgabe erfüllen sollte. Wenn eine Lane zu viel tut, teilen Sie sie in mehrere Lanes und private Lanes auf.

Die zweite Regel ist, dass die Benennung von Lanes ein Verb oder eine Verbphrase sein sollte: build, deploy, test, upload_screenshots. Vermeiden Sie abstrakte Namen wie process oder do_all. Verwenden Sie Unterstriche zur Worttrennung im Lane-Namen.

Die dritte Regel ist, Fehler explizit zu behandeln. Verwenden Sie UI.user_error! für klare Problemnachrichten. Verlassen Sie sich nicht auf die Standard-Fehlermeldungen von Fastlane — geben Sie dem Entwickler Kontext: „GoogleService-Info.plist-Datei nicht gefunden — fügen Sie sie dem Projekt hinzu“ statt „Datei nicht gefunden“.

Die vierte Regel ist, Lanes lokal zu testen, bevor sie auf CI/CD ausgeführt werden. Fastlane unterstützt den Trockenlauf-Modus über das --dry-run-Flag, der anzeigt, welche Aktionen ausgeführt werden, ohne sie tatsächlich auszuführen. Verwenden Sie fastlane run_test zum isolierten Testen einzelner Lanes vor der Integration.

Dokumentation von Lanes

Die Dokumentation jeder Lane ist eine wichtige Praxis für die Teamarbeit. Fastlane unterstützt die automatische Dokumentationsgenerierung aus dem desc-Block, der vor der Lane-Deklaration platziert wird. Der desc-Text wird beim Ausführen von fastlane lanes und fastlane list angezeigt und hilft Entwicklern, den Zweck jedes Skripts zu verstehen, ohne den Quellcode der Fastdatei zu lesen.

Zur Dokumentation von Parametern verwenden Sie Ruby-Kommentare mit Beschreibungen der erwarteten Werte. Fastlane kann eine README.md mit der vollständigen Liste der Lanes und ihrer Beschreibungen über den Befehl fastlane generate_docs erstellen, was für das Onboarding neuer Teammitglieder in die CI/CD-Prozesse des Projekts praktisch ist.