Automatic Capacitor IOS build with GitHub actions with certificate

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

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

Costruzione Capgo per CI/CD da Capgo

Saltate la manutenzione di Fastlane, esecutori Xcode, certificati, profili di provisioning e script di caricamento. Costruzione Capgo esegue costruzioni native iOS firmate dal tuo pipeline CI/CD esistente:

Lavora con il tuo pipeline: Trascinare la costruzione Capgo da GitHub Actions, GitLab CI, Jenkins o script locali dopo la costruzione web e npx cap sync.
La firma dai segreti di CI: Mantenere le chiavi di App Store Connect, i certificati, i profili di provisioning, le password e gli ID di squadra nei propri segreti di CI.
Non mantenete l'esecuzione nativa: La costruzione Capgo fornisce ambienti di costruzione Apple mantenuti, quindi non dovrete gestire esecutori macOS, immagini Xcode o lane Fastlane.
Articoli e sottoscrizione: Scarica gli artefatti firmati per la QA o invia i rilasci dei build attraverso il Capgo CLI.

Prenotazione

Capgo plans start at $12/month
Piani __CAPGO_KEEP_0__ iniziano da 12€/mese
Includono aggiornamenti OTA e circa 15 build nativi al mese

Set up Capgo Build in CI/CD

Configura __CAPGO_KEEP_0__ Build in CI/CD

Guida di configurazione manuale

Continuous Delivery for iOS using Fastlane and GitHub Actions and certificate

Delivery Continua per iOS utilizzando Fastlane e __CAPGO_KEEP_0__ Actions e certificato

Prerequisiti per la sottoscrizione di __CAPGO_KEEP_0__ Build in CI/CD

Assicurati di avere Fastlane installato su il tuo computer di sviluppo.
Assicurati di essere parte del programma di appartenenza al developer iOS.

Informazioni importanti sul prezzo

Prezzo GitHub Action

https://github.com/features/actions

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

Una volta avvertiti dei requisiti e dei prezzi, continuiamo.

Nota: nel post suppongo che tu abbia già creato l'app in App Store Connect. L'informazione importante verrà copiata da Fastlane!

Cosa imparerai nel tutorial

I passaggi da seguire nel post

Utilizzare 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. Utilizzo di App Store Connect API con Fastlane

Da febbraio 2021, l'autenticazione a due fattori o la verifica a due passaggi è obbligatoria 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.
Da Supporto Apple

Requisiti

Per poter utilizzare Fastlane per caricare il tuo app su App Store Connect API, devi fornire i seguenti tre cose:

ID emittente
ID chiave
File di chiave o contenuto di chiave

Ottenimento di una chiave App Store Connect API

Per generare le chiavi, devi avere le autorizzazioni di amministratore in App Store Connect. Se non ne hai, puoi indirizzare la persona competente a questo articolo.

Accedi a App Store Connect.
Scegli Utenti e accessi.

Accesso all'utente di App Store Connect

3 — Scegli la scheda di integrazione.

App Store Connect integrazione API

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

Le chiavi di App Store Connect API creano

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

Le chiavi di App Store Connect API 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 ruoloConsigliamo di selezionare Gestore dell'applicazione.

Clicca su Genera.

Una chiave API non può avere accesso limitato a specifiche app.

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

Scaricare le chiavi di App Store Connect

Ecco dove puoi trovare tutte le informazioni necessarie.
1. ID della richiesta. (APPLE_ISSUER_ID segreto)
2. ID della chiave. (APPLE_KEY_ID segreto)
Click 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. Quindi, 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 nel codice client-side code.

Utilizzare una chiave API di App Store Connect

Il file della chiave API (p8 che hai scaricato), 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 questa informazione può essere passata in Fastlane. Ho scelto di utilizzare l'azione nuova di Fastlane app_store_connect_api_keyPotresti imparare altre modalità in documentazione di FastlaneMostrerò questo metodo perché penso che sia la modalità più facile da utilizzare con la maggior parte delle CI, dove puoi impostare le variabili di ambiente.

Per favore converti il file p8 che hai scaricato in Base64 e memoralo 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 > Account > 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 selezionare Distribuzione Apple

Distribuzione Apple

Poi devi andare al keychain per scaricare il certificato come un .p12 file.

Per farlo, devi andare al keychain, passare alla sezione keychain di accesso keychain di accesso Poi puoi selezionare il certificato che desideri scaricare. (Cerca per la data del certificato).

E poi fai clic destro sulle chiavi private del certificato e selezionare

certificato

certificato Esporta.

Scegli il formato del file Informazioni personali di scambio (.p12).

Questo scaricherà il certificato come .p12 un 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 la squadra giusta.

Crea quindi un nuovo profilo, cliccando su +

Crea un nuovo profilo

E seleziona App Store Connect.

Seleziona App Store Connect

Poi devi selezionare la giusta app, attenzione, non puoi utilizzare wildcard altrimenti la firma fallirà.

Seleziona la giusta app

Seleziona la giusta chiave di firma che hai creato prima (cerca la data di scadenza, dovrebbe essere lo stesso giorno e mese di oggi) e clicca su Continua.

Seleziona la giusta chiave di firma

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

Per favore converti il profilo in Base64 e memorizzalo 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. Con Fastlane puoi fare molto, ma per gli scopi di questo tutorial, utilizzeremo solo una manciata di azioni di base.

Creare la cartella 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/ cartella. Non crearla 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 Le azioni utilizzano i segreti del repository che configuri nel passo successivo. Hai bisogno di un file locale solo se desideri eseguire o testare Fastlane dal tuo computer. .env Per il testing locale, crea

accanto a <project-root>/fastlane/.env . Non commettere questo file. Aggiungi Fastfilea fastlane/.env primo (o verifica che sia già ignorato). Ecco un esempio: .gitignore Ottenere l'ID del team di App Store Connect

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=

Setting up secrets

Vai a Centro per lo Sviluppatore e scorrere verso il basso fino a Membership details sezione. Il Team ID è il valore che devi impostare nel APP_STORE_CONNECT_TEAM_ID segreto.

Ottenere l'IDENTIFICATORE_BUNDLE

Apri Xcode
Clicca due volte sul App nel navigatore dei progetti
Poi clicca sulla scheda Signing and Capabilities
copiare il valore di Bundle identifierQuesto è il valore che devi impostare in BUNDLE_IDENTIFIER segreto.

6. Elaborazione in corso

In GitHub Actions, sei fatturato in base ai minuti utilizzati per l'esecuzione del tuo workflow 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 trueSalva minuti di build evitando di attendere che App Store Connect completi il processo di build.

Tuttavia, ci sono un compromesso - dovrai aggiornare manualmente le informazioni sulla conformità dell'app in App Store Connect prima di poter distribuire il build agli utenti.

Questa ottimizzazione è principalmente utile per i progetti privati dove i minuti di build costano denaro. Per i progetti pubblici/gratuiti, i minuti di build sono gratuiti quindi non c'è bisogno di abilitare questa impostazione. Vedi la pagina dei prezzi di GitHub per maggiori dettagli. 7. Configura __CAPGO_KEEP_0__ Actions

Configura GitHub secrets

Configure GitHub secrets

file e incollali nel repository __CAPGO_KEEP_0__ segreti. .env file and paste them into the GitHub repository secrets.

Impostazioni Settings > Segreti e variabili > Azioni > Nuovo segreto di 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 App Store Connect API Chiave 🔺 Contenuto della chiave .p8, Controlla

8. Configura il file di workflow GitHub

Creare un directory di workflow GitHub

cd .github/workflows

All'interno della cartella, crea un file denominato workflow e aggiungi il seguente. 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: '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

This workflow should be triggered after each GitHub se hai bisogno di automatizzare l'etichettatura, consultaAutomatico build e rilascio con __CAPGO_KEEP_0__ azioni Automatic build and release with GitHub actions Primo.

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

Ogni volta che invierai un nuovo commit, verrà costruita una versione di test in TestFlight.

La tua App non deve utilizzare Ionic, solo la base di Capacitor è obbligatoria, può avere un modulo Cordova vecchio, ma il plugin JS di Capacitor dovrebbe essere preferito.

8. Attiva il workflow

Crea un commit

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

Attiva il workflow

Puoi anche main o development per attivare il workflow.

Iniziato con il commit

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

Dashboard Testflight

9. Posso distribuire dal macchina locale?

Sì, puoi farlo e non è affatto difficile.

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

Guida alla configurazione CI/CD

Build automatico dell'app Android con Capacitor e GitHub Actions - Configurazione completa del CI/CD per Android
Build e rilascio automatico con GitHub Actions - Tutorial completo della pipeline CI/CD
Gestisci costruzioni Dev e Prod con GitHub azioni - Gestione dell'ambiente
Costruzione iOS automatica con Capacitor Match - Alternativa utilizzando Fastlane Match

Alternative piattaforme CI/CD

Costruisci con GitLab CI - Alternativa di GitLab
Costruisci con CodeMagic - Guida di configurazione di CodeMagic

Aggiornamenti in tempo reale & distribuzione

Documentazione degli Capgo Aggiornamenti in tempo reale - Aggiungi aggiornamenti OTA all'app
CI/CD Integration with Capgo - Integra aggiornamenti in tempo reale nel tuo pipeline

Grazie

Questo blog si basa sugli articoli seguenti:

Keep going from Automatic Capacitor IOS build with GitHub actions with certificate

Se stai utilizzando Automatic Capacitor IOS build with GitHub actions with certificate 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 Capacitor IOS automatica con GitHub azioni con certificato