Costruzione automatica di IOS con Capacitor azioni con certificato GitHub

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

Consigliato per Nuove Costruzioni: Utilizza la Capgo Costruzione

Ora raccomandiamo di utilizzare Capgo Costruzione con il Capgo CLI per le costruzioni native Capacitor. Questa guida Fastlane è mantenuta per i team che mantengono pipeline di azioni di GitHub esistenti, ma nuove costruzioni di IOS dovrebbero utilizzare il Capgo CLI per non dover mantenere Fastlane, esecutori Xcode, certificati e script di caricamento.

Capgo Costruzione per la CI/CD di Capgo

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

Lavora con il tuo flusso di lavoro: Attiva Capgo Build 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 App Store Connect, i certificati, i profili di provisioning, le password e gli ID di team nei tuoi segreti CI.
Non è necessario mantenere il runner nativo: Capgo Build fornisce ambienti di costruzione Apple mantenuti, quindi non devi gestire i runner macOS, le immagini Xcode o le strade di Fastlane.
Articoli e sottoscrizione: Scarica gli articoli firmati per la QA o sottoscrivi le costruzioni di rilascio attraverso il Capgo CLI.

Prezzi

I piani di Capgo iniziano a $12/mese
Include aggiornamenti OTA e circa 15 costruzioni native al mese
Minuti di build aggiuntivi sono fatturati per minuto attraverso i crediti

Configura Capgo Build nel CI/CD

Guida di configurazione manuale

Ecco cosa devi fare:

Continua la consegna continua per iOS utilizzando Fastlane e GitHub Azioni e certificato

Prerequisiti

Prima di continuare con il tutorial:

Assicurati di avere Fastlane installato sulla tua macchina di sviluppo.
Assicurati di essere parte del programma di iscrizione iOS.

Importante informazione sui prezzi

Prezzo GitHub Action

https://github.com/caratteristiche/azioni

Il servizio è ‘gratuito’ fino al limite, a seconda della macchina scelta.
Siamo pronti ad utilizzare una macOS 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, continuiamo.

Nota: In questo post si presuppone che l'app sia già creata in App Store Connect. Le informazioni importanti verranno copiate da Fastlane!

Cosa imparerai in questo tutorial

Passaggi da seguire in questo post

Utilizzando App Store Connect API con Fastlane
- Requisiti:
  - Creazione di una chiave App Store Connect API
  - Utilizzo di una chiave App Store Connect API
Copia dei file Fastlane
Configurazione delle azioni GitHub

1. Utilizzando App Store Connect API con Fastlane

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

Requisiti

In modo che Fastlane possa utilizzare App Store Connect API per caricare il tuo app, devi fornire i seguenti tre le cose:

ID emittente
ID chiave
File di chiave o contenuto di chiave

Ottenere una chiave di App Store Connect API

Per generare le chiavi, è necessario avere la permessi di amministratore in App Store Connect. Se non si hanno questi permessi, si può indirizzare la persona competente a questo articolo.

Accedi a App Store Connect.
Scegli Utenti e Accesso.

Accesso all'utente di App Store Connect

3 — Seleziona la scheda di integrazione.

App Store Connect API Integrazione

Clicca su Genera API Chiave o sul pulsante Aggiungi (+).

Le chiavi App Store Connect API creano

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 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. Consigliamo di selezionare Gestore app.

Clicca su Genera.

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

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

Download delle chiavi App Store Connect

Puoi ottenere tutte e tre le informazioni necessarie qui.
1. ID della richiesta. (APPLE_ISSUER_ID segreto)
2. ID della chiave. (APPLE_KEY_ID segreto)
3. Clicca su "Download la chiave API" per scaricare la tua chiave privata API. Il collegamento 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, archivia le chiavi in un code repository o includile nei code client-side.

Utilizzo di una chiave App Store Connect API

Il file della chiave API (file p8 che hai scaricato), l'ID della chiave e l'ID dell'emittente sono necessari per creare il token JWT di autorizzazione. Ci sono diverse modalità in cui questa informazione può essere passata in Fastlane. Ho scelto di utilizzare l'azione nuova di Fastlane app_store_connect_api_keyPuoi imparare altre modalità in Documentazione FastlaneMostrerò questo metodo perché penso che sia il modo più facile per lavorare con la maggior parte delle CI, dove puoi impostare le variabili di ambiente.

Per favore converte il file p8 che hai scaricato in Base64 e memorizzalo come un segreto (APPLE_KEY_CONTENT).

base64 -i APPLE_KEY_CONTENT.p8 | pbcopy

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

2. Certificati

Apre XCode e vai a Impostazioni > Conti > ID Apple > Team e seleziona il tuo team.

Code identità di firma

Clicca su Gestisci certificati.

Se non hai già creato un certificato, puoi creare un nuovo certificato.

Clicca su + e seleziona Distribuzione Apple

Distribuzione Apple

Poi devi andare alla chiave di sistema per scaricare il certificato come un .p12 file.

To fare ciò, devi andare al keychain e spostarti sul login keychain e quindi sulla scheda I miei Certificati.

I miei Certificati

Poi puoi selezionare il certificato che desideri scaricare. (Cerca per la data del certificato)

E quindi fai clic destro sulle chiavi private del certificato e seleziona Export.

Scegli il formato del file Scambio di Informazioni Personali (.p12).

Questo scaricherà il certificato come un .p12 file.

Per favore, apri il file in un terminale e utilizza il seguente comando per convertirlo in Base64:

base64 -i BUILD_CERTIFICATE.p12 | pbcopy

Questo diventerà il tuo BUILD_CERTIFICATE_BASE64 segreto. Inoltre, quando richiesto, fornisci la password del certificato. Questa password sarà il tuo P12_PASSWORD segreto.

3. Profili di provisioning

Apre Sviluppatore Apple e seleziona il team giusto.

Poi crea un nuovo profilo, cliccando su +

Crea un nuovo profilo

E seleziona App Store Connect.

Seleziona App Store Connect

Poi devi selezionare l'app giusta, attenzione, altrimenti non potrai utilizzare caratteri jolly e la firma fallirà.

Seleziona la giusta app

Seleziona il giusto certificato che hai creato prima (controlla la data di scadenza, dovrebbe essere lo stesso giorno e mese di oggi) e clicca su Continua.

Seleziona il giusto certificato

Infine inserisci il nome del profilo e clicca su Genera.

Il nome verrà utilizzato per identificare il profilo in Fastlane, sotto il valore di APPLE_PROFILE_NAME.

Genera il profilo

Potrai scaricare il profilo come un .mobileprovision file.

Scarica il profilo

Converti il profilo in Base64 e memoralo come un segreto (BUILD_PROVISION_PROFILE_BASE64).

base64 -i BUILD_PROVISION_PROFILE.mobileprovision | pbcopy

4. Copia i file Fastlane

Fastlane è una libreria Ruby creata per automatizzare le attività comuni di sviluppo mobile. Utilizzando Fastlane, puoi configurare percorsi personalizzati "lanes" che raggruppano una serie di "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 fondamentali.

Creare il folder Fastlane alla radice del tuo progetto Capacitor/Ionic e aggiungere il file Fastfile lì:

Cartella: <project-root>/fastlane/
File: <project-root>/fastlane/Fastfile

Questo è lo stesso livello di package.json, capacitor.config.*, e il ios/ folder. Non crearlo all'interno di ios/App/.

platform :ios do
  desc 'Export ipa and submit to TestFlight'
  lane :beta do
    keychain_info = { keychain_name: "ios-build-#{Time.now.to_i}.keychain", keychain_password: SecureRandom.uuid }
    
    begin
      setup_signing(keychain_info)
      bump_build_number
      build_app_with_signing(keychain_info)
      submit_to_testflight
    ensure
      cleanup_keychain(keychain_info)
    end
  end

  private_lane :setup_signing do |options|
    create_keychain(
      name: options[:keychain_name],
      password: options[:keychain_password],
      unlock: true,
      timeout: 0,
      lock_when_sleeps: false, 
      add_to_search_list: true
    )
    import_cert(options)
    install_profile
    update_project_settings
  end

  lane :bump_build_number do
		file = File.read('../package.json')
		data_hash = JSON.parse(file)
		api_key = app_store_connect_api_key(
      key_id: ENV['APPLE_KEY_ID'],
      issuer_id: ENV['APPLE_ISSUER_ID'],
      key_content: ENV['APPLE_KEY_CONTENT'],
      is_key_content_base64: true,
      duration: 1200,
      in_house: false
    )
		build_num = app_store_build_number(
      api_key: api_key,
			app_identifier: ENV['BUNDLE_IDENTIFIER'],
			live: false
    )
		build_num = build_num + 1
		UI.message("Bumped build number to #{build_num}")
		increment_build_number(
			build_number: build_num,
			xcodeproj: "./ios/App/App.xcodeproj",
			skip_info_plist: true
		)
	end

  private_lane :import_cert do |options|
    cert_path = "#{Dir.tmpdir}/build_certificate.p12"
    File.write(cert_path, Base64.decode64(ENV['BUILD_CERTIFICATE_BASE64']))
    import_certificate(
      certificate_path: cert_path,
      certificate_password: ENV['P12_PASSWORD'] || "",
      keychain_name: options[:keychain_name],
      keychain_password: options[:keychain_password],
      log_output: true
    )
    File.delete(cert_path)
  end  
  
  private_lane :cleanup_keychain do |options|
    delete_keychain(
      name: options[:keychain_name]
    )
  end  

  private_lane :install_profile do
    profile_path = "#{Dir.tmpdir}/build_pp.mobileprovision"
    File.write(profile_path, Base64.decode64(ENV['BUILD_PROVISION_PROFILE_BASE64']))
    UI.user_error!("Failed to create provisioning profile at #{profile_path}") unless File.exist?(profile_path)
    ENV['PROVISIONING_PROFILE_PATH'] = profile_path
    install_provisioning_profile(path: profile_path)
    File.delete(profile_path)
  end

  private_lane :update_project_settings do
    update_code_signing_settings(
      use_automatic_signing: false,
      path: "./ios/App/App.xcodeproj",
      code_sign_identity: "iPhone Distribution",
      profile_name: ENV['APPLE_PROFILE_NAME'],
      bundle_identifier: ENV['BUNDLE_IDENTIFIER'],
      team_id: ENV['APP_STORE_CONNECT_TEAM_ID']
    )
    update_project_team(
      path: "./ios/App/App.xcodeproj",
      teamid: ENV['APP_STORE_CONNECT_TEAM_ID']
    )
  end

  private_lane :build_app_with_signing do |options|
    unlock_keychain(
      path: options[:keychain_name],
      password: options[:keychain_password],
      set_default: false
    )
    build_app(
      workspace: "./ios/App/App.xcworkspace",
      scheme: "App",
      configuration: "Release",
      export_method: "app-store",
      output_name: "App.ipa",
      export_options: {
        provisioningProfiles: {
          ENV['BUNDLE_IDENTIFIER'] => ENV['APPLE_PROFILE_NAME']
        }
      },
      xcargs: "-verbose",
      buildlog_path: "./build_logs",
      export_xcargs: "-allowProvisioningUpdates",
    )
  end   

  private_lane :submit_to_testflight do
    api_key = app_store_connect_api_key(
      key_id: ENV['APPLE_KEY_ID'],
      issuer_id: ENV['APPLE_ISSUER_ID'],
      key_content: ENV['APPLE_KEY_CONTENT'],
      is_key_content_base64: true,
      duration: 1200,
      in_house: false
    )
    pilot(
      api_key: api_key,
      skip_waiting_for_build_processing: true,
      skip_submission: true,
      distribute_external: false,
      notify_external_testers: false,
      ipa: "./App.ipa"
    )
  end
end

5. Configurazione dei segreti

GitHub Azioni utilizza i segreti del repository che configuri nel passaggio successivo. Hai bisogno solo di un segreto locale .env se vuoi eseguire o testare Fastlane direttamente dalla tua macchina.

Per le prove locali, crea <project-root>/fastlane/.env vicino a Fastfile. Non commettere questo file. Aggiungi fastlane/.env a tuo .gitignore per primo (o verifica che sia già ignorato). Ecco un esempio:

APP_STORE_CONNECT_TEAM_ID=UVTJ336J2D
BUNDLE_IDENTIFIER=ee.forgr.testfastlane
# See previous section for these secrets
BUILD_CERTIFICATE_BASE64=
BUILD_PROVISION_PROFILE_BASE64=
APPLE_KEY_ID=
APPLE_ISSUER_ID=
APPLE_KEY_CONTENT=
P12_PASSWORD=
APPLE_PROFILE_NAME=

Ottenere l'ID del team di APP STORE CONNECT

Vai a Centro del Developer e scorri verso il basso alla Membership details Sezione. Il Team ID è il valore che devi impostare nel APP_STORE_CONNECT_TEAM_ID segreto.

Ottieni l'identificatore del bundle

Apri Xcode
Doppio clic sul App in il navigatore dei progetti
Clicca poi sul riquadro Signing and Capabilities
Copia il valore dell' Bundle identifierQuesto è il valore che devi impostare in BUNDLE_IDENTIFIER segreto.

6. Elaborazione del build

Nelle GitHub Actions, si sei fatturato in base ai minuti utilizzati per eseguire il flusso di lavoro CI/CD. Dalla mia 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 e delle dipendenze del tuo progetto.

Se sei preoccupato per i costi per i progetti privati, puoi impostare skip_waiting_for_build_processing per trueQuesto salverà minuti di build non aspettando che App Store Connect finisca di elaborare il build.

Tuttavia, ci sono un trade-off - dovrai aggiornare manualmente le informazioni sulla conformità del tuo app in App Store Connect prima di poter distribuire il build ai utenti.

This optimization is mainly useful for private projects where build minutes cost money. For public/free projects, the build minutes are free so there’s no need to enable this setting. See GitHub’s pagina dei prezzi di __CAPGO_KEEP_0__ Per ulteriori dettagli.

7. Configura GitHub Actions

Configura GitHub segreti

Per favore copia i segreti dal file e incollali nei segreti del repository __CAPGO_KEEP_0__. .env inserisci e incolla i file nel repository segreti GitHub.

Impostazioni > > Segreti e variabili > repository > Nuovo segreto repository

2. BUILD_CERTIFICATE_BASE64 - Certificato codificato in Base64.

3. BUILD_PROVISION_PROFILE_BASE64 - Profilo di provisioning codificato in Base64.

4. BUNDLE_IDENTIFIER - identificatore del pacchetto dell'applicazione.

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

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

7. APPLE_KEY_CONTENT — Chiave App Store Connect API 🔺 Contenuto della chiave. .p8, verificare

8. Configura il file di workflow GitHub

Creare un directory di workflow GitHub.

cd .github/workflows

Dentro 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: '3.0'
          bundler-cache: true
      - uses: maierj/fastlane-action@v3.1.0
        env:
          APP_STORE_CONNECT_TEAM_ID: ${{ secrets.APP_STORE_CONNECT_TEAM_ID }}
          BUNDLE_IDENTIFIER: ${{ secrets.BUNDLE_IDENTIFIER }}
          BUILD_CERTIFICATE_BASE64: ${{ secrets.BUILD_CERTIFICATE_BASE64 }}
          BUILD_PROVISION_PROFILE_BASE64: ${{ secrets.BUILD_PROVISION_PROFILE_BASE64 }}
          APPLE_KEY_ID: ${{ secrets.APPLE_KEY_ID }}
          APPLE_ISSUER_ID: ${{ secrets.APPLE_ISSUER_ID }}
          APPLE_KEY_CONTENT: ${{ secrets.APPLE_KEY_CONTENT }}
          P12_PASSWORD: ${{ secrets.P12_PASSWORD }}
          APPLE_PROFILE_NAME: ${{ secrets.APPLE_PROFILE_NAME }}
        with:
          lane: ios beta
      - name: Upload release bundle
        uses: actions/upload-artifact@v6
        with:
          name: ios-release
          path: ./App.ipa
          retention-days: 10

Questa workflow dovrebbe essere attivata dopo ogni GitHub etichettaSe hai bisogno di automatizzare la creazione dei tag, consulta 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.

Your App doesn’t need to use Ionic, only Capacitor base is mandatory., it can have old Cordova module, but Capacitor JS plugin should be preferred.

8. Attiva il flusso di lavoro

Crea un Commit

Fai un commitDovresti vedere il workflow attivo nel repository.

Attiva il workflow

Inserisci i nuovi commit nella 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 Testflight

9. Posso distribuire dal mio computer locale?

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

Puoi utilizzare Xcode per compilare e firmare il tuo app, come sempre.

Guida alla configurazione CI/CD

Automatica costruzione Capacitor Android con GitHub azioni - Configurazione completa di CI/CD per Android
Scheda di costruzione e rilascio automatico con azioni GitHub - Tutorial completo della pipeline CI/CD
Gestione delle costruzioni Dev e Prod con azioni GitHub - Gestione degli ambienti
Automatic Capacitor iOS Build with Match - Alternativa utilizzando Fastlane Match

Alternative piattaforme CI/CD

Costruisci con GitLab CI - alternativa a GitLab
Costruisci con CodeMagic - Guida di configurazione di CodeMagic

Aggiornamenti Live & Distribuzione

Capgo Documentazione degli Aggiornamenti Live - Aggiungi aggiornamenti OTA al tuo app
L'integrazione CI/CD con Capgo - Integra gli aggiornamenti live nel tuo pipeline

Grazie

Questo blog si basa sugli articoli seguenti:

Continua con l'edizione automatica di IOS Capacitor con azioni GitHub con certificato

Se stai utilizzando L'edizione automatica di IOS Capacitor con azioni GitHub con certificato 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 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 con certificato