Costruzioni iOS automatiche con GitHub azioni utilizzando Match

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

Consigliato per Nuove Costruzioni: Utilizzare Capgo Costruzione

Consigliamo ora 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 esistenti GitHub, ma le nuove costruzioni iOS dovrebbero utilizzare il Capgo CLI in modo da non dover mantenere i repository di Fastlane, Match, i runner di Xcode, i certificati e i script di caricamento.

Capgo Costruzione per CI/CD da Capgo

Evita la gestione di Fastlane Match, Xcode runner, certificato, profilo di provisioning e upload-script. Capgo Costruisci Esegue costruzioni native iOS firmate da __CAPGO_KEEP_0__ Build a partire dalla tua pipeline CI/CD esistente:

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

Prenotazioni

• I piani Capgo iniziano a $12/mese
• Includono 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

Prima di continuare con il tutorial…

• Assicurati di avere Fastlane installato sul tuo computer di sviluppo.
• Iscolto al programma di appartenenza a 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

https://github.com/feature/azioni

Il servizio è ‘gratuito’ fino al limite, a seconda della macchina scelta.
Stiamo utilizzando un macOS computer, potete vedere nel screenshot 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 ti piace, continuiamo…

📣 Nel post supponiamo di avere l'app creata in iTunes Connect, abbiamo i certificati dell'ecosistema Apple, tutto sarà copiato da Fastlane!

Scendiamo a fondo 🤿

Passaggi da seguire nel post

1. Utilizzare App Store Connect API con Fastlane Match
2. Requisiti
3. Creazione di una chiave App Store Connect API
4. Utilizzare una chiave App Store Connect API
5. Copiare i file Fastlane
6. Configurare Fastlane match

1. Utilizzare 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 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 Supporto Apple

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

Requisiti

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

1. cose.
2. ID rilasciatore.
3. ID chiave.

Creating an App Store Connect API Key

Creazione di una chiave App Store Connect __CAPGO_KEEP_0__","Per generare le chiavi, è necessario avere le autorizzazioni di amministratore in App Store Connect. Se non ne hai, puoi indirizzare la persona competente a questo articolo e seguire le istruzioni seguenti.

1 — Accedi a App Store Connect.

2 — Seleziona Utenti e Accesso.

3 — Seleziona la scheda di Integrazione.

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

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

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 autorizzazioniRaccomandiamo di selezionare Gestore App.

7 — Clicca su Genera.

Un API chiave 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.

Qui puoi trovare tutte e tre le informazioni necessarie.
<1> ID della richiesta.
<2> ID chiave.
<3> Clicca su "Scarica API Chiave" per scaricare la tua API chiave 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 condividere mai le tue chiavi, conserva le chiavi in un code repository o includi le chiavi nel codice del lato client code.

Utilizzando una chiave App Store Connect API

La chiave API (file p8 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 queste informazioni possono essere inserite in Fastlane utilizzando l'azione nuova di Fastlane, app_store_connect_api_key. Puoi imparare altre modalità in documentazione di Fastlane. Mostra questo metodo perché penso che sia la via più facile per lavorare con la maggior parte delle CI, dove puoi impostare le variabili di ambiente.

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

2. Copia i file Fastlane

Fastlane è una libreria Ruby creata per automatizzare compiti di sviluppo mobile comuni. Utilizzando Fastlane, puoi configurare

linee

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. Creare un cartella Fastlane alla radice del tuo progetto e copia i seguenti file: Fastfile Appfile Configura Fastlane match Fastlane match è un nuovo approccio per la firma di iOS. Fastlane match rende facile per i team gestire i certificati e i profili di provisioning richiesti per le vostre app iOS. 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.

ad esempio sul tuo account o organizzazione __CAPGO_KEEP_0__ personale. certificates, for example on your GitHub personal account or organization.

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

fastlane match init

Assegna l'URL del repository creato di recente.

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

Ora avrai all'interno della cartella Fastlane un file denominato

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

Matchfile e che dovrebbe essere impostato sull'URL HTTPS del repository dei certificati. In alternativa, puoi anche utilizzare SSH, ma richiede un passaggio diverso da eseguire. _git_url_Successivamente, andiamo a generare i certificati e inserire le credenziali richieste con Fastlane Match.

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

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

You verrai essere sollecitato a inserire una passphrase. Ricordatela correttamente perché verrà utilizzata successivamente da 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 autorizzazioni necessarie, forse questo post ti aiuterà a generare token di autenticazione per git.

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

Infine, apri il tuo project in Xcode, e aggiorna il profilo di provisioning per la configurazione di rilascio del tuo app.

Pochi punti da notare 💡

MATCH

For il CI/CD importare i certificati e i profili di provisioning, ha bisogno di 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 scopo → clicca quindi Generate token.

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

Poi sostituisci il file di match generato nel folder di 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 in GitHub Secrets, al posto di codificarli direttamente nel file.

Esecuzione elaborazione

In GitHub Azioni, si viene fatturati in base ai minuti utilizzati per l'esecuzione del proprio workflow CI/CD. Dall'esperienza, ci vuole circa 10-15 minuti prima che un build possa essere elaborato in App Store Connect.

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

Se si condividono le stesse preoccupazioni per il prezzo come faccio per i progetti privati, si può mantenere il skip_waiting_for_build_processing per true.

Cosa c'è dietro? Si deve aggiornare manualmente la conformità dell'app in App Store Connect dopo che il build è stato elaborato, per poter distribuire il build ai propri utenti.

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

3. Configura GitHub Azioni

Configura GitHub segreti

Ever wonder dove i valori di ENV vengono da? Bene, non è più un segreto – vengono dal tuo progetto di segreti.

1. APP_STORE_CONNECT_TEAM_ID - l'ID del tuo team di App Store Connect se sei in più team.

2. DEVELOPER_APP_ID - in App Store Connect, vai all'app → Informazioni sull'app → Scrolla verso il basso nella sezione General Information delle informazioni sull'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 portale dello sviluppatore se sei in più team.

5. FASTLANE_APPLE_ID - l'ID Apple o l'indirizzo email del developer che utilizzate per gestire l'app.

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

7. MATCH_PASSWORD - la passphrase che avete assegnato quando avete 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 - assegnate un utente e una password di keychain temporanei per il vostro 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 chiave o contenuto della chiave di .p8, verificatelo

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

4. Configura il file di workflow di GitHub

Creare un directory di workflow di GitHub.

cd .github/workflows

All'interno della 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 workflow dovrebbe essere attivato dopo ogni tag di GitHub se hai bisogno di automatizzare i tag, si prega di fare riferimento aAutomatic build and release con __CAPGO_KEEP_0__ actions Automatic build and release with GitHub actions 4. Configura il file di workflow di Capgo

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

5. Attiva il workflow

Crea un Commit

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

Attiva il workflow

Invia i nuovi commit alla branca main o development per attivare il workflow.

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

Puoi distribuire dal tuo computer 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 un file chiamato .env, nello stesso percorso di Fastfile, per poter creare lo stesso segreto proprietà trovate nel nostro _GitHub, a_s come segue:

.env file per il deploy da macchina locale

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

fastlane closed_beta

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

fastlane/*.env

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

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. Migliorerò 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 al provisionning. Connetti il tuo dispositivo al tuo mac e apri il menu del dispositivo Poi copia il tuo identificatore E poi avvia il comando: fastlane register_new_device ti chiederà di impostare un nome dispositivo e l'identificatore:

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

• Distribuzione continua per IOS utilizzando Fastlane e azioni GitHub
• Documentazione Fastlane
• Questo GitHub messaggio da @mrogunlana

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 Integrations, Integrazione CI/CD per i dettagli di implementazione in Integrazione CI/CD, e GitHub Azioni di integrazione per i dettagli di implementazione in GitHub Azioni di integrazione.