Costruzioni iOS automatiche con azioni di GitHub utilizzando Match

Impostare la CI/CD per le app Capacitor può essere complesso e richiede molto tempo. Ecco cosa devi sapere:

Consigliato per Nuove Costruzioni: Utilizza Capgo Costruzione

Ora consigliamo di utilizzare Capgo Costruzione con il Capgo CLI per le costruzioni native Capacitor. Questa guida di Fastlane Match viene mantenuta per le squadre che mantengono pipeline di azioni di GitHub esistenti, ma le nuove costruzioni iOS dovrebbero utilizzare il Capgo CLI per non dover mantenere i repository di Fastlane, Match, i runner di Xcode, i certificati e gli script di caricamento.

Capgo Costruzione per la CI/CD di Capgo

Evita la gestione di Fastlane Match, Xcode runner, certificato, profilo di provisioning e upload-script. Costruzione Capgo Esegue costruzioni native iOS firmate dal tuo flusso di lavoro CI/CD esistente:

Funziona con il tuo flusso di lavoro: Attiva la costruzione Capgo dal GitHub Actions, GitLab CI, Jenkins o script locali dopo la costruzione web e npx cap sync.
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.
Nessuna manutenzione del runner nativo: La costruzione Capgo fornisce ambienti di costruzione Apple mantenuti, quindi non devi gestire i runner macOS, le immagini Xcode, Fastlane o i repository Match.
Articoli e sottoscrizione: Scarica gli articoli firmati per la QA o sottoscrivi le versioni di rilascio attraverso il Capgo CLI.

Prezzi

I piani Capgo iniziano da 12€/mese
Include aggiornamenti OTA e circa 15 build native al mese
Minuti aggiuntivi per build sono fatturati per minuto attraverso crediti

Configura Capgo Build nel CI/CD

Guida di configurazione manuale

Ecco cosa devi fare:

Continua la consegna per iOS utilizzando Fastlane e GitHub Azioni utilizzando match

Prerequisiti

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 Action

https://github.com/features/actions

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

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

📣 In questo post supponiamo di avere già creato l'applicazione in iTunes Connect, di avere i certificati dell'ecosistema Apple, tutto verrà copiato da Fastlane!

Scendiamo in acqua!

Passaggi da seguire in questo post

Utilizzare 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 Fastlane match

1. Utilizzare 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 ulteriore strato di sicurezza per il tuo ID Apple aiuta a garantire che tu sia l'unica persona che può accedere al tuo account.
Da Support Apple

Iniziare con match richiede la revoca dei certificati esistenti. Non preoccuparti, riceverai il nuovo certificato direttamente.

Requisiti

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

ID emittente.
ID chiave.
File di chiave o contenuto di chiave.

Creazione di una chiave App Store Connect API

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

1 — Accedi a App Store Connect.

2 — Seleziona Utenti e accesso.

Accesso all'utente App Store Connect

3 — Seleziona la scheda di integrazione.

App Store Connect integrazione API

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

App Store Connect API chiavi creano

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

App Store Connect API chiavi creano 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 permessi di ruolo. Raccomandiamo di selezionare Gestore dell'app.

7 — Clicca su Genera.

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

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

Download delle chiavi App Store Connect

Ecco dove puoi trovare tutte le informazioni necessarie.
1. ID della questione.
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 scaricata ancora. Apple non conserva una copia della chiave privata. Pertanto, puoi scaricarla solo una volta.

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

Utilizzare una chiave API App Store Connect

La API chiave file (p8 file che scarichi), l'ID chiave e l'ID emittente sono necessari per creare il token JWT per l'autorizzazione. 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_key. Puoi imparare altre modalità in Documentazione Fastlane. Mostra questo metodo perché penso che sia la via più facile per lavorare con la maggior parte dei CI lì, dove puoi impostare le variabili di ambiente.

Ora possiamo gestire Fastlane con la chiave API App Store Connect, fantastico!

2. Copia i file Fastlane

Fastlane is a Ruby library created to automate common mobile development tasks. Using Fastlane, you can configure custom “lanes” which bundle a series of “actions” that perform tasks that you’d normally perform using Android studio. You can do a lot with Fastlane, but for the purposes of this tutorial, we’ll be using only a handful of core actions.

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 is una nuova approccio per iOS’s code firma. Fastlane match rende facile per i team gestire i certificati e i profili di provisioning richiesti per le vostre app iOS.

Creare un nuovo repository privato denominato certificates, ad esempio sul vostro GitHub account personale o organizzazione.

Avviare Fastlane match per la vostra app iOS.

fastlane match init

Poi selezionare l'opzione #1 (Storage Git).

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

Assegnare 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 avete all'interno della cartella Fastlane un file denominato Matchfile e _git_url_context: Pagina/Area: Sito web di marketing Capgo. Ruolo: Etichetta di navigazione breve o elemento di navigazione. Visualizzato in: pagina trust.astro. Chiave di messaggio `e` (E).

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

Prossimamente, andremo a generare i certificati e inserire le credenziali quando richiesto con Fastlane Match.

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 tutto è andato bene, dovresti vedere qualcosa del genere.

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

Se hai incontrato un problema con GitHub e hai i permessi necessari, forse questo post aiuterà a generare i token di autenticazione per Git.

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

Certificati App Store Connect

will help you to generate authentication tokens for git. project in Xcode, e aggiorna il profilo di provisioning per la configurazione di rilascio della tua app.

Certificati XCode

Qualche cosa da notare

MATCH

For the CI/CD to import the certificates and provisioning profiles, it needs to have access to the certificates repository. You can do this by generating a personal access token (should be used before) that has the scope to access or read private repositories.

In GitHub, vai a Impostazioni → Impostazioni sviluppatore → Token di accesso personale → clicca Generate New Token → seleziona la repo scope → quindi clicca 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 tuo 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 la variabile verrà impostata nelle GitHub Secrets, invece di codificarle nel file.

Elaborazione di costruzione

Nelle GitHub Actions, si sei fatturato in base ai minuti utilizzati per l'esecuzione del tuo workflow CI/CD. Dall'esperienza, ci vogliono circa 10-15 minuti prima che un build possa essere elaborato in App Store Connect.

Per i progetti privati, il costo stimato per build 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.

context: Pagina/Area: Pagina prodotti di aggiornamenti in tempo reale. Ruolo: Etichetta di navigazione o elemento UI breve. Chiave di messaggio `live_update_dynamic_label_to` (Etichetta di aggiornamento in tempo reale dinamica To).

Qual è il catch? Devi aggiornare manualmente la conformità del tuo app in App Store Connect dopo che il build è stato elaborato, per poter distribuire il build ai tuoi utenti. pricing.

3. Configura GitHub Azioni

Configura i GitHub segreti

Ever wonder da dove i valori dei ENV sono provenienti? Bene, non è più un segreto – provengono dal tuo progetto segreto. 🤦

Imposta 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 all'app → Informazioni sull'app → Scendi giù fino alla sezione General Information sezione della tua app e cerca Apple ID.

3. DEVELOPER_APP_IDENTIFIER - l'ID del tuo bundle dell'app.

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

5. FASTLANE_APPLE_ID - l'ID Apple o l'email del tuo sviluppatore che gestisce l'app.

6. GIT_USERNAME & GIT_TOKEN - Il tuo username 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 🔺ID Chiave.

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

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

13. CERTIFICATE_STORE_URL — La URL del tuo repo dei Match chiavi (ad esempio: https://github.com/***/fastlane_match.git)

4. Configura il file di flusso GitHub

Crea un directory di workflow GitHub.

cd .github/workflows

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

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

Questo flusso di lavoro dovrebbe essere attivato dopo ogni GitHub etichettaSe hai bisogno di automatizzare la creazione dei tag, consulta Automatic build and release con GitHub azioni prima.

Quindi questo flusso di lavoro 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 ha bisogno di utilizzare Ionic, solo la base Capacitor è obbligatoria, può avere vecchi moduli di Cordova, ma il plugin Capacitor JS dovrebbe essere preferito.

5. Attiva il workflow

Crea un Commit

Fai un commit, dovresti vedere il workflow attivo nel repository.

Attiva il workflow

Pubblica i nuovi commit sulla branch main o development per attivare il workflow.

Iniziato con commit

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

Dashboard di Testflight

Sì, puoi farlo e non è affatto difficile.

Sì, puoi farlo, e non richiede sforzo.

Imagine that you have a private repository, and you have used up the minutes of the free plan and you do not want to pay for new releases, or maybe you prefer to submit the application manually.

Ok, prima dobbiamo creare in

il mio percorso del progetto/fastlane progetto_mio_percorso/fastlane percorso di un file chiamato .env, nello stesso percorso Fastfile, per poter creare lo stesso segreto proprietà trovate nel nostro _GitHub, elencate di seguito:

file .env per il deploy da macchina locale

Ora, puoi andare al terminale e lanciare il Fastlane dalla tua macchina:

fastlane closed_beta

❌ Informazioni essenziali sul file .env file, preferiamo non esporre questo dato, quindi dobbiamo aggiungerlo .gitignore, qualcosa del genere: ❌

fastlane/*.env

Deve funzionare allo stesso modo di quanto accade da GitHub Actions sul computer remoto, ma sul nostro computer 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 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 lasciaci 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. Collega il tuo dispositivo al tuo Mac e apri il menu del dispositivo Cerca il menu iOS del dispositivo Poi copia il tuo identificatore trova identificatore ios E poi avvia il comando: fastlane register_new_device Vi chiederà di impostare un nome dispositivo e l'identificatore: imposta identificatore ios

se hai problemi

Se hai un problema con il dispositivo di sviluppo che non riesce a testare, ecco la soluzione.

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

Se stai utilizzando Automatic Capacitor IOS build with GitHub actions using match Per pianificare l'automazione CI/CD, connetti 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 workflow del prodotto in Capgo Integrazioni Integrazione CI/CD per i dettagli di implementazione in Integrazione CI/CD, e GitHub Integrazione azioni per i dettagli di implementazione in GitHub Integrazione azioni.

Costruzione automatica Capacitor IOS con GitHub azioni utilizzando match