Lane — apa itu, membuat dan menggunakan di Fastlane

Apa itu Lane di Fastlane

Lane adalah blok bangunan dasar Fastlane yang mendefinisikan skenario otomatisasi bernama. Setiap lane menjelaskan serangkaian tindakan (actions) yang dijalankan untuk mencapai tujuan tertentu: membangun aplikasi, menjalankan pengujian, mengunggah build ke toko, atau mengonfigurasi lingkungan. Lane dideklarasikan di Fastfile dan dijalankan dengan perintah fastlane [nama_lane] dari root proyek.

Konsep lane berasal dari Ruby DSL dan memberikan keterbacaan skenario. Pengembang melihat seluruh proses CI/CD sebagai rangkaian panggilan actions dengan nama dan parameter yang jelas. Lane bisa sederhana (satu perintah) atau kompleks (percabangan, perulangan, pemanggilan lanes lain).

Setiap lane setelah dieksekusi mengembalikan hasil — objek yang berisi status eksekusi dan data dari actions. Hasil tersebut dapat digunakan di lanes lain atau diteruskan ke sistem CI/CD untuk pengambilan keputusan. Jika ada action dalam lane yang gagal, eksekusi lane berhenti dan blok error dipanggil.

Sintaks lane: deklarasi dan menjalankan

Sintaks deklarasi lane mengikuti pola Ruby DSL sederhana: kata kunci lane, nama skenario sebagai simbol Ruby (symbol), dan blok do ... end dengan isi skenario. Nama lane harus unik dalam platform dan terdiri dari huruf, angka, dan garis bawah.

Menjalankan lane dilakukan melalui baris perintah: fastlane build (untuk lane dengan nama :build) atau bundle exec fastlane build (jika Fastlane diinstal melalui Bundler). Untuk lanes platform gunakan fastlane ios build atau fastlane android build.

# Deklarasi lane sederhana
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

# Menjalankan: fastlane build_and_deploy

Lane dapat berisi logika kondisional berdasarkan parameter atau variabel lingkungan. Gunakan if/unless untuk melewati langkah dalam kondisi tertentu. Juga tersedia perulangan each untuk memproses array, yang berguna untuk membangun beberapa target atau skema aplikasi dalam satu lane.

Mengembalikan nilai dari lane

Lane dapat mengembalikan nilai yang akan tersedia untuk kode pemanggil. Untuk mengembalikan nilai, gunakan return Ruby biasa atau ekspresi terakhir dalam blok lane. Nilai yang dikembalikan bisa berupa string, angka, hash, atau hasil dari action. Ini memungkinkan hasil dari satu lane digunakan di lane lain untuk pengambilan keputusan.

Misalnya, lane :get_version dapat mengembalikan versi aplikasi saat ini dari Info.plist, dan lane :deploy dapat menggunakannya untuk membuat pesan di Slack. Nilai kembali sangat berguna di private lanes, di mana hasilnya diperlukan untuk pemrosesan lebih lanjut di lane pemanggil.

Parameter lanes: melewatkan dan memproses

Parameter lane membuat skenario menjadi fleksibel dan dapat digunakan kembali. Lane menerima parameter melalui options hash yang dilewatkan saat menjalankan dari baris perintah: fastlane deploy scheme:AppStore version:2.1.0. Di dalam lane, parameter tersedia sebagai options[:scheme] dan options[:version].

Untuk parameter wajib, periksa keberadaan nilai di awal lane dan panggil UI.user_error! dengan pesan yang jelas. Untuk parameter opsional, tetapkan nilai default menggunakan operator ||. Fastlane juga mendukung parameter bertipe melalui metode options dengan tipe, nilai default, dan deskripsi.

# Lane dengan pemrosesan parameter
lane :deploy do |options|
  scheme = options[:scheme]
  version = options[:version] || '1.0.0'
  beta = options[:beta] || false

  UI.user_error!("Scheme tidak ditentukan") 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

# Menjalankan: fastlane deploy scheme:MyApp beta:true version:2.1.0

Untuk bekerja dengan variabel lingkungan di dalam lane, gunakan ENV['VARIABLE_NAME']. Fastlane secara otomatis memuat file .env dari direktori fastlane. Ini adalah cara standar untuk melewatkan data sensitif — kunci API, kata sandi, dan token — di lingkungan CI/CD tanpa menyimpannya di Fastfile.

Validasi parameter

Untuk lane yang andal, validasi parameter saat masuk sangat diperlukan. Gunakan UI.user_error! dengan deskripsi masalah jika parameter wajib tidak ada atau memiliki tipe yang salah. Fastlane menyediakan metode options yang memungkinkan pengaturan tipe (String, Boolean, Integer, Array), nilai default, dan deskripsi untuk setiap parameter — validasi dilakukan secara otomatis saat lane dijalankan.

Selain itu, Anda dapat melakukan pemeriksaan melalui blok verify: verify do |value| value.length > 0 end untuk parameter string. Jika format salah, Fastlane menampilkan pesan yang jelas dengan format yang diharapkan dan nilai yang diberikan, memudahkan debugging di lingkungan CI/CD.

Menggabungkan lanes: before_all, after_all dan penanganan error

Fastlane menyediakan hook siklus hidup untuk mengeksekusi kode sebelum dan sesudah setiap lane. Blok before_all dijalankan sebelum setiap lane di platform atau secara global. Blok after_all dijalankan setelah lane berhasil diselesaikan. Blok error dijalankan saat terjadi kesalahan di dalam lane.

Hook memungkinkan sentralisasi logika berulang: menginstal dependensi di before_all, mengirim notifikasi di after_all, membersihkan file sementara dan memberi tahu tentang kesalahan di blok error. Ini mengurangi duplikasi kode dan membuat lanes lebih bersih.

# Hook siklus hidup 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} selesai dengan sukses")
end

error do |lane, exception|
  slack(
    message: "Lane #{lane} gagal dengan error: #{exception}",
    success: false
  )
end

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

Blok error menerima dua argumen: nama lane (symbol) dan objek exception. Di dalam blok, Anda dapat mengirim notifikasi ke Slack, menulis log ke file, atau menjalankan skenario pemulihan alternatif. Jika blok error selesai dengan sukses, Fastlane tidak menganggap build gagal di level CI/CD.

Private lanes dan penggunaan ulang

Private lane adalah lane yang dideklarasikan dengan private_lane alih-alih lane, tidak ditampilkan dalam daftar perintah yang tersedia dan tidak dapat dijalankan langsung dari terminal. Private lanes dirancang untuk merangkum langkah-langkah berulang yang dipanggil dari beberapa lanes publik.

Private lanes sangat berguna untuk urutan tindakan yang kompleks yang harus dijalankan dalam urutan yang ditentukan secara ketat. Misalnya, private lane :setup_signing dapat dipanggil dari lanes :build_dev, :build_staging, dan :build_production dengan parameter berbeda, tetapi tidak berguna sebagai perintah terpisah.

# Private lanes untuk penggunaan ulang
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 dapat memanggil private lanes lain, membentuk hierarki abstraksi. Disarankan untuk membatasi kedalaman bersarang hingga 2–3 level untuk menjaga keterbacaan Fastfile. Dokumentasikan setiap private lane dengan komentar yang menjelaskan tujuannya dan parameter yang diharapkan.

Contoh lanes untuk iOS dan Android

Mari kita lihat contoh praktis lanes untuk proyek iOS dan Android. Lanes iOS biasanya menggunakan scan untuk pengujian, match untuk sertifikat, gym untuk membangun, dan pilot atau deliver untuk pengiriman. Lanes Android menggunakan gradle untuk membangun, supply untuk publikasi, dan firebase_test_lab untuk pengujian cloud.

// Lane untuk CI/CD lengkap aplikasi iOS
lane :ci_full_ios do
  scan(scheme: 'App', code_coverage: true)
  gym(scheme: 'App', export_method: 'app-store')
  pilot(distribute_external: true)
  slack(message: 'CI/CD iOS berhasil diselesaikan')
end

/* Lane untuk CI/CD lengkap aplikasi Android */
lane :ci_full_android do
  gradle(task: 'testReleaseUnitTest')
  gradle(task: 'bundleRelease')
  supply(track: 'internal')
end

Dengan menggabungkan lanes untuk iOS dan Android, Anda dapat membuat proses CI/CD terpadu untuk aplikasi lintas platform. Gunakan blok platform :ios dan platform :android untuk mengelompokkan lanes khusus platform, dan panggil dari lane orchestrator umum yang mengelola urutan eksekusi.

Praktik terbaik penulisan lanes

Saat menulis lanes, disarankan untuk mengikuti serangkaian praktik yang memastikan keterbacaan, kemudahan perawatan, dan keandalan skenario. Aturan pertama — setiap lane harus melakukan satu tugas. Jika lane melakukan terlalu banyak, bagi menjadi beberapa lanes dan private lanes.

Aturan kedua — penamaan lanes harus berupa kata kerja atau frasa kerja: build, deploy, test, upload_screenshots. Hindari nama abstrak seperti process atau do_all. Gunakan garis bawah untuk memisahkan kata dalam nama lane.

Aturan ketiga — tangani kesalahan secara eksplisit. Gunakan UI.user_error! untuk pesan yang jelas tentang masalah. Jangan mengandalkan pesan kesalahan standar Fastlane — berikan konteks kepada pengembang: “File GoogleService-Info.plist tidak ditemukan — tambahkan ke proyek” daripada “File not found”.

Aturan keempat — uji lanes secara lokal sebelum menjalankan di CI/CD. Fastlane mendukung mode dry-run melalui flag --dry-run, yang menunjukkan actions apa yang akan dijalankan tanpa benar-benar menjalankannya. Gunakan fastlane run_test untuk pengujian terisolasi dari lanes individual sebelum integrasi.

Mendokumentasikan lanes

Dokumentasi setiap lane adalah praktik penting untuk pengembangan tim. Fastlane mendukung pembuatan dokumentasi otomatis dari blok desc yang ditempatkan sebelum deklarasi lane. Teks desc ditampilkan saat menjalankan fastlane lanes dan fastlane list, membantu pengembang memahami tujuan setiap skenario tanpa membaca kode sumber Fastfile.

Untuk mendokumentasikan parameter, gunakan komentar Ruby dengan deskripsi nilai yang diharapkan. Fastlane dapat menghasilkan README.md dengan daftar lengkap lanes dan deskripsinya melalui perintah fastlane generate_docs, yang berguna untuk mengadaptasi anggota tim baru ke proses CI/CD proyek.