Costruzione automatica Capacitor IOS con GitHub azioni con certificato

Impostare la CI/CD per le applicazioni 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 le costruzioni native Capacitor. Questa guida di Fastlane viene 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 Costruzione per la CI/CD di Capgo

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

• Funziona con il tuo pipeline: Attiva la Capgo costruzione da GitHub Azioni, GitLab CI, Jenkins o script locali dopo la tua 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
• : La __CAPGO_KEEP_0__ costruzione fornisce ambienti di costruzione Apple mantenuti, quindi non devi gestire i runner macOS, le immagini Xcode o le strade Fastlane: Scarica gli artefatti firmati per la QA o invia le release costruite attraverso il Capgo __CAPGO_KEEP_1__
• Prenotazione: Download signed artifacts for QA or submit release builds through the Capgo CLI.

: I piani __CAPGO_KEEP_0__ iniziano da 12€/mese

• Capgo plans start at $12/month
• : I minuti di costruzione aggiuntivi sono fatturati per minuto attraverso i crediti
• contexto: Pagina/area: Capgo Builder / prodotto di costruzione nativa cloud. Ruolo: Frase di copia del sito web. Visto in: pagina native-build.astro. Messaggio chiave `native_build_builder_minuti_di_costruzione` (Minuti di costruzione del costruttore di costruzione nativa)

Configura Capgo Build in CI/CD

Guida di configurazione manuale

Ecco cosa devi fare:

Continua la consegna 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 un membro del programma di sviluppatore iOS.

Informazioni importanti sul prezzo

https://github.com/caratteristiche/azioni

La servizio è ‘gratuito’ fino al limite, a seconda della macchina scelta.
Utilizzeremo una macchina macOS che potete vedere nel screenshot con il suo prezzo e limiti (prezzi validi alla creazione del tutorial, potrebbero subire cambiamenti in futuro)

Dopo aver avvertito delle richieste 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 in questo tutorial

I passaggi da seguire in questo post

1. Utilizzare App Store Connect API con Fastlane
   • Requisiti:
     • Creare una chiave App Store Connect API
     • Utilizzare una chiave App Store Connect API
2. Copia i file Fastlane
3. Configura GitHub Actions

1. Utilizzare App Store Connect API con Fastlane

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

Requisiti

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

1. ID del rilasciatore
2. ID della chiave
3. File della chiave o contenuto della chiave

Ottenimento di una chiave API di App Store Connect

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. Scegli Utenti e accessi.

3 — Scegli la scheda di integrazione.

4. Clicca su Genera API Chiave 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 permessi di ruoloConsigliamo di selezionare Amministratore dell'app.

7. Clicca su Genera.

L'accesso di 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 visualizzati sulla pagina.

Potrai trovare 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 "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. Pertanto, 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 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_keyPotrai imparare altre modalità in Dal documento di riferimento di Fastlane. Mostrerò questo metodo perché penso che sia la via più facile per lavorare con la maggior parte delle CI presenti, 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

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

Clicca su Gestisci certificati.

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

Clicca su + e seleziona Distribuzione Apple

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

Per farlo, devi andare a keychain, passare alla sezione login chiave di accesso e poi la scheda I miei certificati.

Seleziona quindi il certificato che desideri scaricare. (Cerca per la data del certificato)

E poi fare clic destro sul chiave privata del certificato e selezionare Esporta.

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 +

E seleziona App Store Connect.

Poi devi selezionare l'app giusta, attenzione, altrimenti il firmaggio fallirà.

Seleziona il certificato giusto che hai creato prima (guarda 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.

Puoi scaricare il profilo come un .mobileprovision file.

Per favore, converte 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 delle

Create the Fastlane folder at the root of your Capacitor/Ionic project and add the Fastfile there:

• personalizzate che raccolgono una serie di <project-root>/fastlane/
• azioni <project-root>/fastlane/Fastfile

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. package.json, capacitor.config.*Creare la cartella Fastlane alla radice del tuo progetto __CAPGO_KEEP_0__/Ionic e aggiungere il file Fastfile lì: ios/ Cartella: 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

File:

GitHub Actions uses the repository secrets you configure in the next step. You only need a local .env , e il

For il testing locale, crea <project-root>/fastlane/.env prossimo al Fastfile. Non commettere questo file. Aggiungi fastlane/.env a tuo .gitignore primo (o verifica se è 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.

Ottenere l'identificatore del bundle

1. Apre Xcode
2. Doppio clic sul App In progetto navigatore
3. Poi clicca sulla scheda Signing and Capabilities
4. Copia il valore dell' Bundle identifier. Questo è il valore che devi impostare nel BUNDLE_IDENTIFIER segreto.

6. Elaborazione di compilazione

In GitHub Azioni, si 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 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à i 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à dell'app in App Store Connect prima di poter distribuire il build agli 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 per maggiori dettagli. per maggiori dettagli.

7. Configura GitHub Actions

Configura GitHub segreti

Si prega di copiare i segreti dal .env file e incollarli nei segreti del repository GitHub.

Vai a Impostazioni > Segreti e variabili > azioni > Nuovo segreto del repository

2. BUILD_CERTIFICATE_BASE64 - Certificato Base64 codificato.

3. BUILD_PROVISION_PROFILE_BASE64 - Profilo di provisioning Base64 codificato.

4. BUNDLE_IDENTIFIER - identificatore del pacchetto dell'applicazione.

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

6. APPLE_ISSUER_ID — Chiave API di App Store Connect 🔺ID rilasciante.

7. APPLE_KEY_CONTENT — Chiave API di App Store Connect 🔺 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 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: '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 l'etichetta, si prega di fare riferimento a Costruzione automatica e rilascio con GitHub azioni per prima cosa.

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.

La tua App non deve utilizzare Ionic, è sufficiente che abbia la base Capacitor obbligatoria, può avere moduli Cordova vecchi, ma è preferibile il plugin Capacitor JS.

8. Attiva la workflow

Crea un Commit

Realizza un commit, dovresti vedere il flusso di lavoro attivo nel repository.

Attiva il flusso di lavoro

Pusha i nuovi commit sulla branch main o development Per attivare il flusso di lavoro

Avviato con commit

Pannello di Testflight

9. Posso distribuire dal mio computer locale?

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

Articoli correlati

Guida alla configurazione CI/CD

• Automatic Capacitor Android Build with GitHub Actions - Configurazione completa di CI/CD per Android
• Costruzione automatica e rilascio con GitHub Actions - Tutorial completo della pipeline CI/CD
• Gestione delle costruzioni Dev e Prod con GitHub Actions - Gestione degli ambienti
• Automatic Capacitor iOS Build with Match - Alternativa utilizzando Fastlane Match

Piattaforme CI/CD alternative

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

Aggiornamenti in Tempo Reale & Distribuzione

• Capgo Documentazione degli Aggiornamenti in Tempo Reale - Aggiungi aggiornamenti OTA al tuo app
• L'integrazione CI/CD con Capgo - Integra gli aggiornamenti in tempo reale nel tuo pipeline

Grazie

Questo blog si basa sugli articoli seguenti:

• La consegna continua per IOS utilizzando Fastlane e GitHub azioni
• Documentazione Fastlane
• This GitHub message from @mrogunlana
• This GitHub documentation

Continua con l'istanza automatica di build IOS di Capacitor con GitHub azioni con certificato

Se stai utilizzando L'istanza automatica di build IOS di Capacitor con GitHub azioni con certificato per pianificare l'automazione CI/CD, connettilo con Capgo automazione CI/CD per il flusso di lavoro del prodotto in Capgo automazione CI/CD, Capgo Build nativi per il flusso di lavoro del prodotto in Capgo Build nativi, 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 Azioni di integrazione per i dettagli di implementazione in GitHub Azioni di integrazione.