മൊബൈൽ സിഐസിഡി അനുഭവം: നിരവധി മൊബൈൽ ആപ്ലിക്കേഷനുകൾക്കുള്ള ഒരു ഫാസ്റ്റ്ലെയ്ൻ സ്റ്റാൻഡേർഡ്

ഫാസ്റ്റ്‌ലെയ്ൻ ഉപയോഗിച്ച് മൊബൈൽ ആപ്പുകൾക്കുള്ള തുടർച്ചയായ സംയോജനത്തെയും ഡെലിവറിയെയും കുറിച്ച് സംസാരിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. എല്ലാ മൊബൈൽ ആപ്ലിക്കേഷനുകളിലും ഞങ്ങൾ എങ്ങനെയാണ് CI/CD നടപ്പിലാക്കുന്നത്, ഞങ്ങൾ എങ്ങനെ അവിടെ എത്തി, അവസാനം എന്താണ് സംഭവിച്ചത്.

ടൂളിലെ നെറ്റ്‌വർക്കിൽ ഇതിനകം തന്നെ വേണ്ടത്ര മെറ്റീരിയൽ ഉണ്ട്, അത് ഞങ്ങൾക്ക് തുടക്കത്തിൽ തന്നെ ഇല്ലായിരുന്നു, അതിനാൽ ഞാൻ മനഃപൂർവ്വം ഉപകരണത്തെ വിശദമായി വിവരിക്കുന്നില്ല, പക്ഷേ ഞങ്ങൾക്ക് ഉണ്ടായിരുന്നത് മാത്രമേ പരാമർശിക്കൂ:

• ഔദ്യോഗിക ഫാസ്റ്റ്ലെയ്ൻ ഡോക്യുമെൻ്റേഷൻ
• മറ്റ് കമ്പനികളുടെ ഉദാഹരണങ്ങൾ
• Fastlane ഉപയോഗിച്ച് ഞങ്ങൾ iOS ആപ്ലിക്കേഷനുകളുടെ അസംബ്ലി ഓട്ടോമേറ്റ് ചെയ്യുന്നു

ലേഖനം രണ്ട് ഭാഗങ്ങൾ ഉൾക്കൊള്ളുന്നു:

• കമ്പനിയിൽ മൊബൈൽ സിഐ/സിഡിയുടെ ആവിർഭാവത്തിൻ്റെ പശ്ചാത്തലം
• N-ആപ്ലിക്കേഷനുകൾക്കായി CI/CD പുറത്തിറക്കുന്നതിനുള്ള സാങ്കേതിക പരിഹാരം

ആദ്യഭാഗം പഴയ കാലത്തെ കൂടുതൽ ഗൃഹാതുരത്വമാണ്, രണ്ടാമത്തേത് നിങ്ങൾക്ക് സ്വയം പ്രയോഗിക്കാൻ കഴിയുന്ന ഒരു അനുഭവമാണ്.

ചരിത്രപരമായി സംഭവിച്ചത് ഇങ്ങനെയാണ്

വർഷം 2015

ഞങ്ങൾ ഇപ്പോൾ മൊബൈൽ ആപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കാൻ തുടങ്ങി, തുടർന്ന് തുടർച്ചയായ സംയോജനത്തെക്കുറിച്ചും DevOps-നെക്കുറിച്ചും മറ്റ് ഫാഷനബിൾ കാര്യങ്ങളെക്കുറിച്ചും ഞങ്ങൾക്ക് ഒന്നും അറിയില്ലായിരുന്നു. ഓരോ ആപ്ലിക്കേഷൻ അപ്‌ഡേറ്റും ഡവലപ്പർ തന്നെ തൻ്റെ മെഷീനിൽ നിന്ന് പുറത്തിറക്കി. ആൻഡ്രോയിഡിന് ഇത് വളരെ ലളിതമാണെങ്കിൽ - ഒത്തുചേർന്നു, ഒപ്പിട്ടു .apk തുടർന്ന് അത് Google Developer Console-ലേക്ക് അപ്‌ലോഡ് ചെയ്‌തു, തുടർന്ന് iOS-നുള്ള അന്നത്തെ വിതരണ ഉപകരണം Xcode വഴി ഞങ്ങൾക്ക് മികച്ച സായാഹ്നങ്ങൾ സമ്മാനിച്ചു - ആർക്കൈവ് ഡൗൺലോഡ് ചെയ്യാനുള്ള ശ്രമങ്ങൾ പലപ്പോഴും പിശകുകളിൽ അവസാനിച്ചു, ഞങ്ങൾ വീണ്ടും ശ്രമിക്കേണ്ടതായി വന്നു. ഏറ്റവും നൂതനമായ ഡവലപ്പർ മാസത്തിൽ പല തവണ കോഡ് എഴുതുന്നില്ല, പകരം ആപ്ലിക്കേഷൻ റിലീസ് ചെയ്യുന്നു.

വർഷം 2016

ഞങ്ങൾ വളർന്നു, ഒരു റിലീസിനായി ഒരു ദിവസം മുഴുവൻ ഡവലപ്പർമാരെ എങ്ങനെ സ്വതന്ത്രമാക്കാം എന്നതിനെക്കുറിച്ച് ഞങ്ങൾക്ക് ഇതിനകം ചിന്തകൾ ഉണ്ടായിരുന്നു, രണ്ടാമത്തെ ആപ്ലിക്കേഷനും പ്രത്യക്ഷപ്പെട്ടു, ഇത് ഞങ്ങളെ ഓട്ടോമേഷനിലേക്ക് കൂടുതൽ തള്ളിവിട്ടു. അതേ വർഷം തന്നെ, ഞങ്ങൾ ജെങ്കിൻസ് ആദ്യമായി ഇൻസ്റ്റാൾ ചെയ്യുകയും ഫാസ്റ്റ്‌ലെയ്ൻ അതിൻ്റെ ഡോക്യുമെൻ്റേഷനിൽ കാണിക്കുന്നതിന് സമാനമായ ഒരു കൂട്ടം ഭയപ്പെടുത്തുന്ന സ്ക്രിപ്റ്റുകൾ എഴുതുകയും ചെയ്തു.

$ xcodebuild clean archive -archivePath build/MyApp 
    -scheme MyApp

$ xcodebuild -exportArchive 
                        -exportFormat ipa 
                        -archivePath "build/MyApp.xcarchive" 
                        -exportPath "build/MyApp.ipa" 
                        -exportProvisioningProfile "ProvisioningProfileName"

$ cd /Applications/Xcode.app/Contents/Applications/Application Loader.app/Contents/Frameworks/ITunesSoftwareService.framework/Versions/A/Support/

$ ./altool —upload-app 
-f {abs path to your project}/build/{release scheme}.ipa  
-u "[email protected]" 
-p "PASS_APPLE_ID"

നിർഭാഗ്യവശാൽ, ഈ സ്‌ക്രിപ്‌റ്റുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്നും ഈ അനന്തമായ കീകൾ എന്തിന് ആവശ്യമാണെന്നും ഞങ്ങളുടെ ഡെവലപ്പർമാർക്ക് മാത്രമേ അറിയൂ, വീണ്ടും എന്തെങ്കിലും തകരാറിലായപ്പോൾ, ലോഗുകൾ വിശകലനം ചെയ്യുന്നതിനുള്ള “മനോഹരമായ സായാഹ്നങ്ങൾ” അവർക്ക് ലഭിച്ചു.

വർഷം 2017

ഫാസ്റ്റ്‌ലൈൻ എന്നൊരു സംഗതി ഉണ്ടെന്ന് ഈ വർഷം ഞങ്ങൾ മനസ്സിലാക്കി. ഇപ്പോഴുള്ള അത്രയും വിവരങ്ങൾ ഇല്ലായിരുന്നു - ഒരെണ്ണം എങ്ങനെ തുടങ്ങാം, എങ്ങനെ ഉപയോഗിക്കാം. ആ സമയത്ത് ഉപകരണം തന്നെ അസംസ്കൃതമായിരുന്നു: നിരന്തരമായ പിശകുകൾ ഞങ്ങളെ നിരാശരാക്കി, അവർ വാഗ്ദാനം ചെയ്ത മാന്ത്രിക ഓട്ടോമേഷനിൽ വിശ്വസിക്കാൻ പ്രയാസമായിരുന്നു.

എന്നിരുന്നാലും, ഫാസ്റ്റ്‌ലൈൻ കോറിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന പ്രധാന യൂട്ടിലിറ്റികൾ gym и pilot, ഞങ്ങൾ അത് ആരംഭിക്കാൻ കഴിഞ്ഞു.

ഞങ്ങളുടെ സ്ക്രിപ്റ്റുകൾ കുറച്ചുകൂടി മെച്ചപ്പെടുത്തിയിട്ടുണ്ട്.

$ fastlane gym  —-workspace "Example.xcworkspace" 
                --scheme "AppName" 
                —-buildlog_path "/tmp" 
                -—clean

ആവശ്യമായ എല്ലാ പാരാമീറ്ററുകളും ഇല്ലെങ്കിൽ മാത്രം അവ മെച്ചപ്പെടുത്തി xcodebuild, നിങ്ങൾ സൂചിപ്പിക്കേണ്ടതുണ്ട് - gym എവിടെ, എന്താണ് കിടക്കുന്നതെന്ന് സ്വതന്ത്രമായി മനസ്സിലാക്കും. കൂടുതൽ ഫൈൻ-ട്യൂണിംഗിനായി, നിങ്ങൾക്ക് അതേ കീകൾ വ്യക്തമാക്കാൻ കഴിയും xcodebuild, കീകളുടെ നാമകരണം മാത്രമേ കൂടുതൽ വ്യക്തമാകൂ.

ഇത്തവണ, ജിമ്മിനും ബിൽറ്റ്-ഇൻ xcpretty ഫോർമാറ്ററിനും നന്ദി, ബിൽഡ് ലോഗുകൾ കൂടുതൽ വ്യക്തമാണ്. ഇത് തകർന്ന അസംബ്ലികൾ ശരിയാക്കുന്നതിനുള്ള സമയം ലാഭിക്കാൻ തുടങ്ങി, ചിലപ്പോൾ റിലീസ് ടീമിന് അത് സ്വന്തമായി കണ്ടെത്താനാകും.

നിർഭാഗ്യവശാൽ, അസംബ്ലി സ്പീഡ് അളവുകൾ xcodebuild и gym ഞങ്ങൾ അത് ചെയ്തില്ല, പക്ഷേ ഡോക്യുമെൻ്റേഷൻ ഞങ്ങൾ വിശ്വസിക്കും - 30% വരെ വേഗത.

എല്ലാ ആപ്ലിക്കേഷനുകൾക്കും ഒരൊറ്റ പ്രക്രിയ

വർഷം 2018 ഉം ഇപ്പോളും

2018-ഓടെ, ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിനും പുറത്തുവിടുന്നതിനുമുള്ള പ്രക്രിയ പൂർണ്ണമായും ജെങ്കിൻസിലേക്ക് നീങ്ങി, ഡവലപ്പർമാർ അവരുടെ മെഷീനുകളിൽ നിന്ന് റിലീസ് ചെയ്യുന്നത് നിർത്തി, റിലീസ് ടീമിന് മാത്രമേ റിലീസ് ചെയ്യാനുള്ള അവകാശമുള്ളൂ.

ടെസ്റ്റുകളുടെയും സ്റ്റാറ്റിക് വിശകലനത്തിൻ്റെയും സമാരംഭം മെച്ചപ്പെടുത്താൻ ഞങ്ങൾ ഇതിനകം ആഗ്രഹിച്ചിരുന്നു, ഞങ്ങളുടെ സ്ക്രിപ്റ്റുകൾ വളരുകയും വളരുകയും ചെയ്തു. ഞങ്ങളുടെ ആപ്ലിക്കേഷനുകൾക്കൊപ്പം വളരുകയും മാറുകയും ചെയ്തു. അക്കാലത്ത്, ഞങ്ങൾക്ക് രണ്ട് പ്ലാറ്റ്ഫോമുകൾ ഉണ്ടെന്ന് കണക്കിലെടുത്ത് ഏകദേശം 10 ആപ്ലിക്കേഷനുകൾ ഉണ്ടായിരുന്നു, അതായത് ഏകദേശം 20 "ജീവനുള്ള" സ്ക്രിപ്റ്റുകൾ.

സ്‌ക്രിപ്റ്റിലേക്ക് ഒരു പുതിയ ഘട്ടം ചേർക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്ന ഓരോ തവണയും, എല്ലാ ഷെൽ സ്‌ക്രിപ്റ്റുകളിലേക്കും ഞങ്ങൾ കഷണങ്ങൾ പകർത്തി-പേസ്റ്റ് ചെയ്യേണ്ടതുണ്ട്. ഒരുപക്ഷേ നമുക്ക് കൂടുതൽ ശ്രദ്ധയോടെ പ്രവർത്തിക്കാമായിരുന്നു, പക്ഷേ പലപ്പോഴും അത്തരം മാറ്റങ്ങൾ അക്ഷരത്തെറ്റുകളിൽ അവസാനിച്ചു, ഇത് റിലീസ് ടീമിന് സ്ക്രിപ്റ്റുകൾ ശരിയാക്കാനും ഏത് മിടുക്കനാണ് ഈ കമാൻഡ് ചേർത്തതെന്നും അത് യഥാർത്ഥത്തിൽ എന്താണ് ചെയ്യുന്നതെന്നും കണ്ടെത്താനുള്ള സായാഹ്നങ്ങളായി മാറി. പൊതുവേ, ഒരു പ്ലാറ്റ്‌ഫോമിനായുള്ള അസംബ്ലിക്കുള്ള സ്‌ക്രിപ്റ്റുകൾ ഒരു പരിധിവരെ സമാനമാണെന്ന് പറയാനാവില്ല. അവർ തീർച്ചയായും അതേ കാര്യം തന്നെ ചെയ്തിട്ടുണ്ടെങ്കിലും.

ഒരു പുതിയ ആപ്ലിക്കേഷനായി ഒരു പ്രോസസ് ആരംഭിക്കുന്നതിന്, ഈ സ്ക്രിപ്റ്റുകളുടെ ഒരു "പുതിയ" പതിപ്പ് തിരഞ്ഞെടുത്ത് അത് ഡീബഗ് ചെയ്ത് "അതെ, ഇത് പ്രവർത്തിക്കുന്നു" എന്ന് പറയുന്നതിന് ഒരു ദിവസം ചെലവഴിക്കേണ്ടത് ആവശ്യമാണ്.

2018-ലെ വേനൽക്കാലത്ത്, ഇപ്പോഴും വികസിച്ചുകൊണ്ടിരിക്കുന്ന ഫാസ്റ്റ്ലെയിനിലേക്ക് ഞങ്ങൾ ഒരിക്കൽ കൂടി നോക്കി.

ടാസ്ക് #1: എല്ലാ സ്ക്രിപ്റ്റ് ഘട്ടങ്ങളും സംഗ്രഹിച്ച് അവ ഫാസ്റ്റ്ഫയലിൽ വീണ്ടും എഴുതുക

ഞങ്ങൾ തുടങ്ങിയപ്പോൾ, ഞങ്ങളുടെ സ്‌ക്രിപ്റ്റുകൾ ജെങ്കിൻസിലെ ഒരു ഷെൽ സ്‌ക്രിപ്റ്റിൽ എല്ലാ സ്റ്റെപ്പുകളും ക്രച്ചുകളും അടങ്ങുന്ന ഒരു കാൽവസ്ത്രം പോലെ കാണപ്പെട്ടു. ഞങ്ങൾ ഇതുവരെ പൈപ്പ് ലൈനിലേക്കും ഘട്ടം ഘട്ടമായുള്ള ഡിവിഷനിലേക്കും മാറിയിട്ടില്ല.

ഞങ്ങളുടെ പക്കലുള്ളത് ഞങ്ങൾ നോക്കി, ഞങ്ങളുടെ CI/CD-യുടെ വിവരണത്തിന് അനുയോജ്യമായ 4 ഘട്ടങ്ങൾ ഞങ്ങൾ തിരിച്ചറിഞ്ഞു:

• ബിൽഡ് - ഡിപൻഡൻസികൾ ഇൻസ്റ്റാൾ ചെയ്യുക, ആർക്കൈവ് കൂട്ടിച്ചേർക്കുക,
• ടെസ്റ്റ് - ഡവലപ്പർ യൂണിറ്റ് ടെസ്റ്റുകൾ നടത്തുന്നു, കവറേജ് കണക്കാക്കുന്നു,
• സോണാർ - എല്ലാ ലിൻ്ററുകളും ലോഞ്ച് ചെയ്യുകയും സോനാർ ക്യൂബിന് റിപ്പോർട്ടുകൾ അയയ്ക്കുകയും ചെയ്യുന്നു,
• വിന്യസിക്കുക - ആൽഫയിലേക്ക് ഒരു പുരാവസ്തു അയക്കുന്നു (ടെസ്റ്റ്ഫ്ലൈറ്റ്).

നിങ്ങൾ വിശദാംശങ്ങളിലേക്ക് പോകുന്നില്ലെങ്കിൽ, പ്രവർത്തനങ്ങളിൽ ഉപയോഗിക്കുന്ന കീകൾ ഒഴിവാക്കിയാൽ, നിങ്ങൾക്ക് ഈ Fastfile ലഭിക്കും:

default_platform(:ios)

platform :ios do
  before_all do
    unlock
  end

  desc "Build stage"
  lane :build do
    match
    prepare_build
    gym
  end

  desc "Prepare build stage: carthage and cocoapods"
  lane :prepare_build do
    pathCartfile = ""
    Dir.chdir("..") do
      pathCartfile = File.join(Dir.pwd, "/Cartfile")
    end
    if File.exist?(pathCartfile)
      carthage
    end
    pathPodfile = ""
    Dir.chdir("..") do
      pathPodfile = File.join(Dir.pwd, "/Podfile")
    end
    if File.exist?(pathPodfile)
      cocoapods
    end
  end

  desc "Test stage"
  lane :test do
    scan
    xcov
  end

  desc "Sonar stage (after run test!)"
  lane :run_sonar do
    slather
    lizard
    swiftlint
    sonar
  end

  desc "Deploy to testflight stage"
  lane :deploy do
    pilot
  end

  desc "Unlock keychain"
  private_lane :unlock do
    pass = ENV['KEYCHAIN_PASSWORD']
    unlock_keychain(
      password: pass
    )
  end
end

വാസ്തവത്തിൽ, ഞങ്ങൾക്ക് ഇപ്പോഴും ആവശ്യമായ ചില ക്രച്ചുകളും ഞങ്ങൾ മാറ്റിസ്ഥാപിച്ച പാരാമീറ്ററുകളുടെ എണ്ണവും കണക്കിലെടുക്കുമ്പോൾ ഞങ്ങളുടെ ആദ്യത്തെ ഫാസ്റ്റ്ഫയൽ ഭയങ്കരമായി മാറി:

lane :build do
carthage(
  command: "update",
  use_binaries: false,
  platform: "ios",
  cache_builds: true)
cocoapods(
  clean: true,
    podfile: "./Podfile",
    use_bundle_exec: false)

gym(
  workspace: "MyApp.xcworkspace",
  configuration: "Release",
  scheme: "MyApp",
  clean: true,
  output_directory: "/build",
  output_name: "my-app.ipa")
end 

lane :deploy do
 pilot(
  username: "[email protected]",
  app_identifier: "com.example.app",
  dev_portal_team_id: "TEAM_ID_NUMBER_DEV",
  team_id: "ITS_TEAM_ID")
end

മുകളിലുള്ള ഉദാഹരണത്തിൽ, നമുക്ക് വ്യക്തമാക്കേണ്ട പാരാമീറ്ററുകളുടെ ഒരു ഭാഗം മാത്രം: ഇവയാണ് ബിൽഡ് പാരാമീറ്ററുകൾ - സ്കീമ, കോൺഫിഗറേഷൻ, പ്രൊവിഷൻ പ്രൊഫൈൽ പേരുകൾ, അതുപോലെ തന്നെ വിതരണ പാരാമീറ്ററുകൾ - ഡെവലപ്പർ അക്കൗണ്ടിൻ്റെ ആപ്പിൾ ഐഡി, പാസ്‌വേഡ്, ആപ്ലിക്കേഷൻ ഐഡി മുതലായവ ഓൺ. ആദ്യ ഏകദേശ കണക്ക് എന്ന നിലയിൽ, ഞങ്ങൾ ഈ കീകളെല്ലാം പ്രത്യേക ഫയലുകളിൽ ഇടുന്നു - Gymfile, Matchfile и Appfile.

ഇപ്പോൾ ജെങ്കിൻസിൽ നിങ്ങൾക്ക് കാഴ്ച മങ്ങിക്കാത്തതും കണ്ണുകൾക്ക് എളുപ്പത്തിൽ വായിക്കാവുന്നതുമായ ഹ്രസ്വ കമാൻഡുകൾ വിളിക്കാം:

# fastlane ios <lane_name>

$ fastlane ios build
$ fastlane ios test
$ fastlane ios run_sonar
$ fastlane ios deploy

ഹുറേ, ഞങ്ങൾ മികച്ചവരാണ്

നിനക്കെന്തു കിട്ടി? ഓരോ ഘട്ടത്തിനും കമാൻഡുകൾ മായ്‌ക്കുക. സ്ക്രിപ്റ്റുകൾ വൃത്തിയാക്കി, ഫാസ്റ്റ്ലെയ്ൻ ഫയലുകളിൽ ഭംഗിയായി ക്രമീകരിച്ചിരിക്കുന്നു. സന്തോഷത്തോടെ, ഞങ്ങൾ ഡെവലപ്പർമാരുടെ അടുത്തേക്ക് ഓടി, അവർക്ക് ആവശ്യമുള്ളതെല്ലാം അവരുടെ ശേഖരണങ്ങളിലേക്ക് ചേർക്കാൻ ആവശ്യപ്പെട്ടു.

എന്നാൽ ഞങ്ങൾക്കും ഇതേ ബുദ്ധിമുട്ടുകൾ നേരിടേണ്ടിവരുമെന്ന് കാലക്രമേണ ഞങ്ങൾ മനസ്സിലാക്കി - ഒരു തരത്തിൽ അല്ലെങ്കിൽ മറ്റൊരു വിധത്തിൽ സ്വന്തം ജീവിതം നയിക്കാൻ തുടങ്ങുന്ന 20 അസംബ്ലി സ്ക്രിപ്റ്റുകൾ ഞങ്ങളുടെ പക്കലുണ്ടാകും, അവ എഡിറ്റുചെയ്യുന്നത് കൂടുതൽ ബുദ്ധിമുട്ടായിരിക്കും, കാരണം സ്ക്രിപ്റ്റുകൾ ശേഖരണങ്ങളിലേക്ക് നീങ്ങും. ഞങ്ങൾക്ക് അവിടെ പ്രവേശനമുണ്ടായിരുന്നില്ല. കൂടാതെ, പൊതുവേ, നമ്മുടെ വേദന ഈ രീതിയിൽ പരിഹരിക്കാൻ കഴിയില്ല.

ടാസ്ക് #2: N ആപ്ലിക്കേഷനുകൾക്കായി ഒരൊറ്റ Fastfile നേടുക

പ്രശ്നം പരിഹരിക്കുന്നത് അത്ര ബുദ്ധിമുട്ടുള്ള കാര്യമല്ലെന്ന് ഇപ്പോൾ തോന്നുന്നു - വേരിയബിളുകൾ സജ്ജമാക്കുക, നമുക്ക് പോകാം. അതെ, വാസ്തവത്തിൽ, അങ്ങനെയാണ് പ്രശ്നം പരിഹരിച്ചത്. എന്നാൽ ഞങ്ങൾ അത് സ്ക്രൂ ചെയ്ത നിമിഷത്തിൽ, ഫാസ്റ്റ്ലെയിനിൽ തന്നെയോ, ഫാസ്റ്റ്ലെയ്ൻ എഴുതിയിരിക്കുന്ന റൂബിയിലോ, നെറ്റ്വർക്കിലെ ഉപയോഗപ്രദമായ ഉദാഹരണങ്ങളോ ഞങ്ങൾക്ക് ഉണ്ടായിരുന്നില്ല - ഫാസ്റ്റ്ലെയിനിനെക്കുറിച്ച് അന്ന് എഴുതിയ എല്ലാവരും ഒരു ആപ്ലിക്കേഷൻ്റെ ഉദാഹരണമായി പരിമിതപ്പെടുത്തിയിരിക്കുന്നു. ഒരു ഡെവലപ്പർ.

Fastlane-ന് പരിസ്ഥിതി വേരിയബിളുകൾ കൈകാര്യം ചെയ്യാൻ കഴിയും, കീചെയിൻ പാസ്‌വേഡ് സജ്ജീകരിച്ചുകൊണ്ട് ഞങ്ങൾ ഇത് ഇതിനകം പരീക്ഷിച്ചു:

ENV['KEYCHAIN_PASSWORD']

ഞങ്ങളുടെ സ്ക്രിപ്റ്റുകൾ നോക്കിയ ശേഷം, പൊതുവായ ഭാഗങ്ങൾ ഞങ്ങൾ തിരിച്ചറിഞ്ഞു:

#for build, test and deploy
APPLICATION_SCHEME_NAME=appScheme
APPLICATION_PROJECT_NAME=app.xcodeproj
APPLICATION_WORKSPACE_NAME=app.xcworkspace
APPLICATION_NAME=appName

OUTPUT_IPA_NAME=appName.ipa

#app info
APP_BUNDLE_IDENTIFIER=com.example.appName
[email protected]
TEAM_ID=ABCD1234
FASTLANE_ITC_TEAM_ID=123456789

ഇപ്പോൾ, ഫാസ്റ്റ്‌ലെയ്ൻ ഫയലുകളിൽ ഈ കീകൾ ഉപയോഗിക്കാൻ തുടങ്ങുന്നതിന്, അവ എങ്ങനെ അവിടെ ഡെലിവർ ചെയ്യണമെന്ന് ഞങ്ങൾ കണ്ടെത്തേണ്ടതുണ്ട്. Fastlane-ന് ഇതിന് ഒരു പരിഹാരമുണ്ട്: dotenv വഴി വേരിയബിളുകൾ ലോഡ് ചെയ്യുന്നു. വ്യത്യസ്‌ത ആവശ്യങ്ങൾക്കായി കീകൾ ലോഡുചെയ്യുന്നത് നിങ്ങൾക്ക് പ്രധാനമാണെങ്കിൽ, ഫാസ്റ്റ്‌ലൈൻ ഡയറക്‌ടറിയിൽ നിരവധി കോൺഫിഗറേഷൻ ഫയലുകൾ സൃഷ്‌ടിക്കുക എന്ന് ഡോക്യുമെൻ്റേഷൻ പറയുന്നു. .env, .env.default, .env.development.

തുടർന്ന് ഈ ലൈബ്രറി കുറച്ച് വ്യത്യസ്തമായി ഉപയോഗിക്കാൻ ഞങ്ങൾ തീരുമാനിച്ചു. നമുക്ക് ഡെവലപ്പർമാരുടെ ശേഖരത്തിൽ ഫാസ്റ്റ്ലെയ്ൻ സ്ക്രിപ്റ്റുകളും അതിൻ്റെ മെറ്റാ വിവരങ്ങളും അല്ല, ഫയലിലെ ഈ ആപ്ലിക്കേഷൻ്റെ തനതായ കീകൾ സ്ഥാപിക്കാം. .env.appName.

സ്വയം Fastfile, Appfile, Matchfile и Gymfile, ഞങ്ങൾ അത് ഒരു പ്രത്യേക ശേഖരത്തിൽ മറച്ചു. മറ്റ് സേവനങ്ങളിൽ നിന്നുള്ള പാസ്‌വേഡ് കീകളുള്ള ഒരു അധിക ഫയൽ അവിടെ മറച്ചിരിക്കുന്നു - .env.
നിങ്ങൾക്ക് ഒരു ഉദാഹരണം കാണാം ഇവിടെ.

CI-ൽ കോളിന് വലിയ മാറ്റമൊന്നും വരുത്തിയിട്ടില്ല, ഒരു നിർദ്ദിഷ്ട ആപ്ലിക്കേഷനായി ഒരു കോൺഫിഗറേഷൻ കീ ചേർത്തിരിക്കുന്നു

# fastlane ios <lane_name> --env appName

$ fastlane ios build --env appName
$ fastlane ios test --env appName
$ fastlane ios run_sonar --env appName
$ fastlane ios deploy --env appName

കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ്, സ്ക്രിപ്റ്റുകൾ ഉപയോഗിച്ച് ഞങ്ങളുടെ ശേഖരം ലോഡ് ചെയ്യുന്നു. അത്ര മനോഹരമായി തോന്നുന്നില്ല:

git clone [email protected]/FastlaneCICD.git fastlane_temp

cp ./fastlane_temp/fastlane/* ./fastlane/
cp ./fastlane_temp/fastlane/.env fastlane/.env

Fastfile വഴി ഡൗൺലോഡ് ചെയ്യുന്നതിന് Fastlane-ന് ഒരു പരിഹാരം ഉണ്ടെങ്കിലും, ഇപ്പോൾ ഈ പരിഹാരം ഉപേക്ഷിച്ചു നടപടി import_from_git, എന്നാൽ ഇത് Fastfile-ന് മാത്രമേ പ്രവർത്തിക്കൂ, എന്നാൽ മറ്റ് ഫയലുകൾക്ക് വേണ്ടിയല്ല. നിങ്ങൾക്ക് "ശരിക്കും മനോഹരം" വേണമെങ്കിൽ, നിങ്ങൾക്ക് സ്വന്തമായി എഴുതാം action.

Android അപ്ലിക്കേഷനുകൾക്കും ReactNative-നും സമാനമായ ഒരു സെറ്റ് നിർമ്മിച്ചു, ഫയലുകൾ ഒരേ ശേഖരത്തിലാണ്, പക്ഷേ വ്യത്യസ്ത ശാഖകളിലാണ് iOS, android и react_native.

റിലീസ് ടീം ചില പുതിയ ഘട്ടങ്ങൾ ചേർക്കാൻ ആഗ്രഹിക്കുമ്പോൾ, സ്ക്രിപ്റ്റിലെ മാറ്റങ്ങൾ Git-ൽ MR വഴി രേഖപ്പെടുത്തുന്നു, തകർന്ന സ്ക്രിപ്റ്റുകളുടെ കുറ്റവാളികളെ ഇനി അന്വേഷിക്കേണ്ടതില്ല, പൊതുവേ, ഇപ്പോൾ നിങ്ങൾ അത് തകർക്കാൻ ശ്രമിക്കേണ്ടതുണ്ട്.

ഇപ്പോൾ അത് ഉറപ്പാണ്

മുമ്പ്, എല്ലാ സ്‌ക്രിപ്റ്റുകളും പരിപാലിക്കുന്നതിനും അവ അപ്‌ഡേറ്റ് ചെയ്യുന്നതിനും അപ്‌ഡേറ്റുകളുടെ എല്ലാ അനന്തരഫലങ്ങളും പരിഹരിക്കുന്നതിനും ഞങ്ങൾ സമയം ചെലവഴിച്ചു. റിലീസുകളിലെ പിശകുകളുടെയും പ്രവർത്തനരഹിതമായ സമയത്തിൻ്റെയും കാരണങ്ങൾ ഷെൽ സ്ക്രിപ്റ്റുകളുടെ തിരക്കിൽ ട്രാക്ക് ചെയ്യാൻ വളരെ ബുദ്ധിമുട്ടുള്ള ലളിതമായ അക്ഷരത്തെറ്റുകൾ ആയിരുന്നപ്പോൾ ഇത് വളരെ നിരാശാജനകമായിരുന്നു. ഇപ്പോൾ അത്തരം പിശകുകൾ കുറഞ്ഞത് ആയി കുറഞ്ഞു. എല്ലാ ആപ്ലിക്കേഷനുകളിലേക്കും ഒരേസമയം മാറ്റങ്ങൾ കൊണ്ടുവരുന്നു. ഒരു പുതിയ ആപ്ലിക്കേഷൻ പ്രോസസ് ചെയ്യാൻ 15 മിനിറ്റ് എടുക്കും - CI-യിൽ ഒരു ടെംപ്ലേറ്റ് പൈപ്പ്ലൈൻ സജ്ജീകരിച്ച് ഡവലപ്പറുടെ ശേഖരത്തിലേക്ക് കീകൾ ചേർക്കുക.

ആൻഡ്രോയിഡിനുള്ള Fastfile ഉം ആപ്ലിക്കേഷൻ സിഗ്നേച്ചറും ഉള്ള പോയിൻ്റ് വിശദീകരിക്കാനാകാത്തതായി തോന്നുന്നു, ലേഖനം രസകരമാണെങ്കിൽ, ഞാൻ ഒരു തുടർച്ച എഴുതും. അഭിപ്രായങ്ങളിലോ ടെലിഗ്രാമിലോ "ഈ പ്രശ്നം എങ്ങനെ പരിഹരിക്കും" എന്ന നിങ്ങളുടെ ചോദ്യങ്ങളോ നിർദ്ദേശങ്ങളോ കാണുന്നതിൽ എനിക്ക് സന്തോഷമുണ്ട്. ബഷ്കിറോവ.

അവലംബം: www.habr.com