Fastfile: सार, संरचना और मोबाइल डेवलपमेंट में ऑटोमेशन सेट अप करना

Fastfile क्या है और इसकी आवश्यकता क्यों है

Fastfile Fastlane की मुख्य कॉन्फ़िगरेशन फ़ाइल है, जो Ruby में लिखी जाती है और प्रोजेक्ट की जड़ में fastlane निर्देशिका में रखी जाती है। यह एप्लिकेशन बनाने, परीक्षण करने, कोड साइन करने और वितरित करने के लिए सभी ऑटोमेशन परिदृश्यों (lanes) को परिभाषित करती है। Fastfile दर्जनों bash स्क्रिप्ट, Makefile और मैन्युअल निर्देशों को एक एकल घोषणात्मक CI/CD पाइपलाइन विवरण से बदल देता है।

Fastfile की आवश्यकता तब उत्पन्न होती है जब प्रोजेक्ट को विभिन्न डेवलपर मशीनों और CI/CD सर्वरों पर दोहराने योग्य बिल्ड की आवश्यकता होती है। प्रत्येक डेवलपर द्वारा मैन्युअल रूप से वातावरण सेट अप करने के बजाय, Fastfile सभी चरणों को कोड में कैप्चर करता है जिसे Git में वर्जन किया जा सकता है, समीक्षा की जा सकती है और प्रोजेक्ट्स के बीच पुन: उपयोग किया जा सकता है। एक एकल Fastfile गारंटी देता है कि डेवलपर की मशीन पर बिल्ड CI/CD सर्वर पर बिल्ड के समान है।

Fastfile default_platform निर्देश के माध्यम से प्लेटफ़ॉर्म का समर्थन करता है। एक Fastfile में iOS, Android और macOS के लिए परिदृश्यों का वर्णन किया जा सकता है, उन्हें platform :ios और platform :android ब्लॉक में समूहित करके। यह क्रॉस-प्लेटफ़ॉर्म प्रोजेक्ट्स के लिए विशेष रूप से उपयोगी है जहाँ iOS और Android बिल्ड में सामान्य डिप्लॉयमेंट लॉजिक होता है लेकिन विभिन्न बिल्ड टूल का उपयोग करते हैं।

Fastfile संरचना: lanes, actions और पैरामीटर

Fastfile तीन मुख्य तत्वों से बना होता है: प्लेटफ़ॉर्म घोषणा (default_platform), lanes परिभाषाएँ और सहायक फ़ंक्शन कॉन्फ़िगरेशन। प्रत्येक lane कीवर्ड lane से शुरू होता है, जिसके बाद परिदृश्य का नाम (Ruby सिंबल), क्रियाओं के अनुक्रम के साथ बॉडी और त्रुटि प्रबंधन ब्लॉक — error, success या ensure — आते हैं।

Fastfile में Actions Hash के रूप में पैरामीटर के साथ अंतर्निहित Fastlane फ़ंक्शन के कॉल हैं। उदाहरण के लिए, gym(scheme: 'App', export_method: 'app-store') निर्दिष्ट पैरामीटर के साथ iOS एप्लिकेशन बिल्ड शुरू करता है। प्रत्येक action एक परिणाम लौटाता है जिसे वेरिएबल में संग्रहीत किया जा सकता है और बाद के actions में उपयोग किया जा सकता है — यह lane के अंदर सशर्त लॉजिक सक्षम करता है।

Fastfile Ruby के मानक ENV तंत्र के माध्यम से पर्यावरण वेरिएबल का समर्थन करता है। संवेदनशील डेटा (पासवर्ड, टोकन, कुंजियाँ) Fastfile में संग्रहीत नहीं किया जाना चाहिए — CI/CD सिस्टम पर्यावरण वेरिएबल या .gitignore में जोड़ी गई .env फ़ाइल का उपयोग करें। Fastlane स्टार्टअप पर fastlane निर्देशिका से .env फ़ाइलों को स्वचालित रूप से लोड करता है।

Appfile और Matchfile

Fastfile के साथ fastlane निर्देशिका में अतिरिक्त कॉन्फ़िगरेशन फ़ाइलें स्थित होती हैं। Appfile में एप्लिकेशन पहचानकर्ता (app_identifier), Apple ID और Team ID होते हैं — ये डेटा स्वचालित रूप से सभी actions में डाले जाते हैं, प्रत्येक lane में पुनरावृत्ति को समाप्त करते हैं। Matchfile match के लिए सेटिंग्स संग्रहीत करता है: Git रिपॉजिटरी URL, प्रोफ़ाइल प्रकार और एन्क्रिप्शन कुंजी।

कॉन्फ़िगरेशन को कई फ़ाइलों में विभाजित करना विभिन्न वातावरणों वाले प्रोजेक्ट्स के रखरखाव को सरल बनाता है। उदाहरण के लिए, staging और production के लिए, Matchfile रिपॉजिटरी में अलग-अलग शाखाएँ बनाई जा सकती हैं या CI/CD सिस्टम में पर्यावरण वेरिएबल के माध्यम से पैरामीटर को ओवरराइड किया जा सकता है।

# 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

Fastfile सिंटैक्स: lanes लिखना

Fastfile सिंटैक्स Ruby DSL (डोमेन-विशिष्ट भाषा) पर आधारित है, जिसे विशेष रूप से ऑटोमेशन परिदृश्यों की पठनीयता के लिए डिज़ाइन किया गया है। Lane को lane :name do ... end निर्माण के माध्यम से घोषित किया जाता है, जहाँ name एक Ruby सिंबल है जो टर्मिनल या CI/CD सिस्टम से चलाने के लिए fastlane name कमांड बन जाता है।

Lane के अंदर लॉजिक की शाखाओं के लिए Ruby सशर्त ऑपरेटर: if, unless, case का उपयोग किया जा सकता है। मानों की सरणियों को संसाधित करने के लिए लूप each और while भी उपलब्ध हैं। Fastlane lane जीवनचक्र घटनाओं को संभालने के लिए विशेष विधियाँ before_all, after_all और error ब्लॉक प्रदान करता है।

Lane पैरामीटर options हैश के माध्यम से पास किए जाते हैं। fastlane build --option_name value चलाने पर, मान lane के अंदर options[:option_name] में जाता है। पास किए गए पैरामीटर के प्रकारों को नियंत्रित करने के लिए optional: true के माध्यम से डिफ़ॉल्ट मान और टाइप सत्यापन सेट किया जा सकता है।

# पैरामीटर और सशर्त लॉजिक के साथ Lane
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

iOS वितरण के लिए Fastfile उदाहरण

iOS प्रोजेक्ट के लिए एक पूर्ण Fastfile में निर्भरता स्थापना, परीक्षण, बिल्ड और TestFlight और App Store में डिप्लॉयमेंट के लिए lanes शामिल हैं। आइए एक उदाहरण देखें जो कमिट से लेकर आंतरिक परीक्षण के लिए TestFlight पर प्रकाशन तक की विशिष्ट CI/CD प्रक्रिया को कवर करता है।

# iOS CI/CD वितरण के लिए Fastfile
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: 'आंतरिक परीक्षण के लिए TestFlight पर बिल्ड अपलोड किया गया'
  )
end

इस उदाहरण में, before_all ब्लॉक प्रत्येक lane से पहले निष्पादित होता है और निर्भरताएँ स्थापित करता है। tests lane दो उपकरणों पर UI और यूनिट परीक्षण चलाता है। build_appstore lane match के माध्यम से कोड साइन करता है और bitcode के साथ IPA बनाता है। deploy_testflight lane पूर्ण वितरण के लिए सभी चरणों को जोड़ता है।

एकाधिक लक्ष्यों के साथ डिप्लॉयमेंट

एकाधिक लक्ष्यों (मुख्य एप्लिकेशन, watchOS, widget, Notification Service Extension) वाले प्रोजेक्ट्स को प्रत्येक लक्ष्य के लिए अलग-अलग lanes की आवश्यकता होती है। Fastfile में एक सार्वभौमिक lane :deploy_target बनाया जा सकता है जो स्कीमा नाम और बिल्ड पथ को पैरामीटर के रूप में स्वीकार करता है। यह fastlane deploy_target scheme:Widget के माध्यम से सभी एक्सटेंशन के लिए डिप्लॉयमेंट चलाने की अनुमति देता है।

एकाधिक लक्ष्यों को व्यवस्थित करने के लिए, स्कीमा की एक सरणी और lane के अंदर each लूप का उपयोग करें। Fastlane parallel: true फ्लैग के माध्यम से एकाधिक स्कीमा के समानांतर बिल्ड का समर्थन करता है, जो एक्सटेंशन वाले एप्लिकेशन के लिए कुल CI/CD पाइपलाइन समय को कम करता है।

Android बिल्ड के लिए Fastfile उदाहरण

Android प्रोजेक्ट के लिए Fastfile Gradle कार्यों को चलाने के लिए gradle action और Google Play पर प्रकाशन के लिए supply action का उपयोग करता है। iOS के विपरीत, Android को match की आवश्यकता नहीं है, लेकिन यह साइनिंग के लिए Keystore का उपयोग करता है, जो रिपॉजिटरी के बाहर संग्रहीत होता है और पर्यावरण वेरिएबल के माध्यम से पास किया जाता है।

# Android CI/CD बिल्ड के लिए Fastfile
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

Android एप्लिकेशन साइनिंग के लिए, build.gradle में signingConfigs कॉन्फ़िगर करें और पर्यावरण वेरिएबल के माध्यम से Keystore पैरामीटर पास करें: ANDROID_KEYSTORE_PATH, ANDROID_KEYSTORE_PASSWORD, ANDROID_KEY_ALIAS और ANDROID_KEY_PASSWORD। Fastlane स्वचालित रूप से निर्मित AAB या APK पर हस्ताक्षर करने के लिए सिस्टम apksigner का उपयोग करता है।

Fastfile में Android साइनिंग

Fastfile में Android साइनिंग कॉन्फ़िगर करने के लिए, sign_android action का उपयोग करें या build.gradle में signingConfigs पर भरोसा करें। Fastlane Gradle के माध्यम से apksigner के साथ एकीकृत होता है — gradle कार्य में SIGNING_CONFIG फ्लैग पास करने से पर्यावरण वेरिएबल के पैरामीटर के साथ साइनिंग सक्रिय होती है। यह Google Play Console पर अपलोड करने से पहले AAB फ़ाइलों पर हस्ताक्षर करने की अनुमति देता है।

CI/CD में Keystore के सुरक्षित भंडारण के लिए, Base64 एन्कोडिंग और पर्यावरण वेरिएबल का उपयोग करें। Fastlane setup_keystore action का समर्थन करता है, जो Keystore को वेरिएबल से डीकोड करता है और before_all चरण के दौरान इसे एक अस्थायी फ़ाइल में सहेजता है। Lane पूरा होने के बाद, प्रमाणपत्र लीकेज को रोकने के लिए अस्थायी फ़ाइल स्वचालित रूप से हटा दी जाती है।

Private lanes और समूहों का उपयोग

Private lanes (निजी परिदृश्य) वे lanes हैं जिन्हें सीधे कमांड लाइन से कॉल नहीं किया जा सकता है, लेकिन Fastfile के अंदर अन्य lanes से कॉल के लिए उपलब्ध हैं। Private lane को private_lane :name do ... end निर्माण के माध्यम से घोषित किया जाता है और इसका उपयोग दोहराए जाने वाले चरणों को एनकैप्सुलेट करने के लिए किया जाता है जो स्वतंत्र परिदृश्यों के रूप में समझ में नहीं आते हैं।

Private lanes दोहराए जाने वाले लॉजिक को समूहित करने के लिए आदर्श हैं: निर्भरता स्थापना, वातावरण सेट अप, सूचनाएँ भेजना। उदाहरण के लिए, एक private lane :setup_signing बनाया जा सकता है जो कई डिप्लॉयमेंट lanes से कॉल किया जाता है, लेकिन त्रुटियों से बचने के लिए डेवलपर द्वारा सीधे निष्पादन के लिए उपलब्ध नहीं होना चाहिए।

# Private lane और समूहीकरण
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

platform ब्लॉक के माध्यम से lanes का समूहीकरण एक Fastfile में iOS और Android परिदृश्यों को अलग करने की अनुमति देता है। platform :ios do ... end और platform :android do ... end निर्माण संबंधित प्लेटफ़ॉर्म के lanes को अलग करता है, जबकि सामान्य private lanes को पुन: उपयोग के लिए प्लेटफ़ॉर्म ब्लॉक के बाहर रखा जा सकता है।

Lanes में पैरामीटर पास करना

Fastfile का पैरामीटर तंत्र lanes को लचीला और पुन: प्रयोज्य बनाने की अनुमति देता है। पैरामीटर रनटाइम पर कमांड लाइन के माध्यम से पास किए जाते हैं: fastlane build scheme:App export_method:appstore। Lane के अंदर, मान options हैश के माध्यम से सुलभ होते हैं, जो lane ब्लॉक को एक तर्क के रूप में पास किया जाता है।

Fastlane OptionalHash के माध्यम से सत्यापन के साथ टाइप किए गए पैरामीटर का समर्थन करता है। मान प्रकार (String, Boolean, Integer), डिफ़ॉल्ट मान और दस्तावेज़ीकरण के स्वत: निर्माण के लिए विवरण निर्दिष्ट किया जा सकता है। पर्यावरण वेरिएबल भी पैरामीटर पास करने के वैकल्पिक तरीके के रूप में उपलब्ध हैं, जो CI/CD सिस्टम के लिए सुविधाजनक है।

# प्रकार सत्यापन के साथ पैरामीटर
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: "बिल्ड #{options[:scheme]} पूर्ण हुआ")
end

# चलाएँ: fastlane build scheme:MyApp export_method:appstore

सभी वैकल्पिक पैरामीटर के लिए डिफ़ॉल्ट मान का उपयोग करने की अनुशंसा की जाती है, ताकि lane को प्रत्येक तर्क को स्पष्ट रूप से निर्दिष्ट किए बिना चलाया जा सके। आवश्यक पैरामीटर के लिए, lane की शुरुआत में उनकी उपस्थिति की जाँच करें और UI.user_error! के माध्यम से स्पष्ट त्रुटि संदेश के साथ निष्पादन को रोकें।