Aviral Srivastava

Posted on Sep 10

Mobile CI/CD (Fastlane)

#automation #devops #mobile

Ditch the Manual Grind: Unleashing the Power of Mobile CI/CD with Fastlane

Ever feel like building and releasing your mobile app is a bit like wrestling an octopus in a phone booth? You're juggling code, signing certificates, provisioning profiles, app store submissions, and a myriad of other arcane rituals. It's enough to make even the most seasoned developer yearn for a simpler time – perhaps a time when apps were printed on floppy disks and delivered by carrier pigeon.

Well, my friends, there’s good news! We’re not going back to the pigeon era. Instead, we can embrace the glorious world of Mobile CI/CD, and at its forefront, there's a superhero in disguise: Fastlane.

If you're a mobile developer and you haven't heard of Fastlane, buckle up. This gem is about to revolutionize your workflow, freeing you from the soul-crushing tedium of repetitive tasks and letting you focus on what you do best: building awesome apps.

What in the Heck is Mobile CI/CD, Anyway?

Before we dive headfirst into Fastlane, let's briefly unpack the acronym soup:

CI (Continuous Integration): Imagine this as a diligent digital butler who constantly checks your code. Every time a developer pushes new code, CI automatically builds your app and runs tests. This helps catch bugs early and ensures your codebase stays healthy.
CD (Continuous Delivery/Deployment): This is the next logical step. Once your code passes the CI checks, CD takes over and automates the process of preparing your app for release. This could mean building an installable package, signing it with the correct certificates, and even submitting it to app stores.

So, Mobile CI/CD is simply applying these principles to your iOS and Android applications. It’s about automating the entire journey from code commit to app store availability. And that, my friends, is where Fastlane shines.

Enter Fastlane: Your Mobile DevOps Wingman

Fastlane is an open-source platform that makes building and releasing your iOS and Android apps incredibly simple. Think of it as a collection of powerful command-line tools and scripts that orchestrate your entire release process. It’s built for developers, by developers, and it truly understands the pain points we face.

Instead of manually clicking through Xcode or Android Studio menus, writing complex scripts, or praying to the app store gods, you define your actions in a simple configuration file. Fastlane then executes these actions with a single command. It’s like having a highly efficient robot assistant who knows all the tricks.

Prerequisites: Getting Your Ducks (and Certificates) in a Row

Before you can unleash the full power of Fastlane, there are a few things you’ll need to have in place:

Ruby Installation: Fastlane is built on Ruby. You’ll need to have Ruby installed on your machine. Most macOS systems come with Ruby pre-installed, but it’s always a good idea to check and ensure you have a recent version. You can check your Ruby version by running:
```
ruby -v
```
If you need to install or update Ruby, tools like rbenv or RVM are your best friends.
Fastlane Installation: Installing Fastlane is as easy as pie. Navigate to your project's root directory in your terminal and run:
```
gem install fastlane
```
This installs Fastlane globally on your system, making it accessible from any project.
Project Setup: You’ll need to have your iOS and Android projects set up and ready to go. This means having your Xcode project (.xcodeproj or .xcworkspace) or your Android project (build.gradle files) configured correctly.
App Store Connect / Google Play Developer Account: To actually submit your app, you’ll need developer accounts with Apple (App Store Connect) and Google (Google Play Console).
Certificates and Provisioning Profiles (iOS): This is often the most daunting part for iOS developers. Fastlane can help manage these, but you’ll need to have your signing certificates and provisioning profiles set up correctly within your Apple Developer account. Fastlane’s cert and sigh tools are lifesavers here, automating the creation and management of these crucial files.
API Keys (Android): For seamless integration with Google Play, you'll need to set up a service account and download its JSON key file.

The Magic of Lanes: Your Workflow Blueprints

At the heart of Fastlane are lanes. A lane is essentially a named sequence of actions you want to perform. You define these lanes in a file called Fastfile located in a fastlane directory at the root of your project.

Let’s imagine a common iOS release workflow. We might have lanes for:

beta: Building and distributing a beta version to testers.
release: Preparing and submitting the final version to the App Store.
tests: Running all your unit and UI tests.

Here’s a peek at what a Fastfile might look like for iOS:

# fastlane/Fastfile

default_platform(:ios)

platform :ios do
  desc "Build and upload a new Beta build to TestFlight"
  lane :beta do
    increment_build_number(bump_type: "patch") # Automatically increment the patch version
    build_app(scheme: "YourAppScheme")       # Build your app
    upload_to_testflight                     # Upload to TestFlight
    # You can add notifications here too!
    slack(message: "Successfully uploaded a new Beta build to TestFlight! 🚀")
  end

  desc "Submit a new version to the App Store"
  lane :release do
    increment_build_number(bump_type: "minor") # Increment the minor version for a new feature release
    build_app(scheme: "YourAppScheme")
    submit_for_review(skip_waiting_for_build_processing: true) # Submit for review
    slack(message: "Successfully submitted a new version to the App Store! 🎉")
  end

  desc "Run all tests"
  lane :tests do
    scan(scheme: "YourAppScheme", device: "iPhone 14") # Run tests on a specific device
  end
end

# You can define lanes for Android here as well in a similar fashion
# platform :android do
#   # ... Android lanes
# end

To run one of these lanes, you simply open your terminal in the project directory and type:

fastlane beta

Or for the release lane:

fastlane release

Boom! Fastlane takes over, executes all the specified actions, and ideally, you’ll have a happy notification about a successful build or submission.

Key Fastlane Features: The Arsenal at Your Disposal

Fastlane is packed with a dizzying array of tools, or "actions," that cover almost every aspect of mobile development and distribution. Here are some of the heavy hitters:

For iOS:

cert: Automates the creation and maintenance of signing certificates. No more manually clicking through Keychain Access and Apple Developer portal!
```
cert(output_path: "certs") # Creates a certificate and saves it in the certs folder
```
sigh: Automates the creation and download of provisioning profiles. Say goodbye to the provisioning profile nightmare!
```
sigh(adhoc: true) # Creates an Ad Hoc provisioning profile
```
gym (formerly xcodebuild): Builds your iOS application. It’s a more streamlined and robust way to compile your app compared to directly using xcodebuild.
```
gym(scheme: "MyAppScheme", configuration: "Release")
```
deliver: Uploads your app metadata (screenshots, descriptions, release notes) and your app binary to App Store Connect.
```
deliver(submit_for_review: true)
```
snapshot: Automates the creation of screenshots for all your devices and languages. This is a HUGE time-saver for localization and app store listing.
```
snapshot(devices: ["iPhone 14", "iPad Pro (12.9-inch)"], languages: ["en-US", "fr-FR"])
```
pilot: Manages your TestFlight beta testers, including inviting, removing, and managing teams.
```
pilot(activate_users: true)
```

For Android:

gradle: Executes Gradle tasks for building, testing, and signing your Android app.
```
gradle(task: "assembleRelease") # Builds the release APK
```
supply: Uploads your app to the Google Play Store, including APKs/App Bundles, metadata, and screenshots.
```
supply(track: "production", apk: "./app/build/outputs/apk/release/app-release.apk")
```
screengrab: Similar to snapshot for iOS, it automates the creation of screenshots for your Android app.

Cross-Platform/General:

testing_deployer: A generic tool that can be used to deploy test builds to various platforms like Firebase App Distribution, S3, or custom endpoints.
slack: Send notifications to your Slack channel about build status, successes, or failures. This is crucial for team visibility.
```
slack(message: "Build #{ENV['CI_BUILD_NUMBER']} failed!", success: false)
```
jenkins: Integrates with Jenkins CI server for advanced automation.
git_commit: Commits changes to your Git repository.
tag: Creates Git tags for releases.

The Fastlane ecosystem is constantly growing, with many community-contributed actions available. You can explore them on the Fastlane actions website: https://docs.fastlane.tools/actions/

The Glorious Advantages of Embracing Fastlane

So, why should you jump on the Fastlane bandwagon? The benefits are substantial:

Massive Time Savings: This is the most immediate and impactful advantage. Automating repetitive tasks frees up hours – no, days – of your development time.
Reduced Human Error: Manual processes are prone to mistakes. Fastlane eliminates these errors, ensuring consistency and reliability in your builds and releases.
Faster Release Cycles: By streamlining the release process, you can ship updates to your users more frequently, keeping them engaged and providing value sooner.
Improved Team Collaboration: Fastlane provides a standardized way for your team to build and release. Everyone knows how it works, reducing the "bus factor" (where only one person knows how to do something critical).
Consistent Builds: You can be confident that every build produced by Fastlane is built and signed in the same way, preventing those frustrating "it works on my machine" scenarios.
Automated Testing: Integrating your test runs into Fastlane ensures that your code is always being tested, catching bugs before they reach your users.
Better Documentation of Processes: Your Fastfile acts as living documentation of your build and release pipeline, making it easy for new team members to understand.
Cost Savings (Indirectly): While Fastlane itself is free, the time saved and the reduction in errors can translate into significant cost savings for your organization.

But Wait, There's Always a Catch: The Disadvantages

No tool is perfect, and Fastlane is no exception. Here are some potential downsides to consider:

Learning Curve: While Fastlane aims for simplicity, there's still a learning curve involved, especially for developers new to Ruby or command-line tools. Understanding concepts like lanes, actions, and parameters takes time.
Initial Setup Complexity: Setting up Fastlane for the first time, particularly with complex certificate management for iOS, can be challenging. It often involves digging into documentation and troubleshooting.
Platform-Specific Quirks: While Fastlane tries to abstract away platform differences, you'll still encounter platform-specific issues and configurations that require attention.
Maintenance: As your project evolves, you'll need to update your Fastfile to reflect new build configurations, signing requirements, or distribution methods.
Reliance on External Tools: Fastlane relies on the underlying build tools of Xcode and Gradle, as well as the services provided by Apple and Google. If these platforms experience issues, your Fastlane workflows might be affected.
Debugging Challenges: Debugging a Fastlane workflow can sometimes be tricky. When an action fails, it might not always provide a crystal-clear error message, requiring some investigative work.

Fastlane in Action: A Real-World Example (iOS)

Let's say you've just finished a sprint and want to get a new build to your QA team. You'd typically:

Ensure your code is committed.
Manually increment the build number in Xcode.
Archive the project in Xcode.
Export the archive as an Ad Hoc or App Store distribution.
Upload the .ipa file to your distribution platform (e.g., Firebase App Distribution, internal server).

With Fastlane, this process becomes a single command:

First, ensure your Fastfile has a lane for this:

# fastlane/Fastfile

default_platform(:ios)

platform :ios do
  desc "Distribute a new build to QA"
  lane :qa_build do
    # Fetch the latest Git tag and use it for the version number
    latest_tag = last_git_tag
    version_number = latest_tag.split('_').first # Assuming tag is like "1.2.3_build_456"

    increment_build_number(bump_type: "patch") # Increment build number

    gym(
      scheme: "YourAppScheme",
      configuration: "Release",
      output_directory: "./builds",
      output_name: "YourApp_#{version_number}_#{build_number}.ipa", # Custom output name
      include_bitcode: true,
      export_method: "ad-hoc" # Or "app-store"
    )

    # Upload to Firebase App Distribution
    firebase_app_distribution(
      app: "YOUR_FIREBASE_APP_ID",
      groups: ["qa-team"],
      release_notes: "New build from #{latest_tag}"
    )

    slack(message: "Successfully uploaded a new QA build to Firebase App Distribution! 🔥")
  end
end

Then, in your terminal:

fastlane qa_build

Fastlane will automatically fetch the latest Git tag, increment your build number, build your app, package it as an .ipa file with a descriptive name, and upload it to Firebase App Distribution. All you did was type one command!

Conclusion: Embrace the Automation, Reclaim Your Sanity

Mobile CI/CD, powered by tools like Fastlane, isn't just a trend; it's a fundamental shift in how we build and release mobile applications. It’s about embracing efficiency, reducing stress, and ultimately, building better software faster.

While there might be an initial investment of time in setting things up, the long-term rewards are immense. Imagine a world where releasing updates isn't a dreaded, time-consuming ordeal but a smooth, automated process. That world is achievable with Fastlane.

So, if you’re tired of the manual grind, if you dream of more time to code and less time wrestling with certificates, it’s time to give Fastlane a serious look. Your future, less-stressed self will thank you. Happy automating!

DEV Community