fastlane can be simply described as the easiest way to automate building and release your iOS and Android apps, via a suite of tools that can work either autonomously or in tandem to accomplish tasks such as:
- Automation of building and packaging iOS apps producing
.ipafiles - Automation of taking screenshots of your app across different screen types, sizes, and languages
- Automation of uploading the screenshots and metadata and the packaged files to iTunes Connect directly, bypassing Xcode
- Automation of and management of refreshing, renewing, repairing, and managing signing certificates, provisioning profiles, and push notification profiles
- Synchronization and sharing of your certificates and profiles efficiently across to other team members
- Automation of managing and onboarding testers using your app, through TestFlight
- Automation of running tests for your app
The benefit of leveraging one or more fastlane actions is in your ability to save hours and even days, saving you the laborious task of having to submit, provision, and take screenshots manually, and instead allowing you to focus on what matters: that is, feature development. This is the mantra of Continuous Deployment and CD—the ability to code and release iteratively and rapidly, with minimal barriers. This is what fastlane is.
You also won't need to remember and call the individual fastlane actions individually; by using a Fastfile configuration file, you can store the actions in the sequence you want, under a grouping you can define and label, such as alpha testing, and call all the actions that belong to that grouping.
fastlane was the brainchild of Felix Krause (https://krausefx.com/), developed and open sourced on GitHub (https://github.com/fastlane/fastlane) back in 2014. After achieving a cult-like following by indie developers and eventually becoming mainstream and being used by thousands of companies, in late 2015, fastlane was acquired by Twitter (https://krausefx.com/blog/fastlane-is-now-part-of-fabric) as part of Twitter's Fabric development suite (https://fabric.io/login?redirect_url=%2Fhome). Just over a year later, in early 2017, Fabric itself was acquired by Google (https://krausefx.com/blog/fastlane-is-joining-google), as part of Google’s Firebase mobile development platform (https://firebase.google.com/), and the author moved to Google. Despite the project moving to Twitter and then Google, it very much remains an open source and active project.
fastlane is a Ruby-powered configuration file, called a Fastfile, grouped by lanes to serve different purposes and needs. For instance, you have a lane for deploying to the App Store, from which you have specific tasks, called actions, that you want to accomplish, such as incrementing your build number as you build your app, running actions such as cocoapods installment, running tests, taking screenshots, and uploading your app and associative metadata to the App Store. Take a look at the following code snippet:
lane :beta do # Increment build number in XCode increment_build_number # Build your app gym # Upload to TestFlight testflightend lane :appstore do increment_build_number # Run cocoapods install cocoapods # Run tests scan # Take screenshots snapshot # Provisioning sigh # Upload app, screenshots and meta-data deliver # Run your own custom script sh "./customScript.sh"... # Notify your contacts on Slack slack end
As shown in the preceding Fastfile code snippet, you would have another lane for the beta, to beta test your app and run through the automated tasks (actions) you would associate with beta testing, from incrementing your build count to building your app and pushing it to TestFlight. Of course, you could plug in other third-party tools, such as pushing to Fabric instead of TestFlight, as we will demonstrate in later chapters.
The real power of fastlane is in its extensibility, its ability to integrate with all of your familiar existing tools; there are currently over 170 custom actions (https://docs.fastlane.tools/actions/), according to the official website, with the ability to integrate with all major CI systems, such as Jenkins, which we will cover in later chapters.
Over the years, iOS developers have come to appreciate the pain that comes with interacting with the App Store, iTunes Connect, and the Apple developer portal. The manual process of having to go into the portal in order to deal with provisions profiles and to hand a new team member access to code sign the app frustrates the best of developers.
Updating the App Store screenshots each time the app's UI changes and each time a new iPhone or iPad screen size is introduced is laborious, especially when the screens have to be done for each locality (English, German, French, for instance).
Deploying the app to testers, and subsequently out to the App Store itself, is another cumbersome set of tasks that developers will often hesitate or drag their feet at. To deploy a new app to beta testers, developers have to go through the process of having to increment the app's bundle version number, push a new version back to Git, code sign the app with a valid provisioning profile, generate an IPA file, and then deploy it to TestFlight.
This is what makes fastlane a quintessential tool for the iOS developer; it breaks down the mental and physical barriers to CD through simple commands that, when grouped into lanes, allow not only developers but even less savvy technical folks to trigger a set of actions that accomplishes all of the preceding actions with minimal fuss. Reducing the cost of ownership by allowing any developer (or non-developer), as opposed to depending on one centralized subject-matter expert, means there are fewer bottlenecks.
fastlane consists of the following family of tools, for both iOS and Android:
Figure 2: Family of tools that are part of fastlane (Source: Fastlane.tools)
In brief, the fastlane tools accomplish the following automations:
- gym: Automates building and packaging of your iOS apps, generating
ipafiles - deliver: Uploads screenshots and metadata, as well as
.ipafiles to iTunes Connect directly, without having to manually do so via Xcode - snapshot: Automates taking screenshots of your app for different screen types/sizes, devices, and languages
- pem: Takes the hassle out of refreshing and renewing push notification profiles
- sigh: Takes the hassle out of provisioning your app and device
- produce: Automatically creates your iOS app on iTunes Connect and the dev portal, without the need to enter it manually on the website
- cert: Automatically maintains iOS code signing certificates
- pilot: With boarding, makes managing your TestFlight testers and builds easy, right from the Terminal
- match: Helps in syncing and sharing your certificates and profiles with other team members
- scan: Makes running automated tests on your apps a great deal more convenient
Furthermore, there are numerous custom actions that integrate with familiar tools you already have as part of your workflow, such as:
- Slack
- Cocoapods
- Gradle
- Crashlytics
- Git
- IFTTT
- Jenkins CI
- SSH
The suite of tools that fastlane provides are all due to Spaceship (https://github.com/fastlane/fastlane/tree/master/spaceship#readme), a framework that directly connects with the Apple developer center through APIs via HTTP, rather than previously scraping Apple's web services. This increases the speed of all the fastlane tools tremendously; in fact, it speeds up over 90% of actions, as it bypasses the overhead involved with loading images and other unnecessary assets not pertinent to the tasks at hand. The following is the logo of Spaceship:
The Spaceship is a Ruby library that exposes the Apple developer center and iTunes Connect API. It's superfast, well-tested, and supports all of the operations you can do via the browser.
Spaceship even handles authentication (including 2-factor authentication) with Apple's servers securely, storing the result in the user's local folder privately. You can try out Spaceship in Xcode Playgrounds by typing in fastlane spaceship (you will need to install pry first by typing in sudo gem install pry). Take a look at the following screenshot:
In the preceding playground screenshot, we created a new app called Spaceship App, by trying out a Spaceship command. Consult the Spaceship documentation by typing docs in Playground, and you can find some more recipes you can try directly on here. However, as with most, you won't need to work with Spaceship directly, as fastlane will appropriately facade a lot of the tasks through simpler actions, but it is useful to look a little under the hood and see how the fastlane engine works.