Fastfile : essence, structure et configuration de l'automatisation dans le développement mobile

Qu'est-ce que Fastfile et pourquoi en avez-vous besoin

Fastfile est le fichier de configuration principal de Fastlane, écrit en Ruby et placé dans le répertoire fastlane à la racine du projet. Il définit tous les scénarios d'automatisation (lanes) pour compiler, tester, signer le code et livrer l'application. Fastfile remplace des dizaines de scripts bash, Makefiles et instructions manuelles par une seule description déclarative de pipeline CI/CD.

Le besoin de Fastfile surgit lorsqu'un projet nécessite des compilations reproductibles sur différentes machines de développeurs et serveurs CI/CD. Au lieu que chaque développeur configure manuellement l'environnement, Fastfile capture toutes les étapes dans un code qui peut être versionné dans Git, révisé et réutilisé entre projets. Un seul Fastfile garantit que la compilation sur la machine du développeur est identique à celle sur le serveur CI/CD.

Fastfile prend en charge les plateformes via la directive default_platform. Dans un seul Fastfile, il est possible de décrire des scénarios pour iOS, Android et macOS, en les regroupant dans des blocs platform :ios et platform :android. C'est particulièrement utile pour les projets multiplateformes où les compilations iOS et Android partagent une logique de déploiement commune mais utilisent des outils de compilation différents.

Structure de Fastfile : lanes, actions et paramètres

Fastfile se compose de trois éléments principaux : la déclaration de plateforme (default_platform), la définition des lanes et la configuration des fonctions auxiliaires. Chaque lane commence par le mot-clé lane, suivi du nom du scénario (symbole Ruby), du corps avec une séquence d'actions et des blocs de gestion des erreurs : error, success ou ensure.

Les actions dans Fastfile sont des appels aux fonctions intégrées de Fastlane avec des paramètres sous forme de Hash. Par exemple, gym(scheme: 'App', export_method: 'app-store') lance une compilation iOS avec les paramètres spécifiés. Chaque action retourne un résultat qui peut être stocké dans une variable et utilisé dans les actions suivantes — cela permet une logique conditionnelle à l'intérieur d'une lane.

Fastfile prend en charge les variables d'environnement via le mécanisme standard ENV de Ruby. Les données sensibles (mots de passe, jetons, clés) ne doivent pas être stockées dans Fastfile — utilisez les variables d'environnement du système CI/CD ou un fichier .env ajouté à .gitignore. Fastlane charge automatiquement les fichiers .env du répertoire fastlane au démarrage.

Appfile et Matchfile

En plus de Fastfile, le répertoire fastlane contient des fichiers de configuration supplémentaires. Appfile contient les identifiants de l'application (app_identifier), l'Apple ID et le Team ID — ces données sont automatiquement substituées dans toutes les actions, éliminant les répétitions dans chaque lane. Matchfile stocke les paramètres de match : l'URL du référentiel Git, le type de profils et la clé de chiffrement.

Diviser la configuration en plusieurs fichiers simplifie la maintenance des projets avec différents environnements. Par exemple, pour le staging et la production, vous pouvez créer des branches séparées dans le dépôt Matchfile ou remplacer les paramètres via des variables d'environnement dans le système CI/CD.

# Structure de base de 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

Syntaxe de Fastfile : écrire des lanes

La syntaxe de Fastfile est basée sur Ruby DSL (Domain Specific Language), spécialement conçue pour la lisibilité des scénarios d'automatisation. Une lane est déclarée via la construction lane :name do ... end, où name est un symbole Ruby qui devient la commande fastlane name pour l'exécution depuis le terminal ou le système CI/CD.

À l'intérieur d'une lane, vous pouvez utiliser des opérateurs conditionnels Ruby : if, unless, case pour ramifier la logique. Les boucles each et while sont également disponibles pour traiter des tableaux de valeurs. Fastlane fournit des méthodes spéciales before_all, after_all et des blocs error pour gérer les événements du cycle de vie de la lane.

Les paramètres de lane sont passés via le hash options. Lors de l'exécution de fastlane build --option_name value, la valeur va dans options[:option_name] à l'intérieur de la lane. Vous pouvez définir des valeurs par défaut via optional: true et une validation de type pour contrôler les types des paramètres passés.

# Lane avec paramètres et logique conditionnelle
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

Exemple de Fastfile pour la livraison iOS

Un Fastfile complet pour un projet iOS comprend des lanes pour l'installation des dépendances, les tests, la compilation et le déploiement sur TestFlight et l'App Store. Regardons un exemple qui couvre un processus CI/CD typique du commit à la publication sur TestFlight pour les tests internes.

# Fastfile pour la livraison CI/CD iOS
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: 'Compilation téléchargée sur TestFlight pour les tests internes'
  )
end

Dans cet exemple, le bloc before_all s'exécute avant chaque lane et installe les dépendances. La lane tests exécute des tests UI et Unit sur deux appareils. La lane build_appstore signe le code via match et compile l'IPA avec bitcode. La lane deploy_testflight combine toutes les étapes pour la livraison complète.

Déploiement avec plusieurs cibles

Les projets avec plusieurs cibles (application principale, watchOS, widget, Notification Service Extension) nécessitent des lanes séparées pour chaque cible. Dans Fastfile, vous pouvez créer une lane universelle :deploy_target qui accepte le nom du schéma et le chemin de compilation comme paramètres. Cela permet d'exécuter le déploiement pour toutes les extensions via fastlane deploy_target scheme:Widget.

Pour organiser plusieurs cibles, utilisez un tableau de schémas et une boucle each à l'intérieur de la lane. Fastlane prend en charge la compilation parallèle de plusieurs schémas via le flag parallel: true, ce qui réduit le temps total du pipeline CI/CD pour les applications avec extensions.

Exemple de Fastfile pour la compilation Android

Le Fastfile pour les projets Android utilise l'action gradle pour exécuter des tâches Gradle et l'action supply pour publier sur Google Play. Contrairement à iOS, Android n'a pas besoin de match, mais utilise un Keystore pour la signature, qui est stocké en dehors du dépôt et passé via des variables d'environnement.

# Fastfile pour la compilation CI/CD Android
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

Pour la signature Android, configurez signingConfigs dans build.gradle et passez les paramètres du Keystore via des variables d'environnement : ANDROID_KEYSTORE_PATH, ANDROID_KEYSTORE_PASSWORD, ANDROID_KEY_ALIAS et ANDROID_KEY_PASSWORD. Fastlane utilise automatiquement l'apksigner système pour signer l'AAB ou l'APK compilé.

Signature Android dans Fastfile

Pour configurer la signature Android dans Fastfile, utilisez l'action sign_android ou fiez-vous à signingConfigs dans build.gradle. Fastlane s'intègre avec apksigner via Gradle — passer le flag SIGNING_CONFIG dans la tâche gradle active la signature avec les paramètres des variables d'environnement. Cela permet de signer les fichiers AAB avant de les télécharger sur Google Play Console.

Pour un stockage sécurisé du Keystore en CI/CD, utilisez l'encodage Base64 et des variables d'environnement. Fastlane prend en charge l'action setup_keystore, qui décode le Keystore à partir d'une variable et le sauvegarde dans un fichier temporaire pendant l'étape before_all. Après la fin de la lane, le fichier temporaire est automatiquement supprimé pour éviter les fuites de certificats.

Utilisation des private lanes et des groupes

Les private lanes (scénarios privés) sont des lanes qui ne peuvent pas être appelées directement depuis la ligne de commande, mais qui sont disponibles pour être appelées depuis d'autres lanes à l'intérieur de Fastfile. Une private lane est déclarée via la construction private_lane :name do ... end et est utilisée pour encapsuler des étapes répétitives qui n'ont pas de sens en tant que scénarios indépendants.

Les private lanes sont idéales pour regrouper la logique répétitive : installation des dépendances, configuration de l'environnement, envoi de notifications. Par exemple, vous pouvez créer une private lane :setup_signing qui est appelée depuis plusieurs lanes de déploiement, mais qui ne devrait pas être disponible pour une exécution directe par le développeur afin d'éviter des erreurs.

# Private lane et regroupement
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

Le regroupement de lanes via des blocs platform permet de séparer les scénarios iOS et Android dans un même Fastfile. La construction platform :ios do ... end et platform :android do ... end isole les lanes de la plateforme correspondante, tandis que les private lanes communes peuvent être placées en dehors des blocs de plateforme pour être réutilisées.

Passage de paramètres aux lanes

Le mécanisme de paramètres de Fastfile permet de rendre les lanes flexibles et réutilisables. Les paramètres sont passés au moment de l'exécution via la ligne de commande : fastlane build scheme:App export_method:appstore. À l'intérieur de la lane, les valeurs sont accessibles via le hash options, qui est passé au bloc de la lane comme argument.

Fastlane prend en charge les paramètres typés avec validation via OptionalHash. Vous pouvez spécifier le type de valeur (String, Boolean, Integer), une valeur par défaut et une description pour la génération automatique de documentation. Les variables d'environnement sont également disponibles comme moyen alternatif de passer des paramètres, ce qui est pratique pour les systèmes CI/CD.

# Paramètres avec validation de type
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]} terminé")
end

# Exécution : fastlane build scheme:MyApp export_method:appstore

Il est recommandé d'utiliser des valeurs par défaut pour tous les paramètres optionnels, afin qu'une lane puisse être exécutée sans spécifier explicitement chaque argument. Pour les paramètres obligatoires, vérifiez leur présence au début de la lane et interrompez l'exécution avec un message d'erreur clair via UI.user_error!.