Aller au contenu

Fastlane + serveur Mac dédié : guide complet d'automatisation

Automatisez l'intégralité de votre processus de release iOS (builds, signature de code, captures d'écran et déploiement TestFlight) en utilisant Fastlane sur un serveur Mac Mini M4 dédié.

CI/CD 35 min de lecture Mis à jour en octobre 2026

Pourquoi Fastlane sur un Mac dédié ?

Fastlane est l'outil d'automatisation standard pour le développement iOS et Android. Il gère tout, de la signature de code au déploiement TestFlight. Exécuter Fastlane sur un Mac Mini M4 dédié vous offre :

Trousseau persistant

Les certificats de signature de code persistent entre les exécutions. Pas besoin d'importer/exporter à chaque build.

Builds incrémentaux rapides

DerivedData persiste, donc fastlane build prend 2-4 minutes au lieu de 15+.

Captures d'écran sur simulateur

Exécutez fastlane snapshot avec de vrais simulateurs pour toutes les tailles d'appareil.

Déploiements fiables

Un serveur Mac dédié et stable signifie moins de déploiements instables et de problèmes de signature de code.

Installer Fastlane

Connectez-vous en SSH à votre serveur de build Mac mini M4 dédié et installez Fastlane. Pour la CI, nous recommandons Bundler : un Gemfile fixe la version de Fastlane pour que chaque exécution utilise la même, tandis que Homebrew convient à un usage local. Évitez le Ruby système de macOS : les versions actuelles de Fastlane exigent Ruby 3.1 ou plus récent.

Option A : Bundler et un Gemfile (recommandé pour la CI)

# Ruby 3.1 or later (current Fastlane releases need it; the macOS system Ruby is older)
brew install ruby
echo 'export PATH="/opt/homebrew/opt/ruby/bin:$PATH"' >> ~/.zprofile
export PATH="/opt/homebrew/opt/ruby/bin:$PATH"

# In your project, a Gemfile that pins Fastlane
cd /path/to/your/ios-project
cat > Gemfile <<'EOF'
source "https://rubygems.org"

gem "fastlane", "~> 2.240"
gem "cocoapods"  # if using CocoaPods
EOF

bundle install

# Commit Gemfile and Gemfile.lock, then always run Fastlane through Bundler
bundle exec fastlane --version

Option B : Installation via Homebrew (usage local)

# Put the preinstalled Homebrew on your PATH (once per account)
echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile
eval "$(/opt/homebrew/bin/brew shellenv)"

# Install Fastlane with Homebrew
brew install fastlane

# Verify installation
fastlane --version

Initialiser Fastlane dans votre projet

# Navigate to your project directory
cd /path/to/your/ios-project

# Initialize Fastlane (with the Homebrew install, run: fastlane init)
bundle exec fastlane init

# Choose option 4: "Manual setup"
# This creates the fastlane/ directory with Appfile and Fastfile

Configurer Match pour la signature de code

Fastlane Match stocke vos certificats de signature de code et profils de provisionnement dans un dépôt Git privé ou un stockage cloud. Cela garantit que toutes les machines (et les membres de l'équipe) utilisent la même identité de signature.

Initialiser Match

# Initialize match (choose "git" for storage)
fastlane match init

# This creates fastlane/Matchfile

Configurer le Matchfile

# fastlane/Matchfile

git_url("https://github.com/your-org/ios-certificates.git")

storage_mode("git")

type("appstore")  # default type, can be overridden per lane

app_identifier(["com.yourcompany.myapp"])
username("your-apple-id@example.com")

# For CI environments, use App Store Connect API key instead of username/password
# api_key_path("fastlane/AuthKey.json")

Générer les certificats

# Generate development certificates and profiles
fastlane match development

# Generate App Store distribution certificates and profiles
fastlane match appstore

# For ad-hoc distribution
fastlane match adhoc

# On CI, use readonly mode to avoid accidentally creating new certs
fastlane match appstore --readonly

Créer un Fastfile (lanes de build, test, déploiement)

Voici un Fastfile complet avec des lanes pour compiler, tester et déployer votre application iOS :

# fastlane/Fastfile

default_platform(:ios)

platform :ios do

  # ---- SHARED ----

  before_all do
    setup_ci if ENV['CI']  # Configures keychain for CI environments
  end

  # ---- BUILD ----

  desc "Build the app for testing"
  lane :build do
    match(type: "development", readonly: true)

    build_app(
      workspace: "MyApp.xcworkspace",
      scheme: "MyApp",
      configuration: "Debug",
      destination: "generic/platform=iOS Simulator",
      # Outside the checkout, so it survives the next git clean
      derived_data_path: File.expand_path("~/DerivedData/MyApp"),
      skip_archive: true,
      skip_codesigning: true
    )
  end

  # ---- TEST ----

  desc "Run all unit and UI tests"
  lane :test do
    run_tests(
      workspace: "MyApp.xcworkspace",
      scheme: "MyApp",
      devices: ["iPhone 17"],  # any device from: xcrun simctl list devices available
      derived_data_path: File.expand_path("~/DerivedData/MyApp"),
      result_bundle: true,
      output_directory: "fastlane/test_results",
      parallel_testing: true,
      concurrent_workers: 4
    )
  end

  # ---- BETA ----

  desc "Build and push a new beta to TestFlight"
  lane :beta do
    # Ensure we are on a clean git state
    ensure_git_status_clean

    # Fetch App Store certificates
    match(type: "appstore", readonly: true)

    # Increment build number (the API key avoids an Apple ID login and 2FA)
    increment_build_number(
      build_number: latest_testflight_build_number(
        api_key_path: "fastlane/AuthKey.json"
      ) + 1
    )

    # Build the app
    build_app(
      workspace: "MyApp.xcworkspace",
      scheme: "MyApp",
      export_method: "app-store",
      derived_data_path: File.expand_path("~/DerivedData/MyApp"),
      output_directory: "fastlane/builds"
    )

    # Upload to TestFlight
    upload_to_testflight(
      skip_waiting_for_build_processing: true,
      api_key_path: "fastlane/AuthKey.json"
    )

    # Commit the version bump
    commit_version_bump(
      message: "chore: bump build number [skip ci]",
      force: true
    )

    # Tag the release
    add_git_tag(
      tag: "beta/#{lane_context[SharedValues::BUILD_NUMBER]}"
    )

    push_to_git_remote
  end

  # ---- RELEASE ----

  desc "Build and submit to App Store Review"
  lane :release do
    match(type: "appstore", readonly: true)

    # Increment version number (patch)
    increment_version_number(bump_type: "patch")
    increment_build_number(
      build_number: latest_testflight_build_number(
        api_key_path: "fastlane/AuthKey.json"
      ) + 1
    )

    build_app(
      workspace: "MyApp.xcworkspace",
      scheme: "MyApp",
      export_method: "app-store",
      derived_data_path: File.expand_path("~/DerivedData/MyApp")
    )

    upload_to_app_store(
      submit_for_review: true,
      automatic_release: false,
      api_key_path: "fastlane/AuthKey.json",
      precheck_include_in_app_purchases: false,
      force: true  # skip the HTML preview prompt, which fails in non-interactive CI
    )

    commit_version_bump(message: "chore: release #{lane_context[SharedValues::VERSION_NUMBER]}")
    add_git_tag
    push_to_git_remote
  end

  # ---- ERROR HANDLING ----

  error do |lane, exception|
    # Send notification on failure (Slack, email, etc.)
    # slack(
    #   message: "Lane #{lane} failed: #{exception.message}",
    #   success: false
    # )
  end
end

Configurer les captures d'écran automatisées

Fastlane Snapshot capture automatiquement les captures d'écran App Store sur plusieurs appareils et langues. Sur un Mac dédié, cela s'exécute de manière fiable sans concurrence pour les ressources.

# Initialize snapshot
fastlane snapshot init

# This creates:
# - fastlane/Snapfile
# - fastlane/SnapshotHelper.swift (add to UI test target)

Configurer le Snapfile

# fastlane/Snapfile

# Simulator names from: xcrun simctl list devices available
devices([
  "iPhone 18 Pro Max",
  "iPhone 17",
  "iPad Pro 13-inch (M5)"
])

languages([
  "en-US",
  "fr-FR",
  "de-DE",
  "ja"
])

scheme("MyAppUITests")
output_directory("./fastlane/screenshots")
clear_previous_screenshots(true)

# Speed up by running in parallel
concurrent_simulators(true)

Ajouter Snapshot à vos tests UI

// In your XCUITest file:
import XCTest

class ScreenshotTests: XCTestCase {

    override func setUp() {
        continueAfterFailure = false
        let app = XCUIApplication()
        setupSnapshot(app)
        app.launch()
    }

    func testHomeScreen() {
        snapshot("01_HomeScreen")
    }

    func testDetailScreen() {
        let app = XCUIApplication()
        app.cells.firstMatch.tap()
        snapshot("02_DetailScreen")
    }

    func testSettings() {
        let app = XCUIApplication()
        app.tabBars.buttons["Settings"].tap()
        snapshot("03_Settings")
    }
}

Ajouter une lane de captures d'écran

  # Add to your Fastfile:
  desc "Capture App Store screenshots"
  lane :screenshots do
    capture_screenshots
    frame_screenshots(white: true)  # Add device frames
    upload_to_app_store(
      skip_binary_upload: true,
      skip_metadata: true,
      api_key_path: "fastlane/AuthKey.json",
      force: true  # skip the HTML preview prompt when run in CI
    )
  end

Déployer sur TestFlight

Pour les environnements CI, utilisez la clé API App Store Connect au lieu des identifiants Apple ID. Cela évite les invites 2FA sur les serveurs sans écran.

Créer une clé API

  1. Allez sur App Store Connect > Utilisateurs et accès > Intégrations > API App Store Connect
  2. Cliquez sur le bouton + pour générer une nouvelle clé API
  3. Sélectionnez le rôle App Manager
  4. Téléchargez le fichier .p8
  5. Notez le Key ID et l'Issuer ID

Créer le JSON de la clé API

# fastlane/AuthKey.json
{
  "key_id": "YOUR_KEY_ID",
  "issuer_id": "YOUR_ISSUER_ID",
  "key": "-----BEGIN PRIVATE KEY-----\nYOUR_P8_KEY_CONTENT\n-----END PRIVATE KEY-----",
  "in_house": false
}

# IMPORTANT: Add this to .gitignore!
echo "fastlane/AuthKey.json" >> .gitignore

Exécuter le déploiement

# Deploy to TestFlight
fastlane beta

# Or run the full release pipeline
fastlane release

Intégrer avec le CI/CD

Fastlane s'intègre parfaitement avec n'importe quelle plateforme CI/CD. Voici un exemple GitHub Actions utilisant votre runner Mac Mini M4 auto-hébergé :

# .github/workflows/deploy.yml
name: Deploy to TestFlight

on:
  push:
    branches: [ main ]

jobs:
  deploy:
    runs-on: [self-hosted, macOS, ARM64, M4]
    # push_to_git_remote needs write access: the token is read-only by default
    permissions:
      contents: write

    env:
      # Xcode for this job, without sudo
      # (preinstalled Xcode; for another version, use the path from `xcodes installed`)
      DEVELOPER_DIR: /Applications/Xcode.app/Contents/Developer
      MATCH_PASSWORD: ${{ secrets.MATCH_PASSWORD }}
      # base64 of "github_username:personal_access_token", for example:
      #   echo -n your_github_username:your_personal_access_token | base64
      MATCH_GIT_BASIC_AUTHORIZATION: ${{ secrets.MATCH_GIT_BASIC_AUTHORIZATION }}

    steps:
      - name: Checkout
        uses: actions/checkout@v7

      - name: Use the Homebrew Ruby (3.1 or later)
        run: echo "/opt/homebrew/opt/ruby/bin" >> "$GITHUB_PATH"

      - name: Set up App Store Connect API Key
        run: |
          mkdir -p fastlane
          echo '${{ secrets.APP_STORE_CONNECT_API_KEY }}' > fastlane/AuthKey.json

      - name: Install dependencies
        run: |
          bundle install
          pod install  # if using CocoaPods

      - name: Deploy to TestFlight
        run: bundle exec fastlane beta

      - name: Clean up API key
        if: always()
        run: rm -f fastlane/AuthKey.json

Bonnes pratiques

Utiliser Bundler pour le verrouillage de version Fastlane

Ajoutez un Gemfile avec une version Fastlane fixée. Exécutez bundle exec fastlane pour garantir des versions cohérentes dans tous les environnements.

Utiliser les clés API App Store Connect, pas les identifiants Apple ID

Les clés API évitent les invites 2FA et sont plus sécurisées pour les environnements CI.

Utiliser match --readonly en CI

Empêche la création accidentelle de nouveaux certificats. Ne générez des certificats manuellement que lorsque c'est nécessaire.

Utiliser setup_ci dans les environnements CI

Cela crée un trousseau temporaire pour éviter de polluer le trousseau système et empêche les boîtes de dialogue de permission du trousseau.

Conserver DerivedData pour des builds plus rapides

Sur un Mac dédié, spécifiez derived_data_path pour réutiliser les artefacts de build entre les exécutions.

Automatisez vos releases iOS dès aujourd'hui

Obtenez un Mac Mini M4 dédié et exécutez Fastlane avec des builds illimités. À partir de 85 $/mois (USD, HT).

Prix My Remote Mac en USD, hors taxes.

Besoin de plus de détails ?

Parcourez la documentation complète : guides pas à pas, références de configuration et dépannage.

Ouvrir la documentation →