ಮೊಬೈಲ್ CICD ಅನುಭವ: ಅನೇಕ ಮೊಬೈಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಒಂದು ಫಾಸ್ಟ್‌ಲೇನ್ ಮಾನದಂಡ

ಫಾಸ್ಟ್‌ಲೇನ್ ಬಳಸಿಕೊಂಡು ಮೊಬೈಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ನಿರಂತರ ಏಕೀಕರಣ ಮತ್ತು ವಿತರಣೆಯ ಕುರಿತು ಮಾತನಾಡಲು ನಾನು ಬಯಸುತ್ತೇನೆ. ನಾವು ಎಲ್ಲಾ ಮೊಬೈಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ CI/CD ಅನ್ನು ಹೇಗೆ ಅಳವಡಿಸುತ್ತೇವೆ, ನಾವು ಅಲ್ಲಿಗೆ ಹೇಗೆ ಬಂದೆವು ಮತ್ತು ಕೊನೆಯಲ್ಲಿ ಏನಾಯಿತು.

ಟೂಲ್‌ನಲ್ಲಿನ ನೆಟ್‌ವರ್ಕ್‌ನಲ್ಲಿ ಈಗಾಗಲೇ ಸಾಕಷ್ಟು ವಸ್ತುಗಳಿವೆ, ಅದು ಪ್ರಾರಂಭದಲ್ಲಿ ನಮಗೆ ಕೊರತೆಯಿದೆ, ಆದ್ದರಿಂದ ನಾನು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಉಪಕರಣವನ್ನು ವಿವರವಾಗಿ ವಿವರಿಸುವುದಿಲ್ಲ, ಆದರೆ ನಾವು ಅಂದುಕೊಂಡಿದ್ದನ್ನು ಮಾತ್ರ ಉಲ್ಲೇಖಿಸುತ್ತೇನೆ:

• ಅಧಿಕೃತ ಫಾಸ್ಟ್‌ಲೇನ್ ದಸ್ತಾವೇಜನ್ನು
• ಇತರ ಕಂಪನಿಗಳಿಂದ ಉದಾಹರಣೆಗಳು
• ನಾವು ಫಾಸ್ಟ್‌ಲೇನ್ ಬಳಸಿಕೊಂಡು ಐಒಎಸ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಜೋಡಣೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುತ್ತೇವೆ

ಲೇಖನವು ಎರಡು ಭಾಗಗಳನ್ನು ಒಳಗೊಂಡಿದೆ:

• ಕಂಪನಿಯಲ್ಲಿ ಮೊಬೈಲ್ CI/CD ಹೊರಹೊಮ್ಮುವಿಕೆಯ ಹಿನ್ನೆಲೆ
• N-ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ CI/CD ಅನ್ನು ಹೊರತರಲು ತಾಂತ್ರಿಕ ಪರಿಹಾರ

ಮೊದಲ ಭಾಗವು ಹಳೆಯ ದಿನಗಳಿಗೆ ಹೆಚ್ಚು ನಾಸ್ಟಾಲ್ಜಿಯಾ, ಮತ್ತು ಎರಡನೆಯದು ನಿಮಗೆ ನೀವೇ ಅನ್ವಯಿಸಬಹುದಾದ ಅನುಭವವಾಗಿದೆ.

ಇದು ಐತಿಹಾಸಿಕವಾಗಿ ನಡೆದದ್ದು ಹೀಗೆ

2015 ವರ್ಷ

ನಾವು ಮೊಬೈಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ಪ್ರಾರಂಭಿಸಿದ್ದೇವೆ, ನಂತರ ನಿರಂತರ ಏಕೀಕರಣದ ಬಗ್ಗೆ, DevOps ಮತ್ತು ಇತರ ಫ್ಯಾಶನ್ ವಿಷಯಗಳ ಬಗ್ಗೆ ನಮಗೆ ಏನೂ ತಿಳಿದಿರಲಿಲ್ಲ. ಪ್ರತಿಯೊಂದು ಅಪ್ಲಿಕೇಶನ್ ನವೀಕರಣವನ್ನು ಡೆವಲಪರ್ ಸ್ವತಃ ತನ್ನ ಯಂತ್ರದಿಂದ ಹೊರತಂದಿದ್ದಾರೆ. ಮತ್ತು Android ಗಾಗಿ ಇದು ತುಂಬಾ ಸರಳವಾಗಿದ್ದರೆ - ಜೋಡಿಸಲಾಗಿದೆ, ಸಹಿ ಮಾಡಲಾಗಿದೆ .apk ಮತ್ತು ಅದನ್ನು Google ಡೆವಲಪರ್ ಕನ್ಸೋಲ್‌ಗೆ ಅಪ್‌ಲೋಡ್ ಮಾಡಿದೆ, ನಂತರ 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 ಹಂತಗಳನ್ನು ಗುರುತಿಸಿದ್ದೇವೆ:

• ಬಿಲ್ಡ್ - ಅವಲಂಬನೆಗಳನ್ನು ಸ್ಥಾಪಿಸುವುದು, ಆರ್ಕೈವ್ ಅನ್ನು ಜೋಡಿಸುವುದು,
• ಪರೀಕ್ಷೆ - ಡೆವಲಪರ್ ಘಟಕ ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸುವುದು, ವ್ಯಾಪ್ತಿಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು,
• ಸೋನಾರ್ - ಎಲ್ಲಾ ಲಿಂಟರ್‌ಗಳನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಮತ್ತು ಸೋನಾರ್‌ಕ್ಯೂಬ್‌ಗೆ ವರದಿಗಳನ್ನು ಕಳುಹಿಸುತ್ತದೆ,
• ನಿಯೋಜಿಸಿ - ಆಲ್ಫಾ (ಟೆಸ್ಟ್‌ಫ್ಲೈಟ್) ಗೆ ಕಲಾಕೃತಿಯನ್ನು ಕಳುಹಿಸುವುದು.

ಮತ್ತು ನೀವು ವಿವರಗಳಿಗೆ ಹೋಗದಿದ್ದರೆ, ಕ್ರಿಯೆಗಳಲ್ಲಿ ಬಳಸಿದ ಕೀಗಳನ್ನು ಬಿಟ್ಟುಬಿಟ್ಟರೆ, ನೀವು ಈ ಫಾಸ್ಟ್‌ಫೈಲ್ ಅನ್ನು ಪಡೆಯುತ್ತೀರಿ:

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 ಪಡೆಯಿರಿ

ಈಗ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವುದು ತುಂಬಾ ಕಷ್ಟವಲ್ಲ ಎಂದು ತೋರುತ್ತದೆ - ಅಸ್ಥಿರಗಳನ್ನು ಹೊಂದಿಸಿ, ಮತ್ತು ಹೋಗೋಣ. ಹೌದು, ವಾಸ್ತವವಾಗಿ, ಸಮಸ್ಯೆಯನ್ನು ಹೇಗೆ ಪರಿಹರಿಸಲಾಗಿದೆ. ಆದರೆ ನಾವು ಅದನ್ನು ತಿರುಗಿಸಿದ ಕ್ಷಣದಲ್ಲಿ, ನಾವು ಫಾಸ್ಟ್‌ಲೇನ್‌ನಲ್ಲಿ ಪರಿಣತಿಯನ್ನು ಹೊಂದಿರಲಿಲ್ಲ, ಅಥವಾ ಫಾಸ್ಟ್‌ಲೇನ್ ಬರೆಯಲಾದ ರೂಬಿಯಲ್ಲಿ ಅಥವಾ ನೆಟ್‌ವರ್ಕ್‌ನಲ್ಲಿ ಉಪಯುಕ್ತ ಉದಾಹರಣೆಗಳಿಲ್ಲ - ಆಗ ಫಾಸ್ಟ್‌ಲೇನ್ ಬಗ್ಗೆ ಬರೆದ ಪ್ರತಿಯೊಬ್ಬರೂ ಒಂದು ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಉದಾಹರಣೆಗೆ ಸೀಮಿತವಾಗಿದ್ದರು. ಒಬ್ಬ ಡೆವಲಪರ್.

ಫಾಸ್ಟ್‌ಲೇನ್ ಪರಿಸರದ ಅಸ್ಥಿರಗಳನ್ನು ನಿಭಾಯಿಸಬಲ್ಲದು ಮತ್ತು ಕೀಚೈನ್ ಪಾಸ್‌ವರ್ಡ್ ಅನ್ನು ಹೊಂದಿಸುವ ಮೂಲಕ ನಾವು ಈಗಾಗಲೇ ಇದನ್ನು ಪ್ರಯತ್ನಿಸಿದ್ದೇವೆ:

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

ಈಗ, ಫಾಸ್ಟ್‌ಲೇನ್ ಫೈಲ್‌ಗಳಲ್ಲಿ ಈ ಕೀಗಳನ್ನು ಬಳಸುವುದನ್ನು ಪ್ರಾರಂಭಿಸಲು, ಅವುಗಳನ್ನು ಅಲ್ಲಿಗೆ ತಲುಪಿಸುವುದು ಹೇಗೆ ಎಂದು ನಾವು ಲೆಕ್ಕಾಚಾರ ಮಾಡಬೇಕಾಗಿತ್ತು. ಫಾಸ್ಟ್‌ಲೇನ್ ಇದಕ್ಕೆ ಪರಿಹಾರವನ್ನು ಹೊಂದಿದೆ: 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

ಸದ್ಯಕ್ಕೆ ಈ ಪರಿಹಾರವನ್ನು ಬಿಟ್ಟು, ಫಾಸ್ಟ್‌ಲೇನ್ ಮೂಲಕ ಫಾಸ್ಟ್‌ಫೈಲ್ ಡೌನ್‌ಲೋಡ್ ಮಾಡಲು ಪರಿಹಾರವಿದೆ ಕ್ರಮ import_from_git, ಆದರೆ ಇದು ಫಾಸ್ಟ್‌ಫೈಲ್‌ಗೆ ಮಾತ್ರ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಆದರೆ ಇತರ ಫೈಲ್‌ಗಳಿಗೆ ಅಲ್ಲ. ನೀವು "ನಿಜವಾಗಿಯೂ ಸುಂದರ" ಬಯಸಿದರೆ, ನೀವು ನಿಮ್ಮ ಸ್ವಂತ ಬರೆಯಬಹುದು action.

ಇದೇ ರೀತಿಯ ಸೆಟ್ ಅನ್ನು Android ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಮತ್ತು ReactNative ಗಾಗಿ ಮಾಡಲಾಗಿದೆ, ಫೈಲ್‌ಗಳು ಒಂದೇ ರೆಪೊಸಿಟರಿಯಲ್ಲಿವೆ, ಆದರೆ ವಿಭಿನ್ನ ಶಾಖೆಗಳಲ್ಲಿವೆ iOS, android и react_native.

ಬಿಡುಗಡೆ ತಂಡವು ಕೆಲವು ಹೊಸ ಹಂತಗಳನ್ನು ಸೇರಿಸಲು ಬಯಸಿದಾಗ, ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಬದಲಾವಣೆಗಳನ್ನು Git ನಲ್ಲಿ MR ಮೂಲಕ ದಾಖಲಿಸಲಾಗುತ್ತದೆ, ಇನ್ನು ಮುಂದೆ ಮುರಿದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳ ಅಪರಾಧಿಗಳನ್ನು ಹುಡುಕುವ ಅಗತ್ಯವಿಲ್ಲ, ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ, ಈಗ ನೀವು ಅದನ್ನು ಮುರಿಯಲು ಪ್ರಯತ್ನಿಸಬೇಕು.

ಈಗ ಅದು ಖಚಿತವಾಗಿದೆ

ಹಿಂದೆ, ನಾವು ಎಲ್ಲಾ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು, ಅವುಗಳನ್ನು ನವೀಕರಿಸಲು ಮತ್ತು ನವೀಕರಣಗಳ ಎಲ್ಲಾ ಪರಿಣಾಮಗಳನ್ನು ಸರಿಪಡಿಸಲು ಸಮಯವನ್ನು ಕಳೆದಿದ್ದೇವೆ. ಬಿಡುಗಡೆಗಳಲ್ಲಿ ದೋಷಗಳು ಮತ್ತು ಅಲಭ್ಯತೆಯ ಕಾರಣಗಳು ಸರಳವಾದ ಮುದ್ರಣದೋಷಗಳಾಗಿದ್ದು, ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳ ಗೊಂದಲದಲ್ಲಿ ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ತುಂಬಾ ಕಷ್ಟಕರವಾದಾಗ ಇದು ತುಂಬಾ ನಿರಾಶಾದಾಯಕವಾಗಿತ್ತು. ಈಗ ಅಂತಹ ದೋಷಗಳನ್ನು ಕನಿಷ್ಠಕ್ಕೆ ಕಡಿಮೆ ಮಾಡಲಾಗಿದೆ. ಬದಲಾವಣೆಗಳನ್ನು ಎಲ್ಲಾ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಏಕಕಾಲದಲ್ಲಿ ಹೊರತರಲಾಗುತ್ತದೆ. ಮತ್ತು ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಹೊಸ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹಾಕಲು 15 ನಿಮಿಷಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ - CI ನಲ್ಲಿ ಟೆಂಪ್ಲೇಟ್ ಪೈಪ್‌ಲೈನ್ ಅನ್ನು ಹೊಂದಿಸಿ ಮತ್ತು ಡೆವಲಪರ್‌ನ ರೆಪೊಸಿಟರಿಗೆ ಕೀಗಳನ್ನು ಸೇರಿಸಿ.

ಆಂಡ್ರಾಯ್ಡ್‌ಗಾಗಿ ಫಾಸ್ಟ್‌ಫೈಲ್ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಸಹಿಯು ವಿವರಿಸಲಾಗದಂತಿದೆ ಎಂದು ತೋರುತ್ತದೆ, ಲೇಖನವು ಆಸಕ್ತಿದಾಯಕವಾಗಿದ್ದರೆ, ನಾನು ಮುಂದುವರಿಕೆಯನ್ನು ಬರೆಯುತ್ತೇನೆ. ಕಾಮೆಂಟ್‌ಗಳಲ್ಲಿ ಅಥವಾ ಟೆಲಿಗ್ರಾಮ್‌ನಲ್ಲಿ "ಈ ಸಮಸ್ಯೆಯನ್ನು ನೀವು ಹೇಗೆ ಪರಿಹರಿಸುತ್ತೀರಿ" ಎಂಬ ನಿಮ್ಮ ಪ್ರಶ್ನೆಗಳು ಅಥವಾ ಸಲಹೆಗಳನ್ನು ನೋಡಲು ನನಗೆ ಸಂತೋಷವಾಗುತ್ತದೆ ಬಾಷ್ಕಿರೋವಾ.

ಮೂಲ: www.habr.com