Search for a command to run...
Deep dive into automating mobile deployments using fastlane
A DevOps/Cloud Architect experienced with building and automating DevOps processes and tools for engineering teams encompassing cloud-native applications. Extensive background experience working with AWS and Microsoft Azure cloud services building hands-on robust and scalable solutions and services.
No comments yet. Be the first to comment.
This series, "Dev Diaries," is dedicated to exploring and discussing findings from my time as a full-stack developer.
The Evolution of DevOps - The Golden Age Let's wind the clock back a couple of decades to the late 90s and early 2000s, a time when most organisations had a single gatekeeper: the system or IT administrator. If engineering teams needed to run their a...
This guide presents a comprehensive set of rules for software engineering inspired by the movie Zombieland. The rules are not simply a list of arbitrary guidelines, but rather a carefully crafted set of principles that are designed to promote efficie...
Organisations today are increasingly adopting cloud services from different providers to meet their business needs. However, managing multi-cloud infrastructure can be challenging, especially when it comes to infrastructure management, which is where...
What is AWS CloudFront? AWS CloudFront is a content delivery network (CDN). It securely delivers data, videos, applications, and APIs to customers globally with low latency and high transfer speeds. It offers a simple and cost-effective way to distri...
DevOps is more than just a software development methodology – it's a culture. The DevOps culture emphasizes 3 main pillars: collaboration, communication, and shared responsibility between development and operations teams. In this post, we will discus...
Engineering teams these days find it troublesome to build, test and deploy their mobile application changes locally without having to maintain the tools required for it. There is a lot of maintenance involved as you need to keep track of what versions of these tools have been installed to avoid compatibility issues when you’re building the application bundles, especially hybrid apps built on React Native.
One of the main issues with native IDEs from Apple and Google is the lack of automation. For example, in Android Studio, developers must manually upload the APK build to the Google Play Store. Similarly, while Apple does allow for builds to be uploaded to Testflight, developers still need to initiate the process manually. These steps require time and effort that could be better spent on building new features.
Developers would need to spend additional time configuring integrations with third-party systems and plugins, such as Google Firebase, Sentry, Microsoft App Center, Versioning, and Browserstack, among others.
These issues are not limited solely to the native languages supported by Apple and Google, but also affect other mobile frameworks, such as React Native, Flutter, and others.
fastlane, an automation tool that aids in handling all of the tedious tasks so you don't have to. It's by far, the easiest way to build and release your mobile apps.
fastlane can easily:
Distribute beta builds to your testers
Publish a new release to the app store in seconds
Reliably code sign your application - alleviates all of your headaches
Reliably maintain your provisioning profiles and application certificates in a Git repository
All actions in fastlane are written into lanes. Defining lanes are easy. Think of them as functions in any programming language of your choosing. You define all of your actions within that lane.
An example of a lane is as follows:
lane :beta do
increment_build_number
build_app
upload_to_testflight
end
So when it comes to executing that lane, all you do is run fastlane beta in your terminal.
In this article, we will look at setting up a fastlane script to build, sign and deploy an iOS application to Testflight.
As with most projects, you need to perform the initial project setup to support building your application, such as:
Installing your project dependencies
Install XCode and Android Studio
Install Java SDK
Setup git repository for Android and iOS certificates - will be explained later in the article
In ideal cases, you would have an Android application project and an iOS application project, both hosted in the same code repository as your project
projectFolder/
app/
scripts/
ios/
fastlane/
....
android/
fastlane/
....
package.json
.gitignore
...
In this case, you will want to initialise the fastlane folder within the respective android and ios project sub-directories.
Install fastlane
via Homebrew (brew install fastlane)
via RubyGems (sudo gem install fastlane)
Navigate your terminal to your respective android and ios project directory and run fastlane init
You should have a folder structure that is similar to the one below:
fastlane/
Fastfile
Appfile
The most interesting file is fastlane/Fastfile, which contains all the information that is needed to distribute your app.
Fastfile, you can start writing lanes:lane :my_lane do
# Whatever actions you like go in here.
end
You can start adding in actions into your lanes. fastlane actions can be found here.
Copy the following file structure to your Fastfile
default_platform(:ios)
def beta(arg1, arg2)
# You may use Ruby functions to write custom actions for your app deployment
end
platform :ios do
desc "Building the IPA file only"
lane :build_ios_app_ipa do
app_identifier = "com.appbundle.id"
beta("AppSchemeName", app_identifier)
end
end
default_platform(:ios) - Initialise your Fastfile file with a default platform
platform :ios do - Add all actions under a platform
From 5 to 6, it will inform fastlane that this particular Fastfile is purely for iOS operations. So instead of running the command fastlane <lane_name>, you will actually run fastlane ios <lane_name>. Therefore, anything parked under platform :ios do will be executed when lanes are invoked in your terminal.
💡 If you are well-versed in Ruby, you may write your own Ruby functions to help you write custom actions that you require for further flexibility, especially when it comes to building several apps with different environments across your organisation.
fastlane will identify them as an action regardless due to the fact that fastlane is written in Ruby.
In this article, we will follow writing the actions using a Ruby function. This is so we can promote action re-usability across other lanes deployments.
Before we start writing our functionality in the lanes, we first list down our action steps:
Setup API Key for App Store Connect (app_store_connect_api_key) - This will allow fastlane to connect to your App Store to perform other actions that requires user authentication
Setup CI (setup_ci) - This will setup a temporary keychain to work on your CI pipeline of your choice
Create and sync provisioning profiles and certificates (match) - This will help us maintain our provisioning profiles and certificates across your teams
Update code signing settings (update_code_signing_settings) - This is to update the code signing identities to match your profile name and app bundle identifier
Increment your app build number (increment_build_number) - This will automate your application build number by retrieving the latest Testflight build number and incrementing the value
Build the app (build_app) - This will build the app for us and generate a binary (IPA) file
Upload your binary to Testflight (upload_to_testflight) - This will automate the process of uploading the binary file to Testflight and informing your testers accordingly
Visit the following page. It will provide you a step-by-step process in generating an API key
Once you have generated a key, take note of:
Issuer ID
Key ID
Download the generated API key - A .p8 file
Store it in a secure location in which you can easily access them. Avoid storing them in the same repository as anyone in your organisation will have access to the company's Apple account.
def setup_api_key()
sh "if [ -d \"appstoreapi\" ]; then echo 'Folder exist, executing next step'; else git clone #{ENV['APPSTORE_API_GIT_URL']} appstoreapi; fi"
app_store_connect_api_key(
key_id: ENV['APPSTORE_KEY_ID'],
issuer_id: ENV['APPSTORE_ISSUER_ID'],
key_filepath: Dir.pwd + "/appstoreapi/AuthKey_xxx.p8",
)
end
In the snippet above, I am cloning a Git repository which contains my App Store Connect API key, followed by utilising the app_store_connect_api_key action from fastlane. It takes in several parameters, however, there are 3 vital parameters:
key_id - The Key ID from which you took note when you generated the API key
issuer_id - The Issuer ID from which you took note when you generated the API key
key_filepath - The file path to your .p8 file
This step will generate a hash that will be used to authenticate the App Store using JWT.
💡 I would highly recommend storing sensitive credentials or URLs and access them from an Environment Variable (.env) file in the same project folder - fastlane/.env
Once you have prepared the file, you can easily access any Environment Variable by simply passing in ENV['ENV_NAME'] into the Fastfile.
2. Define a Ruby function with 2 arguments
def beta(scheme, bundle_id)
end
Within this function, we specify the action steps we mentioned above
def beta(scheme, bundle_id)
setup_api_key() # Import the setup_api_key function
setup_ci() # Uses fastlane action to create a temporary keychain access on a CI pipeline
end
3. Utilise the match action from fastlane
match is a fastlane action that allows you to easily sync your certificates and provisioning profiles. It takes a new approach to iOS and macOS code signing, where you share one code signing identity across your engineering team to simplify the setup and prevent code signing issues. The foundation of match was built using the implementation of codesigning.guide concept.
You can store your code signing identities in:
Git repository
Google Cloud
Amazon S3 bucket
In this article, we have chosen to store it a Git repository. However, with the case of storing in a Git repository, you would need to provide a form of basic authorization in order for match to access and clone your repository.
In your Fastfile, you will need to encode your PAT with a Base64 encryption
authorization_token_str = ENV['GITHUB_TOKEN']
basic_authorization_token = Base64.strict_encode64(authorization_token_str)
The basic_authorization_token variable will be used in setting up the match implementation below.
match(
git_url: "<git_url>",
git_basic_authorization: basic_authorization_token,
readonly: true,
type: "appstore",
app_identifier: [
bundle_id
])
From the snippet above, this is a very simple implementation. Take note on the readonly parameter. This is crucial in creating and syncing your profiles and certs with your Apple Developer account. If you set readonly to false, you will allow match to automatically sync and create new profiles and certs, should it deem your existing certs and profiles expired or corrupted. Once it has provisioned the profiles, you can set readonly to true. This is to avoid egde cases where it might accidentally create new certs and profiles.
4. Update code signing identities
This step is mainly used to update the Xcode settings on a CI pipeline due to its default behaviour of selecting a default cert and profile from the Mac OS agent.
update_code_signing_settings(
use_automatic_signing: false,
path: "../ios/AppName.xcodeproj",
code_sign_identity: "iPhone Distribution",
profile_name: "match AppStore com.appbundle.id",
bundle_identifier: "com.appbundle.id"
)
From the above snippet, you can retrieve your profile_name and bundle_identifier from your Apple Developer account or taking note of them from the match step once it has been executed.
5. Increment Application build number
We simply increment the number by accessing your latest testflight build number and incrementing the value with 1.
increment_build_number({
build_number: latest_testflight_build_number + 1
})
puts "BUILD_NUMBER: #{lane_context[SharedValues::BUILD_NUMBER]}"
The puts command will print out the Build number in the console, which is shared across the lane context.
6. Build the application
This step will involve building your application to generate a binary (APK) file.
build_app(
workspace: "../ios/AppName.xcworkspace",
export_xcargs: "-allowProvisioningUpdates",
scheme: scheme,
clean: true,
silent: true,
sdk: "iphoneos"
)
puts "IPA: #{lane_context[SharedValues::IPA_OUTPUT_PATH]}"
The build_app action is provided by fastlane.
The puts command will print out the file path location of the IPA file in which you can use to manually upload to Testflight.
7. Upload the binary file to Testflight
This step will involve uploading your binary file to your Testflight account.
app_identifier = "com.appbunde.id"
upload_to_testflight(app_identifier: app_identifier)
upload_to_testflight is an action provided by fastlane.
The final lane should look something like this:
desc "Build and push a new build to TestFlight"
lane :release_build do
app_identifier = "com.appbundle.id"
beta("AppSchemeName", app_identifier) # The custom function we wrote earlier
upload_to_testflight(app_identifier: app_identifier)
end
When you execute fastlane ios release_build in your terminal, it will operate based on the aforementioned steps above.
As you can see, we utilised a Ruby function to group all common operations under the same roof so is to ensure:
Code re-usability
Consistency
Clean code
With the fastlane scripts, you can easily integrate it with any CI/CD tools of your choosing:
GitHub Actions
Gitlab CI
Azure Devops
Bitbucket Pipelines
When setting up your pre-requisite steps in your pipeline YAML file, you can simply include a bash script that executes your fastlane script
cd ios/android folder
fastlane ios/android release_build
The command above will execute your fastlane script by following the aforementioned steps above.
fastlane is a powerful tool that helps streamline your build process across your organisation. It can be used along side your existing CI/CD pipelines or as a standalone pipeline script to be used on your local machines or custom pipeline tools such as Buildkite. It would require additional steps such as, cloning the repository and checking out branches, however, all readily available from fastlane as actions.
Spend some time reading through the documentation as it contains a lot of actions out of the box that will prove useful for your engineering teams (match, pilot, cert, sigh, appium, xctool, supply, and many more) . Furthermore, they provide an extensive list of plugins for third-party integrations such as Firebase, App Center, Yarn, Android Versioning, Dropbox, Slack Upload, S3, Bugsnag and many more. You can supercharge your fastlane scripts by coupling it with a CI/CD tool, such as GitHub Actions, Bitbucket Pipelines or Azure DevOps. The sky's the limit!