Constructions iOS automatiques avec GitHub Actions utilisant Match

La mise en place de CI/CD pour les applications Capacitor peut être complexe et fastidieuse. Voici ce dont vous avez besoin de savoir :

Recommandé pour les nouvelles constructions : Utilisez Capgo Build

Nous recommandons désormais d'utiliser Capgo Build avec le Capgo CLI pour les constructions natives Capacitor. Cette guide Fastlane Match est conservée pour les équipes qui maintiennent des pipelines d'actions existants GitHub, mais les nouvelles constructions iOS devraient utiliser le Capgo CLI afin que vous ne deviez pas maintenir les dépôts Fastlane, Match, les exécutables Xcode, les certificats et les scripts d'envoi.

Capgo Build pour CI/CD par Capgo

Évitez la maintenance de Fastlane Match, de l'exécutable Xcode, du certificat, du profil de provisionnement et du script d'envoi. Capgo Build exécute des constructions natives iOS signées à partir de votre pipeline CI/CD existant :

• Fonctionne avec votre pipeline: Déclenchez la Capgo construction à partir de GitHub Actions, GitLab CI, Jenkins ou scripts locaux après votre construction web et npx cap sync.
• Signature à partir de secrets CI: Gardez les clés App Store Connect, les certificats, les profils de provisionnement, les mots de passe et les identifiants d'équipe dans vos propres secrets CI.
• Aucune maintenance de l'exécuteur natif: La construction Capgo fournit des environnements de construction Apple maintenus, vous n'avez donc pas à gérer les exécutants macOS, les images Xcode, Fastlane ou les dépôts Match.
• Artéfacts et soumission: Téléchargez les artefacts signés pour les tests de qualité ou soumettez les versions de mise en production à travers le Capgo CLI.

Tarification

• Les plans Capgo commencent à 12 $/mois
• Inclut les mises à jour OTA et environ 15 constructions natives par mois
• Les minutes de construction supplémentaires sont facturées par minute à l'aide de crédits

Configurez la construction Capgo dans CI/CD

Guide de configuration manuelle

Ici, voici ce que vous devez faire :

La livraison continue pour iOS en utilisant Fastlane et GitHub Actions en utilisant match

Prérequis

Avant de continuer avec le tutoriel…

• Assurez-vous d'avoir Fastlane installé sur votre machine de développement.
• Membre du programme iOS.
• Souhait de lire 😆…
• Une équipe de nombreux devs, sinon nous recommandons d'utiliser fastlane cert pour des workflows plus simples.

Important sur le prix

https://github.com/features/actions

Le service est ‘gratuit’ jusqu'à la limite, en fonction de la machine choisie.
Nous allons utiliser un ordinateur macOS, vous pouvez voir dans l'écran d'aperçu son prix et ses limites (tarifs valables à la création de ce tutoriel, ils pourraient subir des changements à l'avenir) Une fois averti des exigences et des prix, si vous le souhaitez, nous continuons…

🔴 Dans l'article, on suppose que nous avons l'application créée dans iTunes connect, nous avons les certificats de l'écosystème Apple, tout sera copié par Fastlane !

📣 Allons-y !

Étapes à suivre dans l'article

Étapes à suivre dans cet article

1. Utiliser App Store Connect API avec Fastlane Match
2. Exigences
3. Créer une clé App Store Connect API
4. Utiliser une clé App Store Connect API
5. Copier les fichiers Fastlane
6. Configurer Fastlane match

1. Utiliser App Store Connect API avec Fastlane Match

À partir de février 2021, la deuxième factor d'authentification ou la vérification à deux étapes est obligatoire pour tous les utilisateurs pour se connecter à App Store Connect. Cette couche supplémentaire de sécurité pour votre ID Apple vous aide à vous assurer que vous êtes la seule personne qui peut accéder à votre compte.
De Support Apple

Pour commencer avec match, vous devez révoquer vos certificats existants. Mais ne vous inquiétez pas, vous obtiendrez le nouveau directement.

Exigences

To utiliser App Store Connect API, Fastlane nécessite trois choses.

1. Identifiant émetteur.
2. Identifiant de clé.
3. Clé de fichier ou contenu de clé.

Créer une clé App Store Connect API

Pour générer des clés, vous devez avoir les droits d'administrateur dans App Store Connect. Si vous n'avez pas ces droits, vous pouvez diriger la personne concernée à cet article et suivre les instructions suivantes.

1 — Se connecter à App Store Connect.

2 — Sélectionner Utilisateurs et accès.

3 — Sélectionnez l'onglet Intégration.

4 — Cliquez sur Générer la clé API ou le bouton Ajouter (+).

5 — Entrez un nom pour la clé. Le nom est uniquement pour votre référence et n'est pas partie de la clé elle-même.

6 — Dans Accès, sélectionnez le rôle pour la clé. Les rôles qui s'appliquent aux clés sont les mêmes rôles qui s'appliquent aux utilisateurs de votre équipe. Voir permissions de rôleNous vous recommandons de sélectionner Gestionnaire d'applications.

7 — Cliquez sur Générer.

Une clé API ne peut pas avoir son accès limité à des applications spécifiques.

Les informations de nom de clé, d'ID de clé, d'un lien de téléchargement et d'autres informations apparaissent sur la page.

Vous pouvez trouver ici les trois informations nécessaires.
<1> ID de l'incident.
<2> ID de clé.
<3> Cliquez sur « Télécharger la clé API » pour télécharger votre clé privée API. Le lien de téléchargement n'apparaît que si la clé privée n'a pas encore été téléchargée. Apple ne garde pas de copie de la clé privée. Vous pouvez donc la télécharger qu'une seule fois.

🔴 Stockez votre clé privée dans un endroit sûr. Vous ne devriez jamais partager vos clés, stocker des clés dans un code de dépôt, ou inclure des clés dans un code côté client code.

Utilisation d'une clé App Store Connect API

Le fichier de clé API (fichier p8 que vous téléchargez), l'ID de clé et l'ID émetteur sont nécessaires pour créer le jeton JWT d'autorisation. Il existe plusieurs façons de saisir ces informations dans Fastlane à l'aide de l'action nouvelle de Fastlane. app_store_connect_api_keyVous pouvez apprendre d'autres façons dans Documentation de Fastlane. Je montre cette méthode parce que je pense qu'il s'agit de la façon la plus facile de travailler avec la plupart des CI en place, où vous pouvez définir des variables d'environnement.

Maintenant, nous pouvons gérer Fastlane avec la clé d'App Store Connect API, c'est génial !

2. Copiez les fichiers Fastlane

Fastlane est une bibliothèque Ruby créée pour automatiser les tâches de développement mobile courantes. En utilisant Fastlane, vous pouvez configurer des « chemins » personnalisés qui rassemblent une série d'« actions » qui exécutent des tâches que vous effectueriez normalement à l'aide d'Android Studio. Vous pouvez faire beaucoup avec Fastlane, mais pour les besoins de ce tutoriel, nous utiliserons uniquement une poignée d'actions de base.

Créez un dossier Fastlane à la racine de votre projet et copiez les fichiers suivants : Fastfile

default_platform(:ios)

DEVELOPER_APP_IDENTIFIER = ENV["DEVELOPER_APP_IDENTIFIER"]
DEVELOPER_APP_ID = ENV["DEVELOPER_APP_ID"]
PROVISIONING_PROFILE_SPECIFIER = ENV["PROVISIONING_PROFILE_SPECIFIER"]
TEMP_KEYCHAIN_USER = ENV["TEMP_KEYCHAIN_USER"]
TEMP_KEYCHAIN_PASSWORD = ENV["TEMP_KEYCHAIN_PASSWORD"]
APPLE_ISSUER_ID = ENV["APPLE_ISSUER_ID"]
APPLE_KEY_ID = ENV["APPLE_KEY_ID"]
APPLE_KEY_CONTENT = ENV["APPLE_KEY_CONTENT"]
GIT_USERNAME = ENV["GIT_USERNAME"]
GIT_TOKEN = ENV["GIT_TOKEN"]

def delete_temp_keychain(name)
  delete_keychain(
    name: name
  ) if File.exist? File.expand_path("~/Library/Keychains/#{name}-db")
end

def create_temp_keychain(name, password)
  create_keychain(
    name: name,
    password: password,
    unlock: false,
    timeout: 0
  )
end

def ensure_temp_keychain(name, password)
  delete_temp_keychain(name)
  create_temp_keychain(name, password)
end

platform :ios do
  lane :build do
    build_app(
      configuration: "Release",
      workspace: "./ios/App/App.xcworkspace",
      scheme: "App",
      export_method: "app-store",
      export_options: {
        provisioningProfiles: { 
            DEVELOPER_APP_ID => "#{PROVISIONING_PROFILE_SPECIFIER}"
        }
      }
    )
  end
  lane :refresh_profiles do
    match(
      type: "development",
      force: true)
    match(
      type: "adhoc",
      force: true)
  end
  desc "Register new device"
  lane :register_new_device do  |options|
      device_name = prompt(text: "Enter the device name: ")
      device_udid = prompt(text: "Enter the device UDID: ")
      device_hash = {}
      device_hash[device_name] = device_udid
      register_devices(
                       devices: device_hash
                       )
    refresh_profiles
  end
  lane :closed_beta do
    keychain_name = TEMP_KEYCHAIN_USER
    keychain_password = TEMP_KEYCHAIN_PASSWORD
    ensure_temp_keychain(keychain_name, keychain_password)

    api_key = app_store_connect_api_key(
      key_id: APPLE_KEY_ID,
      issuer_id: APPLE_ISSUER_ID,
      key_content: APPLE_KEY_CONTENT,            
      duration: 1200,            
      in_house: false
    )

    match(
      type: 'appstore',
      git_basic_authorization: Base64.strict_encode64("#{GIT_USERNAME}:#{GIT_TOKEN}"),
      readonly: true,
      keychain_name: keychain_name,
      keychain_password: keychain_password,
      api_key: api_key
    )

    gym(
      configuration: "Release",
      workspace: "./ios/App/App.xcworkspace",
      scheme: "App",
      export_method: "app-store",
      export_options: {
        provisioningProfiles: { 
            DEVELOPER_APP_ID => "#{PROVISIONING_PROFILE_SPECIFIER}"
        }
      }
    )

    pilot(
      apple_id: "#{DEVELOPER_APP_ID}",
      app_identifier: "#{DEVELOPER_APP_IDENTIFIER}",
      skip_waiting_for_build_processing: true,
      skip_submission: true,
      distribute_external: false,
      notify_external_testers: false,
      ipa: "./App.ipa"
    )

    delete_temp_keychain(keychain_name)
  end
  lane :submit_review do
    version = ''
    Dir.chdir("..") do
      file = File.read("package.json")
      data = JSON.parse(file)
      version = data["version"]
    end
    deliver(
      app_version: version,
      submit_for_review: true,
      automatic_release: true,
      force: true, # Skip HTMl report verification
      skip_metadata: false,
      skip_screenshots: false,
      skip_binary_upload: true
    )
  end
end

Appfile

app_identifier(ENV["DEVELOPER_APP_IDENTIFIER"])
apple_id(ENV["FASTLANE_APPLE_ID"])
itc_team_id(ENV["APP_STORE_CONNECT_TEAM_ID"])
team_id(ENV["DEVELOPER_PORTAL_TEAM_ID"])

Configurez Fastlane match

Fastlane match is a new approach to iOS’s code signing. Fastlane match makes it easy for teams to manage the required certificates and provisioning profiles for your iOS apps.

Créez un nouveau dépôt privé nommé certificates, par exemple sur votre compte ou organisation GitHub personnel.

Initialisez Fastlane match pour votre application iOS.

fastlane match init

Sélectionnez ensuite l'option #1 (Stockage Git).

[01:00:00]: fastlane match supports multiple storage modes, please select the one you want to use:1. git2. google_cloud3. s3?

Attribuez l'URL du nouveau dépôt créé.

[01:00:00]: Please create a new, private git repository to store the certificates and profiles there[01:00:00]: URL of the Git Repo: <YOUR_CERTIFICATES_REPO_URL>

Vous avez maintenant à l'intérieur du dossier Fastlane un fichier nommé Matchfile et _git_url_il doit être configuré sur l'URL HTTPS du dépôt des certificats. Vous pouvez également utiliser SSH, mais cela nécessite une étape différente pour exécuter.

# ios/Matchfilegit_url("https://github.com/gitusername/certificates")storage_mode("git")type("appstore")

Ensuite, nous allons générer les certificats et entrer vos informations de connexion lorsque vous serez invité avec Fastlane Match.

Vous serez invité à entrer un mot de passe. Rappelez-vous-le correctement car il sera utilisé ultérieurement par les Actions de GitHub pour déchiffrer votre dépôt de certificats.

fastlane match appstore

Si tout s'est bien passé, vous devriez voir quelque chose comme cela :

[01:40:52]: All required keys, certificates and provisioning profiles are installed 🙌

Si vous avez rencontré un problème avec GitHub et les permissions nécessaires, peut-être ce post vous aidera à générer des jetons d'authentification pour Git.

Les certificats et les profils de provisionnement générés sont chargés dans les ressources du référentiel des certificats

Enfin, ouvrez votre project dans Xcode, et mettez à jour le profil de provisionnement pour la configuration de publication de votre application.

Quelques choses à noter 💡

MATCH

Pour que le CI/CD puisse importer les certificats et les profils de provisionnement, il doit avoir accès au référentiel des certificats. Vous pouvez faire cela en générant un jeton d'accès personnel (qui doit être utilisé avant) qui a l'autorisation d'accéder ou de lire les référentiels privés.

Dans GitHub, allez à Paramètres → Paramètres du développeur → Jetons d'accès personnels → cliquez Generate New Token → cochez la case repo scope → puis cliquez Generate token.

Vous avez une copie du jeton d'accès personnel généré. Vous l'utiliserez plus tard pour la variable d'environnement GIT_TOKEN.

Remplacez ensuite votre fichier de correspondance généré dans le dossier Fastlane par Matchfile

CERTIFICATE_STORE_URL = ENV["CERTIFICATE_STORE_URL"]
GIT_USERNAME = ENV["GIT_USERNAME"]
GIT_TOKEN = ENV["GIT_TOKEN"]
FASTLANE_APPLE_ID = ENV["FASTLANE_APPLE_ID"]

git_url(CERTIFICATE_STORE_URL)
storage_mode("git")
type("appstore")
git_basic_authorization(Base64.strict_encode64("#{GIT_USERNAME}:#{GIT_TOKEN}"))
username(FASTLANE_APPLE_ID)

Cela sera utilisé par les GitHub Actions pour importer les certificats et les profils de provisionnement. Et var sera défini dans les GitHub Secrets, au lieu de les coderdur dans le fichier.

Traitement de la construction

Dans les GitHub Actions, vous êtes facturé en fonction des minutes vous avez utilisées pour exécuter votre flux de CI/CD. D'expérience, il faut environ 10–15 minutes avant que la construction puisse être traitée dans App Store Connect.

For les projets privés, le coût estimé par build peut aller jusqu'à $0.08/min x 15 mins = $1.2, ou plus, en fonction de la configuration ou des dépendances de votre projet.

Si vous partagez les mêmes préoccupations concernant le tarification que moi pour les projets privés, vous pouvez conserver le skip_waiting_for_build_processing à true.

Quel est le piège ? Vous devez mettre à jour manuellement la conformité de votre application dans App Store Connect après que le build a été traité, pour distribuer le build à vos utilisateurs.

C'est juste un paramètre optionnel à mettre à jour si vous voulez économiser sur les minutes de build pour les projets privés. Pour les projets gratuits, ce n'est pas un problème du tout. Voir tarification.

3. Configuration GitHub Actions

Configurer GitHub secrets

Vous vous demandez peut-être où les valeurs des ENV sont venues ? Eh bien, ce n'est plus un secret – elles viennent de votre secret de projet. 🤦

1. APP_STORE_CONNECT_TEAM_ID - l'ID de votre équipe d'App Store Connect si vous en avez plusieurs.

2. DEVELOPER_APP_ID - dans App Store Connect, allez dans l'application → Informations sur l'application → Faites défiler vers le bas jusqu'à la General Information section de votre application et cherchez Apple ID.

3. DEVELOPER_APP_IDENTIFIER - l'identifiant de l'application de votre équipe.

4. DEVELOPER_PORTAL_TEAM_ID - l'ID de votre équipe de portail des développeurs si vous en avez plusieurs.

5. FASTLANE_APPLE_ID - l'ID Apple ou l'adresse e-mail de développeur que vous utilisez pour gérer l'application.

6. GIT_USERNAME & GIT_TOKEN - Votre nom d'utilisateur Git et votre jeton d'accès personnel.

7. MATCH_PASSWORD - la phrase secrète que vous avez assignée lors de l'initialisation de match, qui sera utilisée pour déchiffrer les certificats et les profils de provisionnement.

8. PROVISIONING_PROFILE_SPECIFIER - match AppStore <YOUR_APP_BUNDLE_IDENTIFIER>par exemple match AppStore com.domain.blabla.demo.

9. TEMP_KEYCHAIN_USER & TEMP_KEYCHAIN_PASSWORD - attribuer un utilisateur et un mot de passe temporaire pour votre flux de travail.

10. APPLE_KEY_ID — Clé App Store Connect API 🔺ID de clé.

11. APPLE_ISSUER_ID — Clé App Store Connect API 🔺ID émetteur.

12. APPLE_KEY_CONTENT — Clé App Store Connect API 🔺Fichier de clé ou contenu de la clé .p8 vérifiez-le, — L'URL du référentiel de vos clés Match (ex:

13. CERTIFICATE_STORE_URL https://__CAPGO_KEEP_0__.com/***/fastlane_match.git 4. Configurer le fichier de flux de travail github)

Créer un répertoire de flux de travail GitHub.

5. Configurez votre workflow GitHub

cd .github/workflows

Dans le dossier, créez un fichier nommé __CAPGO_KEEP_0__ workflow et ajoutez le contenu suivant : build-upload-ios.ymlCette tâche doit être déclenchée après chaque __CAPGO_KEEP_0__

name: Build source code on ios

on:
  push:
    tags:
      - '*'

jobs:
  build_ios:
    runs-on: macOS-latest
    steps:
      - uses: actions/checkout@v6
      - name: set Node.js
        uses: actions/setup-node@v6
        with:
          node-version: '24'
          cache: npm
      - name: Install dependencies
        id: install_code
        run: npm ci
      - name: Build
        id: build_code
        run: npm run build
      - uses: actions/cache@v5
        with:
          path: ios/App/Pods
          key: ${{ runner.os }}-pods-${{ hashFiles('**/Podfile.lock') }}
          restore-keys: |
            ${{ runner.os }}-pods-
      - name: Sync
        id: sync_code
        run: npx cap sync
      - uses: ruby/setup-ruby@v1
        with:
          ruby-version: 2.7.2
      - uses: maierj/fastlane-action@v2.3.0
        env:
          DEVELOPER_APP_IDENTIFIER: ${{ secrets.DEVELOPER_APP_IDENTIFIER }}
          DEVELOPER_APP_ID: ${{ secrets.DEVELOPER_APP_ID }}
          PROVISIONING_PROFILE_SPECIFIER: match AppStore ${{ secrets.DEVELOPER_APP_IDENTIFIER }}
          TEMP_KEYCHAIN_USER: ${{ secrets.TEMP_KEYCHAIN_USER }}
          TEMP_KEYCHAIN_PASSWORD: ${{ secrets.TEMP_KEYCHAIN_PASSWORD }}
          APPLE_ISSUER_ID: ${{ secrets.APPLE_ISSUER_ID }}
          APPLE_KEY_ID: ${{ secrets.APPLE_KEY_ID }}
          APPLE_KEY_CONTENT: ${{ secrets.APPLE_KEY_CONTENT }}
          CERTIFICATE_STORE_URL: https://github.com/${{ secrets.CERTIFICATE_STORE_REPO }}.git
          GIT_USERNAME: ${{ secrets.GIT_USERNAME }}
          GIT_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
          FASTLANE_APPLE_ID: ${{ secrets.FASTLANE_APPLE_ID }}
          MATCH_USERNAME: ${{ secrets.FASTLANE_APPLE_ID }}
          MATCH_PASSWORD: ${{ secrets.MATCH_PASSWORD }}
          APP_STORE_CONNECT_TEAM_ID: ${{ secrets.APP_STORE_CONNECT_TEAM_ID }}
          DEVELOPER_PORTAL_TEAM_ID: ${{ secrets.DEVELOPER_PORTAL_TEAM_ID }}
        with:
          lane: closed_beta
      - name: Upload release bundle
        uses: actions/upload-artifact@v2
        with:
          name: ios-release
          path: ./App.ipa
          retention-days: 60

This workflow should be triggered after each GitHub , si vous avez besoin d'automatiser les tags, veuillez vous référer àL'automatisation de la construction et de la mise en production avec __CAPGO_KEEP_0__ actions Automatic build and release with GitHub actions Ensuite, cette tâche va récupérer vos dépendances NodeJS, les installer et construire votre application JavaScript.

Chaque fois que vous envoyez un nouveau commit, une mise en production sera créée dans TestFlight.

Votre application n'a pas besoin d'utiliser Ionic, seule la base __CAPGO_KEEP_0__ est obligatoire.

Your App doesn’t need to use Ionic, only Capacitor base is mandatory., it can have old Cordova module, but Capacitor JS plugin should be preferred.

5. Déclencher la tâche

Créez un Commit

Faites un commitVous devriez voir le flux de travail actif dans le dépôt.

Déclenchez le flux de travail

Pousser les nouveaux commits vers la branche main ou development pour déclencher le flux de travail.

Après quelques minutes, la build devrait être disponible dans votre tableau de bord App Store Connect.

Pouvez-vous déployer depuis la machine locale ?

Oui, vous pouvez, et cela est sans effort.

Imaginez que vous avez un dépôt privé, et que vous avez utilisé toutes les minutes du plan gratuit et que vous ne voulez pas payer pour de nouvelles versions, ou peut-être préférez-vous soumettre l'application manuellement.

Allons-y

D'accord, nous devons d'abord créer dans mon_dossier_de_projet/fastlane un fichier appelé .env, juste dans le même dossier que Fastfile, afin de pouvoir créer les mêmes propriétés secrètes trouvées dans notre _GitHub, comme suit : a_s

.env fichier pour le déploiement à partir de la machine locale

Maintenant, vous pouvez aller à la console et lancer le Fastlane à partir de votre machine :

fastlane closed_beta

❌ Informations essentielles sur le fichier .env , car nous préférons ne pas exposer ces données, nous devons les ajouter dans notre .gitignore, quelque chose comme cela : ❌

fastlane/*.env

Il devrait fonctionner de la même manière que cela se produit à partir de GitHub Actions sur la machine distante, mais sur notre machine locale. 🍻

Exécution de terminal : $ Fastlane closed_beta

Si vous avez réussi à atteindre ce point, mes félicitations, vous avez maintenant un processus automatisé complet pour vos applications iOS avec Fastlane et GitHub Actions.

Chaque fois que vous envoyez un nouveau commit, une mise à jour sera construite dans le console Google Play, canal bêta. martin@capgo.app

martin@__CAPGO_KEEP_0__.app

Construire sur votre appareil Connectez votre appareil à votre Mac et ouvrez le menu appareil Ensuite, copiez votre identifiant fastlane register_new_device Trouvez l'identifiant iOS et

Si vous avez des problèmes

Si vous avez des problèmes avec le dispositif de développement qui ne peut pas tester, etc. Cela résout généralement le problème.

Il existe une commande magique qui peut vous sauver :

fastlane match nuke development
fastlane match development

Ensuite : Nettoyez le projet en maintenant la touche Shift(⇧) + Command(⌘) + K ou en sélectionnant Produit > Nettoyer (ce peut être étiqueté « Nettoyer le dossier de construction »)

Essayez ensuite de lancer à nouveau l'application sur votre appareil.

Merci

Cet article repose sur les articles suivants :

• La livraison continue pour iOS en utilisant Fastlane et les actions GitHub
• Documentation Fastlane
• Ce message GitHub de @mrogunlana

Continuez à partir de la construction automatique Capacitor d'IOS avec les actions GitHub en utilisant match

Si vous utilisez Automatic Capacitor IOS build with GitHub actions using match pour planifier l'automatisation CI/CD, connectez-le avec Capgo CI/CD pour le flux de travail du produit dans Capgo CI/CD, Capgo Builds natifs pour le flux de travail du produit dans Capgo Builds natifs, Capgo Intégrations pour le flux de travail du produit dans Capgo Intégrations, Intégration CI/CD pour les détails d'implémentation dans Intégration CI/CD, et GitHub Intégration d'actions pour les détails d'implémentation dans les intégrations GitHub Actions.