Construction automatique d'IOS avec des actions GitHub utilisant Match

Configurer la construction continue et la livraison continue pour les applications Capacitor peut être complexe et fastidieux. Voici ce dont vous avez besoin de savoir :

Recommandé pour les nouvelles constructions : Utiliser la construction Capgo

On recommande maintenant d'utiliser Capgo Construction avec le Capgo CLI pour les constructions natives Capacitor. Cet guide Fastlane Match est conservé pour les équipes qui maintiennent des pipelines d'actions GitHub existants, 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 Construction 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 Construction exécute des constructions natives iOS signées à partir de votre pipeline CI/CD existant :

Fonctionne avec votre pipeline: Déclenchez la construction Capgo à partir d'actions GitHub, de GitLab CI, de Jenkins ou de scripts locaux après votre construction web et npx cap sync.
Signature à partir de secrets CI: Conservez 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.
Pas d'entretien de l'exécutant natif: Capgo Build fournit des environnements de construction Apple maintenus, vous n'avez donc pas à gérer les exécutables 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 qualité ou soumettez des builds de mise en production à l'aide du Capgo CLI.

Prix

Capgo plans start at $12/month
Les plans __CAPGO_KEEP_0__ commencent à 12 $/mois
Comprend les mises à jour OTA et environ 15 builds natifs par mois

Set up Capgo Build in CI/CD

context

Configurez __CAPGO_KEEP_0__ Build dans CI/CD

Continuous Delivery for iOS using Fastlane and GitHub Actions using match

Voici ce que vous devez faire :

Avant de continuer avec le tutoriel…

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

Importants sur le prix

Prix GitHub Action

https://github.com/features/actions

Le service est ‘gratuit’ jusqu'à la limite, en fonction de la machine choisie.
Nous allons utiliser un ordinateur macOS machine, vous pouvez voir dans l'écran d'affichage son prix et ses limites (tarifs au moment de 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

Utilisation de App Store Connect API avec Fastlane Match
Exigences
Création d'une clé App Store Connect API
Utilisation d'une clé App Store Connect API
Copiez les fichiers Fastlane
Configurez match Fastlane

1. Utilisez 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 n'ayez crainte, vous obtiendrez le nouveau directement.

Exigences

Pour pouvoir utiliser App Store Connect API, Fastlane a besoin de trois choses.

Identifiant émetteur.
Identifiant de clé.
Clé de fichier ou contenu de clé.

Création d'une clé API App Store Connect pour une application.

To generate keys, you must have Admin permission in App Store Connect. If you don’t have that permission, you can direct the relevant person to this article and follow the following instructions.

1 — Connectez-vous à App Store Connect App Store Connect.

2 — Sélectionnez Utilisateurs et accès Accès utilisateur App Store Connect.

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

Intégration App Store Connect __CAPGO_KEEP_0__

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

4 — Click Generate API Key or the Add (+) button.

App Store Connect API clés créent

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

App Store Connect API clés créent nom

6 — Dans l'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 rôle des permissions. Nous recommandons de sélectionner App manager.

7 — Cliquez sur Générer.

Un API clé d'accès ne peut pas être limité à des applications spécifiques.

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

App Store Connect télécharger les clés

Vous pouvez récupérer toutes les trois informations nécessaires ici.
1. ID de l'incident.
2. ID de la clé.
3. Cliquez sur « Télécharger la clé API » pour télécharger votre clé API privée. 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 conserve pas une 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 devez jamais partager vos clés, stocker les clés dans un code de dépôt, ou inclure les clés dans le code côté client code.

Utilisation d'une clé API d'App Store Connect

Le fichier de clé API (fichier p8 que vous téléchargez), l'ID de la clé et l'ID de l'é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 de Fastlane nouvelle. app_store_connect_api_key. Vous pouvez apprendre d'autres façons dans Documentation de Fastlane. Je montre cette méthode car je pense qu'elle est la plus facile à utiliser avec la plupart des CI, où vous pouvez définir des variables d'environnement.

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

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 « voies » personnalisées qui regroupent une série d'« actions » qui exécutent des tâches que vous effectueriez normalement à l'aide d'Android Studio. Vous pouvez faire beaucoup de choses 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 est une nouvelle approche de l'code signature pour iOS. Fastlane match facilite la gestion des certificats et des profils de provisionnement requis pour vos applications iOS.

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

Initialisez Fastlane match pour votre application iOS.

fastlane match init

Choisissez 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 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_doit être défini sur l'URL HTTPS du référentiel 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 saisir vos informations de connexion lorsque vous y serez invité avec Fastlane Match.

Vous serez invité à saisir un mot de passe. Rappelez-vous-le correctement car il sera utilisé ultérieurement par les Actions GitHub pour déchiffrer votre référentiel des 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 que ce post 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

Certificats App Store Connect

Dernièrement, ouvrez votre project dans Xcode, et mettez à jour le profil de provisionnement pour la configuration de sortie de votre application.

certificats XCode

Quelques choses à noter 💡

MATCH

Pour que la CI/CD importe 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'étendue pour accéder ou lire des dépôts privés.

Dans GitHub, allez à Paramètres → Paramètres du développeur → Jeton d'accès personnel → cliquez Generate New Token → cochez la repo étendue → puis cliquez Generate token.

Créer un jeton d'accès personnel

Ayant 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 match 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 la variable sera définie dans les GitHub Secrets, au lieu de les coderdur dans le fichier.

Traitement de la construction

Dans les GitHub Actions, Vous êtes facturés en fonction des minutes que 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.

Pour les projets privés, le coût estimé par construction peut aller jusqu'à $0,08/min x 15 min = $1,2, ou plus, en fonction de la configuration ou des dépendances de votre projet.

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

Quel est le piège ? Vous devez mettre à jour manuellement la conformité de votre application dans App Store Connect après le traitement du build, afin de distribuer le build à vos utilisateurs.

Ceci est simplement un paramètre facultatif à mettre à jour si vous souhaitez économiser des minutes de build pour les projets privés. Pour les projets gratuits, ce n'est vraiment pas un problème. tarification.

3. Configurer les Actions GitHub

Configurer les secrets GitHub

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

Configurer les secrets GitHub

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 → Descendez jusqu'à la section de votre application et cherchez General Information - votre identifiant de bundle d'application. Apple ID.

3. DEVELOPER_APP_IDENTIFIER - l'ID de votre équipe de portail de développeur si vous êtes dans plusieurs équipes.

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

5. FASTLANE_APPLE_ID &

6. GIT_USERNAME - Votre nom d'utilisateur Git et votre jeton d'accès personnel. GIT_TOKEN - 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.

7. MATCH_PASSWORD , par exemple.

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

9. TEMP_KEYCHAIN_USER - attribuez un utilisateur et un mot de passe de cléchain temporaire pour votre workflow. TEMP_KEYCHAIN_PASSWORD — App Store Connect __CAPGO_KEEP_0__ Clé 🔺ID de la clé.

10. APPLE_KEY_ID — App Store Connect API Key 🔺Key ID.

11. APPLE_ISSUER_ID — App Store Connect API Clé 🔺Identifiant de l'émetteur.

12. APPLE_KEY_CONTENT — App Store Connect API Clé 🔺Fichier de clé ou contenu de la clé de .p8, Pour utiliser Capacitor avec Appflow, vous devez configurer votre clé App Store Connect. Vous pouvez trouver les informations nécessaires dans votre compte App Store Connect. Pour plus d'informations, consultez la documentation d'Appflow.

13. CERTIFICATE_STORE_URL Vérifiez-le https://github.com/***/fastlane_match.git)

https://GitHub.com/*/fastlane_match.git**

4. Configurez le fichier de workflow GitHub

cd .github/workflows

Créez un répertoire de workflow __CAPGO_KEEP_0__. workflow Dans le build-upload-ios.ymlrépertoire, créez un fichier nommé

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

et ajoutez le contenu suivant. Ce workflow doit être déclenché après chaque GitHub tag, si vous avez besoin d'automatiser les tags, veuillez vous référer à Automatisation de la construction et de la mise en production avec des actions GitHub premierement.

Ensuite, ce flux de travail récupérera vos dépendances NodeJS, les installera et construira votre application JavaScript.

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

Votre application n'a pas besoin d'utiliser Ionic, seule la base Capacitor est obligatoire. Elle peut avoir des anciens modules Cordova, mais il est préférable d'utiliser le plugin Capacitor JS.

5. Déclencher le flux de travail

Créer un Commit

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

Déclenchez le flux de travail

Envoi les nouveaux commits vers la branch main ou development Déclenchez le flux de travail.

Commencez avec le commit

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

Tableau de bord Testflight

Peut-on déployer depuis la machine locale ?

Oui, vous pouvez, et c'est facile.

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

Alors allons-y

Ok, nous devons d'abord créer dans chemin de mon projet/fastlane chemin d'un fichier appelé .env, exactement dans le même chemin que Fastfile, afin de pouvoir créer les mêmes propriétés secrètes trouvées dans notre ___CAPGO_KEEP_0__, comme suit : properties found in our _GitHub, a_s below:

Maintenant, vous pouvez vous rendre au

terminal et lancer le et lancer le Fastlane à partir de votre machine :

fastlane closed_beta

❌ Il est essentiel de comprendre le fichier .env car nous ne voulons pas exposer ces données, nous devons donc les ajouter dans notre fichier .gitignore, quelque chose comme cela : ❌

fastlane/*.env

Elle devrait fonctionner de la même manière que si elle se produisait à partir des Actions de GitHub sur la machine distante, mais sur notre machine locale. 🍻

Exécution locale de Fastlane

Exécution de la console : $ Fastlane closed_beta

Si vous avez réussi à atteindre ce stade, mes félicitations, vous avez maintenant un processus entièrement automatisé pour vos applications iOS avec Fastlane et les Actions de GitHub.

Chaque fois que vous envoyez un nouveau commit, une mise à jour sera construite dans le console Google Play, canal bêta. Je vais améliorer ce blog en fonction de vos retours, si vous avez des questions ou des suggestions, veuillez me les faire par email. martin@capgo.app

Construire sur votre appareil

Si vous avez encore besoin de construire sur votre appareil, vous devez les ajouter manuellement à la provision. Connectez votre appareil à votre Mac et ouvrez le menu appareil Trouvez le menu iOS appareil Copiez ensuite votre identifiant Trouvez l'identifiant iOS fastlane register_new_device Et commencez ensuite la commande : Il vous demandera de définir un nom d'appareil et l'identifiant :

Définissez l'identifiant iOS

Si vous rencontrez des problèmes

Si vous rencontrez des problèmes avec le dispositif de développement qui ne peut pas être testé, etc. Ce problème est généralement résolu.

fastlane match nuke development
fastlane match development

Ensuite : Nettoyez le projet en maintenant Shift(⇧)+Command(⌘)+K ou en sélectionnant Produit > Nettoyer (il pourrait s'appeler « Nettoyer le dossier de construction »)

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

Merci

Cet article repose sur les articles suivants :

Continuez de Automatic Capacitor IOS build avec GitHub actions en utilisant match

Si vous utilisez Automatic Capacitor IOS build avec GitHub actions en utilisant match pour planifier l'automatisation CI/CD, connectez-l’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 GitHub Intégration d'actions.

Construction automatique d'Capacitor IOS avec des actions GitHub utilisant match