Fastfile: esensi, struktur dan konfigurasi otomatisasi dalam pengembangan mobile

Apa itu Fastfile dan mengapa diperlukan

Fastfile — adalah file konfigurasi utama Fastlane, ditulis dalam bahasa Ruby dan ditempatkan di direktori fastlane di root proyek. File ini mendefinisikan semua skenario otomatisasi (lanes) untuk membangun, menguji, menandatangani kode, dan mengirimkan aplikasi. Fastfile menggantikan puluhan skrip bash, Makefile, dan instruksi manual dengan satu deskripsi deklaratif pipeline CI/CD.

Kebutuhan akan Fastfile muncul ketika proyek memerlukan pembangunan yang dapat diulang di berbagai mesin pengembang dan server CI/CD. Alih-alih setiap pengembang mengkonfigurasi lingkungan secara manual, Fastfile mencatat semua langkah dalam kode yang dapat di-versioning di Git, ditinjau, dan digunakan kembali antar proyek. Satu Fastfile menjamin bahwa pembangunan di mesin pengembang identik dengan pembangunan di server CI/CD.

Fastfile mendukung platform melalui direktif default_platform. Dalam satu Fastfile dapat dijelaskan skenario untuk iOS, Android, dan macOS, mengelompokkannya dalam blok platform :ios dan platform :android. Ini sangat nyaman untuk proyek lintas platform, di mana pembangunan iOS dan Android memiliki logika penerapan yang sama tetapi alat pembangunan yang berbeda.

Struktur Fastfile: lanes, actions dan parameter

Fastfile terdiri dari tiga elemen utama: deklarasi platform (default_platform), definisi lanes, dan konfigurasi fungsi bantu. Setiap lane dimulai dengan kata kunci lane, diikuti dengan nama skenario (simbol Ruby), badan dengan urutan actions, dan blok penanganan kesalahan error, success, atau ensure.

Actions dalam Fastfile — adalah panggilan fungsi bawaan Fastlane dengan parameter dalam bentuk Hash. Misalnya, gym(scheme: 'App', export_method: 'app-store') menjalankan pembangunan aplikasi iOS dengan parameter yang ditentukan. Setiap action mengembalikan hasil yang dapat disimpan dalam variabel dan digunakan di actions berikutnya — ini memungkinkan pembangunan logika kondisional di dalam lane.

Fastfile mendukung variabel lingkungan melalui mekanisme standar ENV dalam Ruby. Data sensitif (kata sandi, token, kunci) tidak boleh disimpan di Fastfile — gunakan variabel lingkungan sistem CI/CD atau file .env yang ditambahkan ke .gitignore. Fastlane secara otomatis memuat file .env dari direktori fastlane saat dijalankan.

Appfile dan Matchfile

Bersama dengan Fastfile, di direktori fastlane terdapat file konfigurasi tambahan. Appfile berisi pengidentifikasi aplikasi (app_identifier), Apple ID, dan Team ID — data ini secara otomatis dimasukkan ke semua actions, menghilangkan pengulangan di setiap lane. Matchfile menyimpan pengaturan untuk match: URL repositori Git, jenis profil, dan kunci enkripsi.

Pembagian konfigurasi ke beberapa file memudahkan pemeliharaan proyek dengan lingkungan yang berbeda. Misalnya, untuk staging dan production dapat dibuat cabang terpisah di repositori Matchfile atau parameter dapat ditimpa melalui variabel lingkungan di sistem CI/CD.

# Struktur dasar 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

Sintaksis Fastfile: menulis lanes

Sintaksis Fastfile didasarkan pada Ruby DSL (Domain Specific Language), yang dirancang khusus untuk keterbacaan skenario otomatisasi. Lane dideklarasikan melalui konstruksi lane :name do ... end, di mana name adalah simbol Ruby yang menjadi perintah fastlane name untuk dijalankan dari terminal atau sistem CI/CD.

Di dalam lane dapat digunakan operator kondisional Ruby: if, unless, case untuk percabangan logika. Juga tersedia perulangan each dan while untuk memproses array nilai. Fastlane menyediakan metode khusus before_all, after_all, dan blok error untuk menangani peristiwa siklus hidup lane.

Parameter lane diteruskan melalui hash options. Saat menjalankan fastlane build --option_name value, nilai masuk ke options[:option_name] di dalam lane. Nilai default dapat diatur melalui optional: true dan validasi type untuk mengontrol tipe parameter yang diteruskan.

# Lane dengan parameter dan logika kondisional
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

Contoh Fastfile untuk pengiriman iOS

Fastfile lengkap untuk proyek iOS mencakup lanes untuk menginstal dependensi, pengujian, pembangunan, dan penerapan ke TestFlight dan App Store. Mari kita lihat contoh yang mencakup proses CI/CD tipikal dari commit hingga publikasi di TestFlight untuk pengujian internal.

# Fastfile untuk pengiriman 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: 'Build diunggah ke TestFlight untuk pengujian internal'
  )
end

Dalam contoh ini, blok before_all dieksekusi sebelum setiap lane dan menginstal dependensi. Lane tests menjalankan pengujian UI dan Unit pada dua perangkat. Lane build_appstore menandatangani kode melalui match dan membangun IPA dengan bitcode. Lane deploy_testflight menggabungkan semua langkah untuk pengiriman lengkap.

Penerapan dengan beberapa target

Proyek dengan beberapa target (aplikasi utama, watchOS, widget, Notification Service Extension) memerlukan lanes terpisah untuk setiap target. Di Fastfile dapat dibuat lane universal :deploy_target yang menerima nama skema dan jalur pembangunan sebagai parameter. Ini memungkinkan menjalankan penerapan untuk semua ekstensi melalui fastlane deploy_target scheme:Widget.

Untuk mengatur beberapa target, gunakan array skema dan perulangan each di dalam lane. Fastlane mendukung pembangunan paralel beberapa skema melalui flag parallel: true, yang mempercepat total waktu pipeline CI/CD untuk aplikasi dengan ekstensi.

Contoh Fastfile untuk pembangunan Android

Fastfile untuk proyek Android menggunakan gradle action untuk menjalankan tugas Gradle dan supply action untuk publikasi di Google Play. Tidak seperti iOS, Android tidak memerlukan match, tetapi menggunakan Keystore untuk penandatanganan, yang disimpan di luar repositori dan diteruskan melalui variabel lingkungan.

# Fastfile untuk pembangunan 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

Untuk penandatanganan Android aplikasi, konfigurasikan signingConfigs di build.gradle dan teruskan parameter Keystore melalui variabel lingkungan: ANDROID_KEYSTORE_PATH, ANDROID_KEYSTORE_PASSWORD, ANDROID_KEY_ALIAS, dan ANDROID_KEY_PASSWORD. Fastlane secara otomatis menggunakan apksigner sistem untuk menandatangani AAB atau APK yang dibangun.

Penandatanganan Android di Fastfile

Untuk mengkonfigurasi penandatanganan Android di Fastfile, gunakan action sign_android atau andalkan signingConfigs di build.gradle. Fastlane terintegrasi dengan apksigner melalui Gradle — meneruskan flag SIGNING_CONFIG di gradle task mengaktifkan penandatanganan dengan parameter dari variabel lingkungan. Ini memungkinkan penandatanganan file AAB sebelum diunggah ke Google Play Console.

Untuk penyimpanan Keystore yang aman di CI/CD, gunakan pengkodean Base64 dan variabel lingkungan. Fastlane mendukung action setup_keystore, yang mendekode Keystore dari variabel dan menyimpannya ke file sementara pada tahap before_all. Setelah lane selesai, file sementara secara otomatis dihapus untuk mencegah kebocoran sertifikat.

Menggunakan private lanes dan grup

Private lanes (skenario pribadi) — adalah lanes yang tidak dapat dipanggil langsung dari baris perintah, tetapi tersedia untuk dipanggil dari lanes lain di dalam Fastfile. Private lane dideklarasikan melalui konstruksi private_lane :name do ... end dan digunakan untuk enkapsulasi langkah berulang yang tidak berarti sebagai skenario mandiri.

Private lanes sangat ideal untuk mengelompokkan logika berulang: instalasi dependensi, konfigurasi lingkungan, mengirim notifikasi. Misalnya, dapat dibuat private lane :setup_signing yang dipanggil dari beberapa lane penerapan, tetapi tidak boleh tersedia untuk eksekusi langsung oleh pengembang untuk menghindari kesalahan.

# Private lane dan pengelompokan
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

Pengelompokan lanes melalui blok platform memungkinkan pemisahan skenario untuk iOS dan Android dalam satu Fastfile. Konstruksi platform :ios do ... end dan platform :android do ... end mengisolasi lanes dari platform yang sesuai, dan private lanes umum dapat ditempatkan di luar blok platform untuk digunakan kembali.

Meneruskan parameter ke lanes

Mekanisme parameter Fastfile memungkinkan lanes menjadi fleksibel dan dapat digunakan kembali. Parameter diteruskan saat eksekusi melalui baris perintah: fastlane build scheme:App export_method:appstore. Di dalam lane, nilai tersedia melalui hash options yang diteruskan ke blok lane sebagai argumen.

Fastlane mendukung parameter bertipe dengan validasi melalui OptionalHash. Tipe nilai (String, Boolean, Integer), nilai default, dan deskripsi dapat diatur untuk pembuatan dokumentasi otomatis. Juga tersedia variabel lingkungan sebagai cara alternatif untuk meneruskan parameter, yang nyaman untuk sistem CI/CD.

# Parameter dengan validasi tipe
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: "Membangun #{options[:scheme]} selesai")
end

# Eksekusi: fastlane build scheme:MyApp export_method:appstore

Disarankan untuk menggunakan nilai default untuk semua parameter opsional, sehingga lane dapat dijalankan tanpa menyebutkan setiap argumen secara eksplisit. Untuk parameter wajib, periksa keberadaan nilai di awal lane dan hentikan eksekusi dengan pesan kesalahan yang jelas melalui UI.user_error!.