Build IOS automatico con Capacitor azioni con certificato GitHub

Configurare la CI/CD per le Capacitor applicazioni può essere complesso e tempo consumante. Ecco cosa devi sapere:

Consigliato per Nuove Costruzioni: Utilizza Capgo Build

Ora raccomandiamo l'uso di Capgo Build con il Capgo CLI per le costruzioni native Capacitor. Questa guida Fastlane è mantenuta per i team 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.

Capgo Build per la CI/CD da Capgo

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

• Funziona con il tuo pipeline: Trasmetti Capgo Build da GitHub Actions, GitLab CI, Jenkins o script locali dopo la costruzione web e npx cap sync.
• Autenticazione dai segreti CI: Conservare le chiavi App Store Connect, i certificati, i profili di provisioning, le password e gli ID di team nei propri segreti CI.
• Assenza di manutenzione del runner nativo: Capgo Build fornisce ambienti di costruzione Apple mantenuti, quindi non è necessario gestire i runner macOS, le immagini Xcode o le strade Fastlane.
• Articoli e sottoscrizione: Scaricare gli articoli firmati per la QA o sottoscrivere i rilasci attraverso il Capgo CLI.

Prenotazioni

• I piani Capgo iniziano a $12/mese
• Includono aggiornamenti OTA e circa 15 costruzioni native al mese
• I minuti di costruzione aggiuntivi sono fatturati per minuto attraverso crediti

Configura Capgo Build in CI/CD

Guida di configurazione manuale

Ecco cosa devi fare:

Continuous Delivery per iOS utilizzando Fastlane e GitHub Azioni e certificato

Requisiti

Prima di continuare con il tutorial:

• Assicurati di avere Fastlane installato sulla tua macchina di sviluppo.
• Assicurati di essere membro del programma di sviluppatore iOS.

Informazioni importanti sul prezzo

https://github.com/features/actions

Il servizio è ‘gratuito fino al limite, a seconda della macchina scelta.
Stiamo utilizzando un macchina macOS 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, continuiamo.

Nota: Nel post si assume che avete già creato l'app in App Store Connect. L'informazione importante verrà copiata da Fastlane!

Cosa imparerete in questo tutorial

Passaggi da seguire in questo post

1. Utilizzo di App Store Connect API con Fastlane
   • Requisiti:
     • Creazione di una chiave App Store Connect API
     • Usando una chiave App Store Connect API
2. Copia i file Fastlane
3. Configura GitHub Azioni

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

Requisiti

Per poter utilizzare Fastlane per caricare l'applicazione con App Store Connect API, è necessario fornire i seguenti tre cose:

1. ID rilasciante
2. ID della chiave
3. File della chiave o Contenuto della chiave

Ottieni una chiave App Store Connect API

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.

1. Accedi a App Store Connect.

2. Seleziona Utenti e accessi.

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 riferimento 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 permessi di ruolo. Raccomandiamo di selezionare Amministratore dell'app.

7. Clicca su Genera.

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

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

Ecco dove puoi prendere tutte e tre le informazioni necessarie.
ID del problema. (APPLE_ISSUER_ID ID della chiave. (
Clicca su "Scarica la chiave __CAPGO_KEEP_0__" per scaricare la tua chiave __CAPGO_KEEP_1__ 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.APPLE_KEY_ID Conserva la tua chiave privata in un luogo sicuro. Non condividere mai le tue chiavi, archivia le chiavi in un __CAPGO_KEEP_0__ repository o includile nei client-side __CAPGO_KEEP_1__.
<3> Click “Download API Key” to download your API private key. The download link appears only if the private key has not yet been downloaded. Apple does not keep a copy of the private key. So, you can download it only once.

🔴 Store your private key in a safe place. You should never share your keys, store keys in a code repository, or include keys in client-side code.

Using an App Store Connect API Key

The API Key file (p8 file that you download), the key ID, and the issuer ID are required in order to create the JWT token for authorization. There are multiple ways that this information can be passed into Fastlane. I chose to use the Fastlane’s new action app_store_connect_api_key. Ho mostrato questo metodo perché penso sia la via più facile per lavorare 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 (ID del problema. (

ID della chiave. (APPLE_KEY_CONTENT).

base64 -i APPLE_KEY_CONTENT.p8 | pbcopy

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

2. Certificati

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

Clicca su Gestisci certificati.

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

Clicca su + e seleziona Distribuzione Apple

Dopo di che, devi andare al keychain per scaricare il certificato come .p12 file.

Per farlo, devi andare al keychain, passare alla keychain di login keychain di login e poi alla scheda.

I miei certificati

Esegui quindi un clic destro sul certificato e seleziona Esporta.

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

Questo scaricherà il certificato come .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, si prega di fornire la password del certificato. Questa password sarà il tuo P12_PASSWORD segreto.

3. Profili di provisioning

Apre Apple Developer e seleziona il team giusto.

Poi crea un nuovo profilo, cliccando su +

E seleziona App Store Connect.

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

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

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.

Potrai scaricare il profilo come un .mobileprovision file.

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

Fastlane è una libreria Ruby creata per automatizzare compiti 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, useremo solo una manciata di azioni di base.

Creare il folder Fastlane alla radice del tuo progetto Capacitor/Ionic e aggiungi il 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 creare all'interno 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 delle segretezze

GitHub Azioni utilizzano le segretezze del repository che configuri nel passo successivo. Hai bisogno di un file locale .env se vuoi eseguire o testare Fastlane dal tuo computer.

Per il testing locale, crea <project-root>/fastlane/.env accanto al Fastfile. Non commettere questo file. Aggiungi fastlane/.env al tuo .gitignore 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 al Centro del developer e scorrere verso il basso fino alla Membership details sezione. Team ID è il valore che devi impostare nella APP_STORE_CONNECT_TEAM_ID segreta.

Ottenere l'identificatore del bundle

1. Apri Xcode
2. Clicca due volte sul App nel navigatore dei progetti
3. Cliccare poi sul pulsante Signing and Capabilities
4. Copiare il valore di Bundle identifier. Questo è il valore che devi impostare in BUNDLE_IDENTIFIER segreto.

6. Elaborazione in corso

In GitHub Azioni, sei fatturato in base ai minuti hai utilizzato 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 il 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.

If sei preoccupato per i costi per progetti privati, puoi impostare skip_waiting_for_build_processing per true. Ciò salverà i minuti di costruzione non aspettando che App Store Connect finisca di elaborare la costruzione.

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

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

7. Setup GitHub Actions

file e incollali nel repository GitHub segreti.

Vai a .env 7. Impostazione GitHub Actions

Configurazione __CAPGO_KEEP_0__ segreti Impostazioni > Segreti e variabili > Azioni > 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 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, controlla

8. Configura il file di workflow GitHub

Crea un directory di workflow GitHub.

cd .github/workflows

All'interno del workflow folder, 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: '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

Questo workflow dovrebbe essere attivato dopo ogni GitHub etichetta, se hai bisogno di automatizzare le etichette, consulta Costruzione automatica e rilascio con GitHub azioni in primo luogo.

Quindi questo workflow recupererà 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.

può avere vecchi moduli Cordova, ma il __CAPGO_KEEP_1__ plugin JS dovrebbe essere preferito.

8. Attiva il workflow

Crea un Commit Fai uncommit

e dovresti vedere il workflow attivo nel repository.

Attiva il workflow main Invia i nuovi commit sul ramo development o

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

9. Posso distribuire dal mio computer locale?

Sì, puoi farlo e non è affatto difficile.

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

Articoli correlati

Guida alla configurazione CI/CD

• Automatic Capacitor Android Build with GitHub Actions Build e rilascio automatico con __CAPGO_KEEP_0__ Actions
• Automatic Build and Release with GitHub Actions Build e rilascio automatico con __CAPGO_KEEP_0__ Actions
• Manage Dev and Prod Builds with GitHub Actions - Gestione dell'ambiente
• Automatic Capacitor iOS Build with Match - Alternativa utilizzando Fastlane Match

Alternative piattaforme CI/CD

• Costruzione con GitLab CI - Alternativa a GitLab
• Costruzione con CodeMagic - Guida di configurazione di CodeMagic

Aggiornamenti in tempo reale e distribuzione

• Documentazione degli aggiornamenti in tempo reale di Capgo - Aggiungi aggiornamenti OTA al tuo app
• Integrazione CI/CD con Capgo - Integra aggiornamenti in tempo reale nel tuo pipeline

Grazie

Questo blog si basa sui seguenti articoli:

• La consegna continua per IOS utilizzando Fastlane e GitHub azioni
• Documentazione Fastlane
• Questo GitHub messaggio da @mrogunlana
• Questo GitHub documento

Continua a procedere dall'Automatico Capacitor build IOS con GitHub azioni con certificato

Se stai utilizzando Automatico Capacitor build IOS con GitHub azioni 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 il dettaglio di implementazione in Integrazione CI/CD, e GitHub Integrazione delle azioni for the implementation detail in GitHub Actions Integration.