Costruzione iOS Automatica con GitHub Azioni utilizzando Match

La configurazione della CI/CD per le Capacitor app può essere complessa e richiede molto tempo. Ecco cosa devi sapere:

Consigliato per Nuove Costruzioni: Utilizza Capgo Costruzione

Adesso raccomandiamo di utilizzare Capgo Costruzione con il Capgo CLI per le costruzioni native Capacitor. Questa guida di Fastlane Match è mantenuta per i team che mantengono pipeline di azioni GitHub esistenti, ma le nuove costruzioni iOS dovrebbero utilizzare il Capgo CLI in modo da non dover mantenere Fastlane, Match repository, Xcode runner, certificati e script di caricamento.

Capgo Costruzione per la CI/CD da Capgo

Saltare la manutenzione di Fastlane Match, Xcode runner, certificato, profilo di provisioning e script di caricamento. Capgo Costruzione esegue costruzioni native iOS firmate dal tuo pipeline CI/CD esistente:

Lavora con il tuo pipeline: Avvia Capgo Build da GitHub Actions, GitLab CI, Jenkins o script locali dopo la tua build web e npx cap sync.
La firma da segreti CI: Mantieni le chiavi App Store Connect, i certificati, i profili di provisioning, le password e gli ID di team nei tuoi segreti CI.
: __CAPGO_KEEP_0__ Build fornisce ambienti di build Apple mantenuti, quindi non devi gestire i runner macOS, le immagini Xcode, Fastlane o i repository Match.: Scarica gli artefatti firmati per la QA o invia i release build attraverso il Capgo __CAPGO_KEEP_1__.
Prenotazione: Download signed artifacts for QA or submit release builds through the Capgo CLI.

: Includono aggiornamenti OTA e circa 15 build native al mese

Capgo plans start at $12/month
: Configura __CAPGO_KEEP_0__ Build in CI/CD
Prenotazione

Set up Capgo Build in CI/CD

Guida di configurazione manuale

Ecco cosa devi fare:

Continuous Delivery per iOS utilizzando Fastlane e GitHub Azioni utilizzando match

Requisiti

Prima di continuare con il tutorial…

Assicurati di avere Fastlane installato sulla tua macchina di sviluppo.
iscrizione al programma di sviluppo iOS.
Desiderio di leggere 😆…
Un team di molti sviluppatori, altrimenti consigliamo di utilizzare fastlane cert per flussi di lavoro più semplici.

Importante per il prezzo.

Prezzo GitHub Azione

https://github.com/caratteristiche/azioni

Il servizio è ‘gratuito’ fino al limite, a seconda della macchina scelta.
Stiamo utilizzando un macOS macchina, potete vedere nello screenshot il suo prezzo e i limiti (prezzi validi alla creazione del tutorial, potrebbero subire cambiamenti in futuro)

🔴 Una volta avvertiti dei requisiti e dei prezzi, se vi piace, continuiamo…

📣 Nel post si assume che abbiamo già creato l'applicazione in iTunes Connect, abbiamo i certificati dell'ecosistema Apple, tutto sarà copiato da Fastlane!

Vediamo di approfondire 🤿

Passaggi da seguire nel post

Utilizzando App Store Connect API con Fastlane Match
Requisiti
Creazione di una chiave App Store Connect API
Utilizzo di una chiave App Store Connect API
Copia dei file Fastlane
Configurazione di match Fastlane

1. Utilizzando App Store Connect API con Fastlane Match

Dal febbraio 2021, l'autenticazione a due fattori o la verifica a due passaggi è richiesta per tutti gli utenti per accedere a App Store Connect. Questo strato aggiuntivo di sicurezza per il tuo ID Apple aiuta a garantire che tu sia l'unica persona che può accedere al tuo account.
Dal Sostegno di Apple

Iniziare con match richiede di revocare i certificati esistenti. Ma non preoccuparti, avrai il nuovo uno direttamente.

Requisiti

To poter utilizzare App Store Connect API, Fastlane ha bisogno di tre cose.

ID rilasciatore.
ID chiave.
File o contenuto della chiave.

Creazione di una chiave App Store Connect API

Per generare le chiavi, è necessario avere le autorizzazioni di amministratore in App Store Connect. Se non si hanno queste autorizzazioni, si può indirizzare la persona competente a questo articolo e seguire le istruzioni seguenti.

1 — Accedere a App Store Connect.

2 — Selezionare Utenti e accessi.

Accesso all'utente di App Store Connect

3 — Seleziona la scheda di integrazione.

App Store Connect API Integration

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

App Store Connect API keys create

5 — Inserisci un nome per la chiave. Il nome è solo per la tua riferimento e non fa parte della chiave stessa.

App Store Connect API keys create name

6 — Sotto Accesso, seleziona il ruolo per la chiave. I ruoli che si applicano alle chiavi sono gli stessi ruoli che si applicano agli utenti del tuo team. Vedi permessi di ruolo. Consigliamo di selezionare amministratore di App.

7 — Clicca su Genera.

Una chiave API non può essere limitata ad accessi specifici per app.

Il nome della nuova chiave, l'ID chiave, un link di download e altre informazioni vengono visualizzati sulla pagina.

Download delle chiavi App Store Connect

Potete trovare tutte e tre le informazioni necessarie qui.
<1> ID della richiesta.
<2> ID chiave.
<3> Clicca su "Download chiave API" per scaricare la tua chiave privata API. Il link di download compare solo se la chiave privata non è stata ancora scaricata. Apple non conserva una copia della chiave privata. Pertanto, potete scaricarla solo una volta.

🔴 Conservate la vostra chiave privata in un luogo sicuro. Non dovete mai condividere le vostre chiavi, archiviare le chiavi in un repository code o includere le chiavi nel codice client-side code.

Utilizzo di una chiave API App Store Connect

È necessario il file della chiave API (file p8 che avete scaricato), l'ID chiave e l'ID emittente per creare il token JWT di autorizzazione. Ci sono diverse modalità per inserire queste informazioni nel Fastlane utilizzando l'azione nuova di Fastlane. app_store_connect_api_key. Potete imparare altre modalità in documentazione di Fastlane. Mostrerò questo metodo perché penso che sia la via più facile per lavorare con la maggior parte delle CI presenti, dove puoi impostare le variabili di ambiente.

Ora possiamo gestire Fastlane con la chiave App Store Connect API.

2. Copia i file Fastlane.

Fastlane è una libreria Ruby creata per automatizzare le attività di sviluppo mobile comuni. Utilizzando Fastlane, puoi configurare delle

lanes

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

personalizzate che raccolgono una serie di

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"])

azioni

che eseguono compiti che normalmente eseguiresti utilizzando Android Studio. Puoi fare molto con Fastlane, ma per i fini di questo tutorial, utilizzeremo solo una manciata di azioni di base. Crea una cartella Fastlane alla radice del tuo progetto e copia i seguenti file: Fastfile 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.

Configura Fastlane match certificates, for example on your GitHub personal account or organization.

Inizia Fastlane match per il tuo app iOS.

fastlane match init

Seleziona quindi l'opzione #1 (Archiviazione Git).

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

Assegna l'URL del repository appena creato.

[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>

Ora hai all'interno della cartella Fastlane un file denominato Matchfile e _git_url_Deve essere impostato sull'URL HTTPS del repository dei certificati. In alternativa, puoi utilizzare SSH, ma richiede un passo diverso da eseguire.

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

Successivamente, andiamo a generare i certificati e inserisci le tue credenziali quando richiesto con Fastlane Match.

Ti verrà chiesto di inserire una passphrase. Ricordala correttamente perché verrà utilizzata successivamente dalle GitHub Actions per decrittografare il tuo repository dei certificati.

fastlane match appstore

Se tutto è andato bene, dovresti vedere qualcosa di simile:

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

Se hai incontrato problemi con GitHub e le necessarie autorizzazioni, forse questo post aiuterà a generare i token di autenticazione per Git.

I certificati e i profili di provisioning generati vengono caricati nel repository dei certificati e delle risorse

I certificati di App Store Connect

Infine, apri il tuo project in Xcode, e aggiorna il profilo di provisioning per la configurazione di rilascio dell'applicazione.

I certificati di XCode

Alcune cose da notare 💡

MATCH

Per importare i certificati e i profili di provisioning, il CI/CD deve avere accesso al repository dei certificati. Puoi farlo generando un token di accesso personale (che dovrebbe essere utilizzato prima) che ha lo scopo di accedere o leggere repository privati.

In GitHub, vai a Impostazioni → Impostazioni dello sviluppatore → Token di accesso personale → clicca Generate New Token → seleziona repo scope → clicca quindi Generate token.

Crea token di accesso personale

Hai una copia del token di accesso personale generato. Lo utilizzerai in seguito per la variabile di ambiente GIT_TOKEN.

Poi sostituisci il file match generato nella cartella Fastlane con 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)

Questo verrà utilizzato dalle GitHub Actions per importare i certificati e i profili di provisioning. E var verrà impostato nelle GitHub Secrets, invece di codificarli direttamente nel file.

Elaborazione di costruzione

In GitHub Actions, hai un costo basato sulle minuti che hai utilizzato per eseguire il flusso di lavoro CI/CD. Dalla nostra esperienza, ci vogliono circa 10–15 minuti prima che una costruzione possa essere elaborata in App Store Connect.

Per progetti privati, il costo stimato per la costruzione può arrivare fino a $0,08/min x 15 min = $1,2, o più, a seconda della configurazione o delle dipendenze del tuo progetto.

Se condividi le stesse preoccupazioni per il prezzo come faccio per i progetti privati, puoi mantenere il skip_waiting_for_build_processing per true.

C'è un trucco? Dovrai aggiornare manualmente la conformità della tua app in App Store Connect dopo che la costruzione è stata elaborata, per poter distribuire la costruzione ai tuoi utenti.

Questo è solo un parametro facoltativo da aggiornare se desideri risparmiare sui minuti di costruzione per i progetti privati. Per i progetti gratuiti, questo non dovrebbe essere un problema per niente. Vedi prezzi.

3. Configura GitHub Azioni

Configura GitHub segreti

Ever wonder where the values of the __CAPGO_KEEP_0__ are coming from? Well, it’s not a secret anymore – it’s from your project’s secret. ENV are coming from? Well, it’s not a secret anymore – it’s from your project’s secret. 🤦

Configura i GitHub segreti

1. APP_STORE_CONNECT_TEAM_ID - l'ID del tuo team di App Store Connect se ne hai più di uno.

2. DEVELOPER_APP_ID - in App Store Connect, vai alla sezione dell'applicazione: - Informazioni sull'app - Scorri verso il basso nella sezione dell'app e cerca: General Information - l'ID del tuo bundle dell'applicazione. Apple ID.

3. DEVELOPER_APP_IDENTIFIER - l'ID del tuo team del Developer Portal se ne hai più di uno.

4. DEVELOPER_PORTAL_TEAM_ID - l'ID Apple o l'indirizzo email del tuo sviluppatore che utilizza per gestire l'app.

5. FASTLANE_APPLE_ID &

6. GIT_USERNAME - il tuo username Git e il tuo token di accesso personale. GIT_TOKEN - la passphrase che hai assegnato quando hai inizializzato match, verrà utilizzata per decrittografare i certificati e i profili di provisioning.

7. MATCH_PASSWORD - in App Store Connect, vai alla sezione dell'app →

8. PROVISIONING_PROFILE_SPECIFIER - match AppStore <YOUR_APP_BUNDLE_IDENTIFIER>, ad esempio. match AppStore com.domain.blabla.demo.

9. TEMP_KEYCHAIN_USER & TEMP_KEYCHAIN_PASSWORD - assegna un utente e una password temporanei per il tuo workflow.

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

11. APPLE_ISSUER_ID — App Store Connect API Chiave 🔺ID rilasciatore.

12. APPLE_KEY_CONTENT — App Store Connect API Chiave 🔺 File della chiave o contenuto della chiave. .p8, controlla.

13. CERTIFICATE_STORE_URL — L'URL del repository delle tue chiavi Match (ad esempio: https://github.com/***/fastlane_match.git)

4. Configura il file di workflow di GitHub.

Crea un directory di workflow di GitHub.

cd .github/workflows

Inside la workflow cartella, crea un file denominato build-upload-ios.ymle aggiungi il seguente contenuto.

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

Questa workflow dovrebbe essere attivata dopo ogni GitHub etichettase hai bisogno di automatizzare l'etichettatura, si prega di consultare Automatic build e rilascio con GitHub azioni prima.

Poi questa workflow estrarrà le dipendenze NodeJS, le installerà e costruirà il tuo'applicazione JavaScript.

Ogni volta che invii un nuovo commit, verrà costruito un rilascio in TestFlight.

La tua App non deve utilizzare Ionic, è sufficiente che abbia la base Capacitor; può avere moduli Cordova vecchi, ma è preferibile il plugin JS Capacitor.

5. Attiva la workflow

Creare un Commit

Fa un commit, dovresti vedere il flusso di lavoro attivo nel repository.

Attiva il flusso di lavoro

Invia i nuovi commit sulla branca main o development Per attivare il flusso di lavoro

Con un paio di minuti, il build dovrebbe essere disponibile nel tuo dashboard App Store Connect.

Pannello di Testflight

Sì, puoi distribuire dal tuo computer locale.

Appflow Plugins o

Sì, puoi farlo, e non è affatto difficile.

Immagina di avere un repository privato, e hai esaurito i minuti del piano gratuito e non vuoi pagare per nuove rilasci, o forse preferisci inviare l'applicazione manualmente.

Vediamo di farlo

Ok, prima dobbiamo creare in my_project_path/fastlane un file chiamato .env, giusto nella stessa cartella di Fastfile, per poter creare le stesse proprietà segrete trovate nel nostro ___CAPGO_KEEP_0__, come segue: properties found in our _GitHub, a_s below:

.file di ambiente per il deploy dal macchina locale

Ora, puoi andare al terminale e avviare il Fastlane dal tuo macchina:

fastlane closed_beta

❌ Informazioni essenziali sul file di ambiente poiché non desideriamo esporre questi dati, dobbiamo aggiungerli nel nostro .gitignorequalcosa del tipo: ❌

fastlane/*.env

Dovrebbe funzionare allo stesso modo di quanto accade con le GitHub Actions sulla macchina remota, ma sul nostro macchina locale. 🍻

Esecuzione locale di Fastlane

Esecuzione terminale: $ Fastlane closed_beta

Se sei arrivato fin qui, i miei complimenti, ora hai un processo completamente automatizzato per le tue app iOS con Fastlane e GitHub Azioni.

Ogni volta che invii un nuovo commit, verrà costruito un rilascio nel console di Google Play, canale beta. Metterò a punto questo blog con i tuoi feedback, se hai una domanda o una suggerenza, per favore lasciaci un messaggio via email martin@capgo.app

Costruisci sul tuo dispositivo

Se ancora hai bisogno di costruire sul tuo dispositivo, devi aggiungerli manualmente al provisioning. Collega il tuo dispositivo al tuo Mac e apri il menu del dispositivo Trovare dispositivo menu iOS Poi copia il tuo identificatore Trovare identificatore iOS E quindi avvia il comando: fastlane register_new_device Ti chiederà di impostare un nome dispositivo e l'identificatore: impostare identificatore ios

se hai problemi

Se hai problemi con il dispositivo di sviluppo non riesci a testare ecc. che di solito risolve il problema.

C'è un comando magico che può salvarti:

fastlane match nuke development
fastlane match development

Poi: Pulisci il progetto tenendo premuto Shift(⇧)+Command(⌘)+K o selezionando Product > Pulisci (potrebbe essere etichettato “Pulisci cartella di costruzione”)

Poi prova a eseguire nuovamente l'app sul tuo dispositivo.

Grazie

Questo blog si basa sugli articoli seguenti:

Continua da Automatic Capacitor IOS build con GitHub azioni utilizzando match

If sei in uso di Automatico Capacitor build IOS con GitHub azioni utilizzando match per pianificare l'automazione CI/CD, connettilo con Capgo CI/CD per il flusso di lavoro del prodotto in Capgo CI/CD, Capgo Build nativi per il flusso di lavoro del prodotto in Capgo Build nativi, Capgo Integrazioni per il flusso di lavoro del prodotto in Capgo Integrazioni, Integrazione CI/CD per il dettaglio di implementazione in Integrazione CI/CD, e GitHub Integrazione azioni per i dettagli di implementazione in GitHub Actions Integration.

Costruzione automatica Capacitor IOS con GitHub azioni utilizzando match

Costruzione iOS Automatica con GitHub Azioni utilizzando Match

Consigliato per Nuove Costruzioni: Utilizza Capgo Costruzione

Capgo Costruzione per la CI/CD da Capgo

: Includono aggiornamenti OTA e circa 15 build native al mese

Guida di configurazione manuale

Continuous Delivery per iOS utilizzando Fastlane e GitHub Azioni utilizzando match

Requisiti

Importante per il prezzo.

Vediamo di approfondire 🤿

1. Utilizzando App Store Connect API con Fastlane Match

Requisiti

Creazione di una chiave App Store Connect API

Utilizzo di una chiave API App Store Connect

2. Copia i file Fastlane.

azioni

Alcune cose da notare 💡

MATCH

Elaborazione di costruzione

3. Configura GitHub Azioni

4. Configura il file di workflow di GitHub.

5. Attiva la workflow

Appflow Plugins o

Costruisci sul tuo dispositivo

se hai problemi

Grazie

Continua da Automatic Capacitor IOS build con GitHub azioni utilizzando match