La configurazione della CI/CD per le app Capacitor può essere complessa e richiede molto tempo. Ecco cosa devi sapere:
Consigliato per Nuove Costruzioni: Utilizza 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 esistenti di GitHub, ma nuove costruzioni di 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 da Capgo
Evita la manutenzione di Fastlane, esecutori Xcode, certificati, profili di provisioning e script di caricamento. Capgo Costruzione Esegue costruzioni native iOS firmate da chiave
- Funziona con il tuo pipeline: Attiva la Capgo Costruzione da GitHub Actions, GitLab CI, Jenkins o script locali dopo la costruzione web e
npx cap sync. - 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.
- Nessuna manutenzione del runner nativo: La Capgo Costruzione fornisce ambienti di costruzione Apple mantenuti, quindi non devi gestire i runner macOS, le immagini Xcode o le strade Fastlane.
- Articoli e sottoscrizione: Scarica gli articoli firmati per le QA o invia i rilasci attraverso il Capgo CLI.
Prezzi
- Capgo piani iniziano a $12/mese
- Include aggiornamenti OTA e circa 15 costruzioni native al mese
- Minuti aggiuntivi per la costruzione sono fatturati per minuto attraverso crediti
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 membro del programma di sviluppo iOS.
Informazioni importanti sul prezzo
https://github.com/features/actions
Il servizio è ‘gratuito fino al limite, a seconda della macchina scelta.
Utilizzeremo una macchina macOS, potete vedere nello screenshot il suo prezzo e limiti (prezzi validi alla creazione del tutorial, potrebbero subire cambiamenti in futuro) Dopo aver avvertito dei requisiti e dei prezzi, continuiamo.
Nota: Nell'articolo si assume che tu abbia già creato l'app in App Store Connect. Le informazioni importanti saranno copiate da Fastlane!
Cosa imparerai in questo tutorial
Important information about the price
Etappe da seguire nel post
- Utilizzare App Store Connect API con Fastlane
- Requisiti:
- Creazione di una chiave App Store Connect API
- Utilizzare una chiave App Store Connect API
- Requisiti:
- Copia dei file Fastlane
- Configurazione delle azioni GitHub
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
Per poter utilizzare App Store Connect API per caricare il tuo app, hai bisogno di fornire i seguenti elementi tre cose:
- ID emittente
- ID chiave
- File di chiave o contenuto di chiave
Ottieni 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 dirigere la persona interessata a questo articolo.
-
Accedi a App Store Connect.
-
Seleziona Utenti e accessi.
3 — Seleziona la scheda di integrazione.
- Clicca su Genera chiave API o sul pulsante Aggiungi (+).
- 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. Consigliamo di selezionare Amministratore dell'app.
- Clicca su Genera.
Una chiave API non può essere limitata all'accesso a specifiche app.
Il nome della nuova chiave, l'ID chiave, un link di download e altre informazioni vengono visualizzati sulla pagina.
Qui puoi trovare tutte e tre le informazioni necessarie.
<1> ID della richiesta. (APPLE_ISSUER_ID segreto)
<2> ID chiave. (APPLE_KEY_ID segreto)
<3> Clicca su "Download API Chiave" per scaricare la tua API chiave 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 condividere mai le tue chiavi, archivia le chiavi in un code repository o includile nei code client-side.
Utilizzo di una chiave API App Store Connect
È necessario il file della chiave API (file p8 che hai scaricato), l'ID chiave e l'ID emittente per creare il token JWT di autorizzazione. Ci sono diverse modalità per passare queste informazioni nel Fastlane. Ho scelto di utilizzare l'azione nuova del Fastlane app_store_connect_api_key. Puoi imparare altri modi in Documentazione di Fastlane. Mostra 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 | pbcopyOra 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 i certificati.
Se non hai già creato un certificato, puoi creare un nuovo certificato.
Clicca su + e seleziona Distribuzione Apple
Poi devi andare al keychain per scaricare il certificato come un file .p12 To do so, you need to go to the keychain, switch to the
login keychain e poi la scheda My Certificates My Certificates.
E poi fare clic destro sul chiave privata del certificato e selezionare
Export Scegli il formato del file.
Personal Information Exchange (.p12) Questo scaricherà il certificato come un file.
file. .p12 file.
Per favore, apri il file in un terminale e utilizza il seguente comando per convertirlo in Base64:
base64 -i BUILD_CERTIFICATE.p12 | pbcopyQuesto 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
Apri 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à.
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 .mobileprovision file.
Per favore converti il profilo in Base64 e memoralo come un segreto (BUILD_PROVISION_PROFILE_BASE64).
base64 -i BUILD_PROVISION_PROFILE.mobileprovision | pbcopy4. Copia i file Fastlane
Fastlane è una libreria Ruby creata per automatizzare le attività di sviluppo mobile comuni. Utilizzando Fastlane, puoi configurare delle
Create the Fastlane folder at the root of your Capacitor/Ionic project and add the Fastfile there:
- personalizzate che raggruppano 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 gli scopi di questo tutorial, utilizzeremo solo una manciata di azioni di base. package.json, capacitor.config.*Crea la cartella Fastlane alla radice del tuo progetto __CAPGO_KEEP_0__/Ionic e aggiungi 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
endFile: Questo è lo stesso livello di , e la cartella. Non crearla all'interno di . 5. Configurazione dei segreti
GitHub Azioni utilizza 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 Se desideri eseguire test locali, crea
adiacente a <project-root>/fastlane/.env . Non commettere questo file. Aggiungi Fastfileal tuo 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=Vai al
Centro per gli sviluppatori e scorrile verso il basso nella sezione .
La Membership details La Team ID è il valore che devi impostare nel APP_STORE_CONNECT_TEAM_ID segreto.
Ottenere il BUNDLE_IDENTIFIER
- Apri Xcode
- Doppio clic sul
Appnel navigatore dei progetti - Poi clicca sulla scheda
Signing and Capabilities - Copia il valore del
Bundle identifier. Questo è il valore che devi impostare nelBUNDLE_IDENTIFIERsegreto.
6. Elaborazione dei processi
In GitHub Azioni, sei fatturato in base ai minuti hai utilizzato per eseguire il 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 true. Ciò 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à del tuo 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 GitHub’s pagina di prezzo Per ulteriori informazioni.
7. Configura GitHub azioni
Configura i segreti GitHub
Copiare i segreti dal file e incollarli nel repository __CAPGO_KEEP_0__ segreti. .env file and paste them into the GitHub repository secrets.
Impostazioni > Segreti e variabili > Azioni > > Segreto del nuovo 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 bundle dell'applicazione.
5. APPLE_KEY_ID — Chiave App Store Connect API 🔺ID della chiave.
6. APPLE_ISSUER_ID — Chiave App Store Connect API 🔺ID dell'emittente.
7. APPLE_KEY_CONTENT — Chiave App Store Connect API 🔺 Contenuto della chiave .p8, verificare
8. Configura il file di workflow GitHub
Creare un GitHub directory di workflow.
cd .github/workflowsall'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: 10Questa workflow dovrebbe essere attivata dopo ogni GitHub etichetta, se hai bisogno di automatizzare le etichette, si prega di consultare Costruzione automatica e rilascio con GitHub azioni per prima cosa.
Poi questa workflow trarrà i tuoi dipendenze NodeJS, li 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, è sufficiente che utilizzi la base Capacitor , può avere vecchi moduli Cordova, ma è preferibile il plugin Capacitor JS.
8. Attiva il flusso di lavoro
Creare un Commit
Fare un commit, dovresti vedere il flusso di lavoro attivo nel repository.
Attiva il flusso di lavoro
Inviare i nuovi commit sul ramo main o development per attivare il flusso di lavoro.
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 compilare e firmare il tuo app, come sempre.
Articoli correlati
Guida alla configurazione CI/CD
- Costruzione automatica di Capacitor per Android con GitHub Actions - Configurazione completa di CI/CD per Android
- Costruzione e rilascio automatico con GitHub Actions - Tutorial completo del pipeline CI/CD
- Gestione delle costruzioni Dev e Prod con GitHub Actions - Gestione degli ambienti
- Costruzione automatica di Capacitor per iOS con Match - Utilizzo alternativo con Fastlane Match
Alternative piattaforme CI/CD
- 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
- Integrazione CI/CD con Capgo - Integra gli aggiornamenti in tempo reale nel tuo pipeline
Grazie
This blog is based on the following articles:
- La consegna continua per IOS utilizza Fastlane e azioni GitHub
- Documentazione Fastlane
- Questo GitHub messaggio da @mrogunlana
- Questa GitHub documentazione
Continua a procedere dall'edizione automatica Capacitor IOS con GitHub azioni con certificato
Se stai utilizzando L'edizione automatica Capacitor 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 Build 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 la dettaglio di implementazione in Integrazione CI/CD, e GitHub Integrazione azioni per la dettaglio di implementazione in GitHub Integrazione azioni.
