Costruzione automatica Capacitor IOS con GitHub azioni con certificato

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

Consigliato per Nuove Costruzioni: Utilizzare 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 d'azione esistenti GitHub, ma nuove costruzioni iOS dovrebbero utilizzare il Capgo CLI in modo da non dover mantenere Fastlane, i runner Xcode, i certificati e gli script di caricamento.

Capgo Build per la CI/CD da Capgo

Saltate la manutenzione di Fastlane, del runner Xcode, del certificato, del profilo di provisioning e dello script di caricamento. Capgo Build esegue costruzioni native iOS firmate dal vostro pipeline CI/CD esistente:

• Funziona con il vostro pipeline: Trasmettere 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.
• Nessuna manutenzione del runner nativo: Capgo Build fornisce ambienti di costruzione Apple mantenuti, quindi non devi 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.

Prenotazione

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

Configura Capgo Build in CI/CD

Guida di configurazione manuale

Ecco cosa devi fare:

Distribuzione Continua per iOS utilizzando Fastlane e GitHub Azioni e certificato

Requisiti

Prima di continuare con il tutorial:

• Assicurati di avere Fastlane installato sul tuo computer 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 una 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 nel tutorial

Passaggi da seguire nel post

Utilizzo di App Store Connect __CAPGO_KEEP_0__ con Fastlane

1. Using App Store Connect API with Fastlane
   • Creazione di una chiave App Store Connect __CAPGO_KEEP_0__
     • Utilizzo di App Store Connect API con Fastlane
     • 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 di sicurezza aggiuntivo 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 su 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 la permessso di amministratore in App Store Connect. Se non si ha quel permesso, si può indirizzare la persona competente a questo articolo.

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

7. Clicca su Genera.

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

Il nome della nuova chiave, l'ID della chiave, un link di download 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. (
Seleziona "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 dovresti mai condividere le tue chiavi, archiviare le chiavi in un __CAPGO_KEEP_0__ repository o includere le chiavi 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 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 (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 accesso e poi alla scheda I miei certificati.

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

E poi fare clic con il pulsante destro sulla chiave privata sul certificato e selezionare __CAPGO_KEEP_0__.

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

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

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

Apri Apple Developer e seleziona il team giusto.

Crea quindi un nuovo profilo, cliccando su +

E seleziona App Store Connect.

Poi devi selezionare l'app giusta, attenzione, altrimenti il firmato 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.

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, utilizzeremo solo una manciata di azioni di base.

Creare il folder di Fastlane nella radice del tuo Capacitor/Ionic progetto 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 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 delle segrete

GitHub Azioni utilizzano le segrete 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 verificare 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 per gli sviluppatori e scorrere verso il basso nella sezione. Membership details è il valore che devi impostare nella Team ID segreta. APP_STORE_CONNECT_TEAM_ID app-store-connect-team-id

Apri Xcode

1. Doppio clic sul
2. nel navigatore dei progetti App section
3. Cliccare quindi sul pulsante Signing and Capabilities
4. Copiare il valore di Bundle identifierQuesto è il valore che devi impostare in BUNDLE_IDENTIFIER segreto.

6. Elaborazione dei dati

In GitHub Azioni, 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 progetti privati, il costo stimato per build può arrivare a $0,08/min x 15 min = $1,2o più, a seconda della configurazione e delle dipendenze del tuo progetto.

If sei preoccupato per i costi per i 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 i 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. Setup GitHub Actions

Configure __CAPGO_KEEP_0__ secrets Impostazioni > 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 — ID emittente della chiave App Store Connect API 🔺

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

8. Configura il file di workflow GitHub

Crea un directory di workflow 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: '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 preleverà 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 ha bisogno di utilizzare Ionic, solo la base Capacitor è obbligatoria, può avere vecchi moduli di Cordova, ma il plugin Capacitor JS dovrebbe essere preferito.

8. Attiva il workflow

Crea un Commit

Fai un commitdovresti vedere il workflow attivo nel repository.

Attiva il workflow

Pubblica i nuovi commit sulla branch main o development per attivare il workflow.

Dopo pochi minuti, la 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 la tua app, come sempre.

Articoli correlati

Guida alla configurazione CI/CD

• Costruzione automatica di una build Android con Capacitor e GitHub Actions - Configurazione completa di CI/CD per Android
• Costruzione automatica e rilascio con GitHub Actions - Tutorial completo di pipeline CI/CD
• Gestione delle build di sviluppo e prodotto con 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 sugli articoli seguenti:

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

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 azioni per il dettaglio di implementazione in GitHub Integrazione azioni.