Costruzioni automatiche iOS con GitHub Actions utilizzando Match

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

Consigliato per Nuove Costruzioni: Utilizza Capgo Build

Ora raccomandiamo di utilizzare Capgo Build with the Capgo CLI per costruzioni native Capacitor. Questa guida di Fastlane Match viene mantenuta per le squadre che mantengono pipeline di azioni esistenti GitHub, ma nuove costruzioni iOS dovrebbero utilizzare il Capgo CLI in modo da non dover mantenere i repository di Fastlane, Match, i runner Xcode, i certificati e i script di caricamento.

Capgo Costruisci per CI/CD da Capgo

Saltare la manutenzione dei repository di Fastlane Match, dei runner Xcode, dei certificati, dei profili di provisioning e dei script di caricamento. Capgo Costruisci esegue costruzioni native iOS firmate dal tuo pipeline CI/CD esistente:

Lavora con il tuo pipeline: Attiva Capgo Costruisci da GitHub Actions, GitLab CI, Jenkins o script locali dopo la costruzione web e npx cap sync.
La firma dai segreti di CI: Mantieni le chiavi di App Store Connect, i certificati, i profili di provisioning, le password e gli ID di squadra nei tuoi segreti di CI.
Non mantenere il runner nativo: Capgo Build fornisce ambienti di costruzione Apple mantenuti, quindi non dovrai gestire i runner macOS, le immagini Xcode, Fastlane o i repository Match.
Articoli e sottoscrizione: Scarica gli artefatti firmati per la QA o invia i build di rilascio attraverso il Capgo CLI.

Prezzi

Capgo piani iniziano da $12/mese
Inclusi gli aggiornamenti OTA e circa 15 build nativi al mese
I minuti di build aggiuntivi sono fatturati per minuto attraverso crediti

Configura Capgo Build in CI/CD

Guida di configurazione manuale

Ecco cosa devi fare:

Distribuzione continua per iOS utilizzando Fastlane e GitHub Azioni utilizzando match

Requisiti preliminari

Prima di continuare con il tutorial…

Assicurati di avere Fastlane installato sul tuo computer di sviluppo.
Iscrizione al programma di sviluppo iOS.
Desiderio di leggere 😆…
Un team di molti sviluppatori, altrimenti raccomandiamo di utilizzare fastlane cert per flussi di lavoro più semplici.

Importante per il prezzo

Prezzo GitHub Action

https://github.com/features/actions

Il servizio è ‘gratuito’ fino al limite, a seconda della macchina scelta.
Stiamo utilizzando una macchina macOS, potete vedere nel screenshot il suo prezzo e i limiti (prezzi alla data di creazione del tutorial, potrebbero subire cambiamenti in futuro) Una volta avvertiti dei requisiti e dei prezzi, se lo desiderate, 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!

📣 Scendiamo in acqua!

Passaggi da seguire nel post

Utilizzare App Store Connect __CAPGO_KEEP_0__ con Fastlane Match

Using App Store Connect API with Fastlane Match
Creazione di una chiave App Store Connect __CAPGO_KEEP_0__
Utilizzo di una chiave App Store Connect API
Utilizzo di App Store Connect API con Fastlane Match
Copia i file Fastlane
Configura match Fastlane

1. Utilizza App Store Connect API con Fastlane Match

A partire da 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 di sicurezza aggiuntivo per il tuo ID Apple aiuta a garantire che tu sia l'unica persona che può accedere al tuo account.
Da Supporto Apple

Per iniziare con match è necessario revocare i certificati esistenti. Ma non preoccuparti, avrai il nuovo uno direttamente.

Requisiti

Per poter utilizzare App Store Connect API, Fastlane richiede tre cose.

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

Creazione di una chiave API per App Store Connect

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 — Accedi a App Store Connect.

2 — Seleziona Utenti e accessi.

Accesso all'utente di App Store Connect

3 — Seleziona la scheda di integrazione.

Integrazione API di App Store Connect

4 — Clicca su Genera chiave API o sul pulsante Aggiungi (+).

App Store Connect API chiavi crea

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 chiavi crea nome

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 ruoli autorizzazioni. Consigliamo di selezionare App manager.

7 — Clicca su Genera.

L'accesso di una API chiave non può essere limitato a specifiche app.

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

App Store Connect download chiavi

Puoi prendere tutte e tre le informazioni necessarie qui.
<1> ID del problema.
<2> ID della chiave.
<3> Clicca su “Scarica la chiave API” per scaricare la tua chiave API privata. Il link di download compare solo se la chiave privata non è stata ancora scaricata. Apple non conserva una copia della chiave privata. Pertanto, puoi scaricarla solo una volta.

🔴 Conserva la tua chiave privata in un luogo sicuro. Non dovresti mai condividere le tue chiavi, archiviare le chiavi in un code repository o includere le chiavi nei code client-side.

Utilizzo di una chiave API App Store Connect

Il file della chiave API (file p8 che scarichi), l'ID della chiave e l'ID dell'emittente sono necessari per creare il token JWT per l'autenticazione. Ci sono diverse modalità in cui questi pezzi di informazione possono essere inseriti in Fastlane utilizzando l'azione nuova di Fastlane, app_store_connect_api_keyPuoi imparare altre modalità in Documentazione di FastlaneMostrerò questo metodo perché penso 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 API App Store Connect, fantastico!

2. Copia i file di Fastlane

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

Crea un folder Fastlane alla radice del tuo progetto e copia i seguenti file: 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"])

Configura Fastlane match

Fastlane match è un nuovo approccio per la firma code di iOS. Fastlane match rende facile per i team gestire i certificati e i profili di provisioning richiesti per le tue app iOS.

Crea un nuovo repository privato denominato certificates, ad esempio sul tuo GitHub account personale o organizzativo.

Inizia Fastlane match per la tua 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 del folder Fastlane un file denominato Il file Matchfile e dovrebbe essere impostato sull'URL HTTPS del repository dei certificati. Opzionalmente, puoi anche utilizzare SSH, ma richiede un passaggio diverso per eseguire. _git_url_Successivamente, andiamo a generare i certificati e inserisci le tue credenziali quando richiesto con Fastlane Match.

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

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

You will be prompted to enter a passphrase. Remember it correctly because it will be used later by GitHub Actions to decrypt your certificates repository.

fastlane match appstore

Se hai incontrato problemi con __CAPGO_KEEP_0__ e le necessarie autorizzazioni, forse questo

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

If you experienced any problem with GitHub and the necessary permissions, maybe this aiuterà a generare i token di autenticazione per git. I certificati e i profili di provisioning generati vengono caricati nel repository dei certificati delle risorse

I certificati di App Store Connect

Infine, apri il tuo

App Store Connect project in Xcode, e aggiorna il profilo di provisioning per la configurazione di rilascio dell'app.

Certificati 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 deve 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 scopo → 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.

Sostituisci quindi 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, al posto di codificarli direttamente nel file.

Elaborazione di costruzione

In GitHub Actions, sei fatturato in base ai minuti hai utilizzato per eseguire il flusso di lavoro CI/CD. Dall'esperienza, ci vuole circa 10–15 minuti prima che una costruzione possa essere elaborata in App Store Connect.

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

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

Cosa c'è dietro? Dovrai aggiornare manualmente la conformità della tua app in App Store Connect dopo che il build è stato elaborato, per poter distribuire il build ai tuoi utenti.

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

3. Configura GitHub Azioni

Configura GitHub segreti

Ti sei mai chiesto da dove vengono i valori di ENV Beh, non è più un segreto – vengono dal tuo progetto segreto. 🤦

Imposta 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 all'app → Informazioni sull'app → Scorrere verso il basso nella sezione General Information della tua app e cerca Apple ID.

3. DEVELOPER_APP_IDENTIFIER - l'identificatore del pacchetto della tua app.

4. DEVELOPER_PORTAL_TEAM_ID - l'ID del tuo team di Developer Portal se sei in più team.

5. FASTLANE_APPLE_ID - l'ID Apple o l'indirizzo email del tuo account di sviluppatore che utilizzi per gestire l'app.

6. GIT_USERNAME & GIT_TOKEN - il tuo nome utente Git e il tuo token di accesso personale.

7. MATCH_PASSWORD - la passphrase che hai assegnato quando hai inizializzato match, verrà utilizzata per decrittografare i certificati e i profili di provisioning.

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 di keychain 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 di 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

All'interno della cartella, crea un file denominato workflow e aggiungi il seguente contenuto. build-upload-ios.ymlQuesto workflow dovrebbe essere attivato dopo ogni __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

— App Store Connect GitHub Key 🔺 Issuer ID. tag, se hai bisogno di automatizzare il tag, consulta Costruzione automatica e rilascio con GitHub azioni primo.

Successivamente, questo workflow caricherà i tuoi dipendenze NodeJS, li installerà e costruirà il tuo'applicazione JavaScript.

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

La tua App non ha bisogno di utilizzare Ionic, solo la base Capacitor è obbligatoria. Può avere vecchi moduli Cordova, ma il plugin Capacitor JS dovrebbe essere preferito.

5. Attiva il workflow

Crea un Commit

Fai un commit, dovresti vedere l'attivo workflow nel repository.

Attivare il workflow

Pubblica i nuovi commit sul ramo main o development per attivare il workflow.

Avviato con commit

Dopo pochi minuti, il build dovrebbe essere disponibile nel tuo dashboard App Store Connect.

Dashboard Testflight

Puoi deployare dalla macchina locale?

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.

Andiamo per questo

Ok, prima dobbiamo creare in my_project_path/fastlane percorso di un file chiamato .env, nello stesso percorso di Fastfile, per poter creare lo stesso segreto proprietà trovate nel nostro _GitHub, a_s come segue:

file .env per il deploy dal macchina locale

Ora, puoi andare al terminale e lanciare il Fastlane da tuo computer:

fastlane closed_beta

❌ Informazioni essenziali sul .env il file, poiché non desideriamo esporre questi dati, dobbiamo aggiungerli nel nostro .gitignore, qualcosa del tipo: ❌

fastlane/*.env

Deve funzionare allo stesso modo di quando si esegue GitHub Actions sul computer remoto, ma sul nostro computer locale. 🍻

Esecuzione locale di Fastlane

Esecuzione del 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 Actions.

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 lascia un messaggio via email martin@capgo.app

Costruisci sul tuo dispositivo

Se ancora hai bisogno di costruire sul tuo dispositivo, devi aggiungerli manualmente alla configurazione di provisioning. Connetti il tuo dispositivo al tuo Mac e apri il menu del dispositivo trova dispositivo menu ios Copia quindi il tuo identificatore trova identificatore ios E quindi esegui il comando: fastlane register_new_device ti chiederà di impostare un nome dispositivo e l'identificatore: imposta identificatore ios

se hai problemi

Se hai problemi con il dispositivo di sviluppo non in grado di 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 Prodotto > Pulisci (potrebbe essere etichettato “Pulisci cartella di costruzione”)

Prova quindi a eseguire nuovamente l'app sul tuo dispositivo.

Grazie

Questo blog si basa sugli articoli seguenti:

Continua a procedere dall'edizione automatica Capacitor IOS con azioni GitHub utilizzando match

Se stai utilizzando Edizione automatica Capacitor IOS con azioni GitHub 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 Costruzioni native per il flusso di lavoro del prodotto in Capgo Costruzioni native, Capgo Integrazioni per il flusso di lavoro del prodotto in Capgo Integrazioni, Integrazione CI/CD per la dettaglio di implementazione in Integrazione CI/CD, e GitHub Integrazione delle azioni for the implementation detail in GitHub Actions Integration.

Costruzione automatica Capacitor IOS con GitHub azioni utilizzando match