Configurare la CI/CD per le app Capacitor

Vuoi rilasci app per iOS e Android più rapidi e senza errori? Pipeline CI/CD per Capacitor le app automatizzano build, test e deployment, riducendo i tempi di rilascio fino al 70% e gli errori del 60%. Questa guida copre tutto ciò che devi sapere, dal setup dell'ambiente all'automazione dei live update con Capgo.

Punti chiave:

• Perché la CI/CD è fondamentale per le app Capacitor: accelera le build del 78% e riduce i rifiuti degli store del 60%.
• Strumenti essenziali: Xcode, Android Studio, CocoaPods, e molto altro.
• Setup della pipeline: automatizza attività come npx cap sync, caching delle dipendenze e build specifiche per piattaforma.
• Live updates con Capgo: Abilita gli aggiornamenti post-rilascio con rollout graduali e tutele per il rollback.

Passaggi per il setup rapido:

1. Prepara l'ambiente: Installa gli strumenti necessari per iOS e Android.
2. Configura il tuo progetto: Aggiorna capacitor.config.ts e gestisci le variabili d'ambiente in modo sicuro.
3. Pipeline di build: Automatizza installazione dipendenze, build e test per entrambe le piattaforme.
4. Ottimizza le performance: Usa caching, build parallele e workflow condizionali.
5. Aggiungi gli aggiornamenti live: Integra Capgo per aggiornamenti OTA sicuri con rollout graduali.

Con la CI/CD, le app con Capacitor ottengono release più veloci e fluide, riducendo errori e interventi manuali. Pronto a ottimizzare il tuo workflow? Cominciamo!

Integra le tue pipeline CI/CD con funzionalità mobile

Preparazione dell'ambiente CI/CD

Una volta padroneggiati i concetti base della CI/CD, il passo successivo è configurare l'ambiente. È la spina dorsale di un'automazione affidabile.

Configurazione di tool e software

Assicurati di avere installato questi strumenti chiave:

Per lo sviluppo iOS:

• Xcode 14 o versioni successive
• Xcode Command Line Tools
• CocoaPods per la gestione delle dipendenze

Per lo sviluppo Android:

• Android Studio
• Android SDK 33 o superiore
• Java Development Kit (JDK)

Per verificare che Xcode Command Line Tools siano installati, usa:

xcode-select -p

Creazione di un Capacitor Progetto

Il tuo progetto Capacitor deve essere configurato correttamente per i workflow CI/CD. Il capacitor.config.ts file è al centro di questa configurazione:

const config: CapacitorConfig = {
  appId: 'com.example.app',
  webDir: 'build',
  ios: { 
    scheme: 'MyApp'
  }
}

Questo file garantisce che il tuo progetto sia conforme ai requisiti CI/CD.

Configurazione delle variabili d'ambiente

Gestire le credenziali in modo sicuro è una parte fondamentale per collegare la configurazione dell'ambiente alla pipeline CI/CD.

Variabili chiave da definire:

• BUILD_ENV: Specifica la fase di deployment (ad es., production)
• IOS_SIGNING_IDENTITY: Il tuo certificato di firma code
• ANDROID_KEYSTORE_PATH: Percorso del tuo keystore Android

Per le build Android, genera dinamicamente un local.properties file durante il processo CI:

echo "sdk.dir=$ANDROID_SDK_ROOT" > android/local.properties

Quando lavori con build iOS, assicurati che la tua piattaforma CI supporti agenti macOS.

Per verificare che il tuo ambiente sia pronto:

node --version | grep "v16" && xcodebuild -version | grep "Xcode 14" || exit 1

Gestire correttamente chiavi e credenziali può ridurre significativamente il rischio di rifiuto da parte degli app store, come evidenziato dalle statistiche precedenti [1].

Creazione della tua pipeline CI/CD

Una volta pronto l'ambiente, il passo successivo è configurare una pipeline CI/CD per il tuo app Capacitor. Questa pipeline deve gestire in modo efficiente sia gli asset web sia i build delle piattaforme native.

Installazione e aggiornamento delle dipendenze

In ambienti CI/CD, la gestione delle dipendenze richiede un controllo rigoroso delle versioni. Inizia con un processo di installazione pulito:

npm install --ignore-scripts
npm install @capacitor/cli

Per accelerare le build, usa la cache delle dipendenze. Ad esempio, Azure DevOps ha visto i tempi di build migliorare del 40-60% con questa configurazione:

- task: Cache@2
  inputs:
    key: 'npm | "$(Agent.OS)" | package-lock.json'
    path: |
      node_modules
      android/.gradle
      ios/Pods

Configurazione build iOS e Android

Ecco come configurare le build per entrambe le piattaforme:

Configurazione build iOS:

steps:
  - task: InstallAppleCertificate@2
    inputs:
      certSecureFile: 'certificate.p12'
      certPwd: $(P12_PASSWORD)
  - script: |
      xcodebuild -workspace ios/App/App.xcworkspace -scheme App -configuration Release -archivePath ios/App/App.xcarchive archive

Configurazione build Android:

cd android
./gradlew bundleRelease

Fasi di testing e deployment

Esegui i test delle piattaforme in parallelo con una strategia matrix:

test:
  steps:
    - run: npm run test:unit
    - run: npm run test:e2e
    - name: Run Platform Tests
      matrix:
        platform: [ios, android]
      run: npm run test:${{ matrix.platform }}

Per il deployment, configura la gestione degli artifact per piattaforma:

L'uso di build parallele può ridurre notevolmente i tempi di esecuzione della pipeline se configurate correttamente.

Una volta validate e pacchettizzate le build, puoi passare ai live update con Capgo (ne parleremo nella prossima sezione).

sbb-itb-f9944d2

Aggiunta Capgo per i Live Updates

Integrare Capgo nel tuo workflow ottimizza il processo di CI/CD, permettendoti di gestire gli aggiornamenti post-rilascio. Ecco come configurarlo:

Configurazione della pipeline Capgo

Per prima cosa, installa il Capgo CLI nel tuo ambiente di pipeline:

steps:
  - name: Install Capgo CLI
    run: npm install -g @capgo/cli
  - name: Configure Authentication
    env:
      CAPGO_KEY: ${{ secrets.CAPGO_API_KEY }}

Questa aggiunta estende il tuo ciclo di vita CI/CD integrando gestione degli update nel tuo processo automatizzato di build e deployment.

Successivamente, inserisci il comando di upload dopo gli step di build:

- name: Upload Update
  run: |
    capgo upload --api-key $CAPGO_KEY --bundle ./build/app-release.apk
    capgo deploy v${VERSION} --channel production

Per aggiornamenti sicuri, configura le impostazioni di validazione in questo modo:

{
  "verification": {
    "checksum": "strict",
    "certificatePinning": true,
    "updateTimeout": 500
  }
}

Panoramica delle funzionalità di Capgo

Linee guida per gli OTA update

Migliora i processi di test monitorando queste metriche chiave dopo il deployment:

Strategia di deployment graduale

Utilizza un rollout graduale per controllare la distribuzione degli aggiornamenti:

- name: Staged Rollout
  run: |
    capgo deploy v1.2.3 --group "beta-users" --rollout 10%
    capgo deploy v1.2.3 --rollout 50%

Monitoraggio degli aggiornamenti

Tieni d'occhio queste metriche:

• Tasso di adozione: Punta al 40-60% nelle prime 24 ore.
• Sessioni senza crash: Mantienilo sopra il 99,5%.
• Tempo di verifica: Assicurati che sia sotto i 500 ms.

Se i crash superano i livelli accettabili, automatizza un rollback:

- name: Rollback Check
  run: |
    if [ $(capgo stats --version v1.2.3 --metric crashes) -gt 2 ]; then
      capgo rollback --channel production
    fi

Migliorare le performance della pipeline

Concentrarsi su tre aree chiave può portare a miglioramenti significativi nella pipeline:

Ottimizzazione della velocità di build

Per le modifiche solo web, l'uso di npx cap sync può far risparmiare tempo saltando i rebuild nativi completi, riducendo i tempi di rebuild di circa il 40%. Ecco come implementare la build condizionale:

- name: Build Strategy
  run: |
    [ "$WEB_ONLY" = true ] && npx cap sync || (./gradlew assembleRelease && xcodebuild ...)

Questo approccio garantisce che vengano ricostruiti solo i componenti necessari, semplificando il processo.

Automazione del version control

Automatizzare il versionamento può semplificare il workflow. Usa lo script seguente per impostare dinamicamente i numeri di versione e build:

- name: Set Version
  run: |
    VERSION=$(node -p "require('./package.json').version")
    BUILD_NUMBER=$GITHUB_RUN_NUMBER
    echo "APP_VERSION=${VERSION}" >> $GITHUB_ENV
    echo "BUILD_ID=${BUILD_NUMBER}" >> $GITHUB_ENV

Inoltre, è possibile configurare il semantic versioning automatizzato con questa configurazione:

{
  "scripts": {
    "version": "standard-version",
    "build:prod": "npm version patch && ionic build --prod"
  }
}

Queste pratiche forniscono una solida base per monitorare e migliorare le prestazioni della pipeline tramite metriche come:

• Tempo di build per stage
• Efficienza della cache (rapporti hit/miss)
• Utilizzo massimo delle risorse

Setup multi-ambiente

Gestire più ambienti è più semplice con configurazioni specifiche per ogni ambiente. Ecco un esempio di setup:

Puoi configurare gli ambienti dinamicamente con questo script:

- name: Configure Environment
  env:
    API_KEY: ${{ secrets.ENV_SPECIFIC_API_KEY }}
    BUNDLE_ID: ${{ parameters.bundleId }}
  run: |
    echo "ENVIRONMENT=${{ parameters.environment }}" >> $GITHUB_ENV
    echo "API_ENDPOINT=${{ parameters.apiUrl }}" >> $GITHUB_ENV

Abbinare queste configurazioni al deployment basato su canali di Capgo permette aggiornamenti precisi per ogni ambiente. Questo garantisce rollout più fluidi e un migliore controllo del comportamento dell'app in contesti diversi.

Riassunto

Il ruolo della CI/CD nello sviluppo

L'uso di pipeline CI/CD per le app Capacitor aumenta drasticamente l'efficienza del workflow. Secondo i dati di settore, i team possono ottenere cicli di release dal 50 al 70% più veloci grazie alle build simultanee per iOS e Android [3]. Automatizzare task come l'installazione delle dipendenze e la sincronizzazione delle piattaforme riduce gli errori di deployment del 40-60% [1][2].

Ad esempio, i team che utilizzano le pipeline di Azure DevOps hanno automatizzato processi come i passaggi di build sequenziali e il packaging di Xcode. Utilizzano inoltre ambienti parametrizzati sia per lo sviluppo che per la produzione. Questo approccio elimina la necessità di operazioni manuali su Gradle e Xcode CLI, garantendo la creazione di artifact affidabili ogni volta.

Questi miglioramenti pongono le basi per una gestione degli aggiornamenti semplificata se abbinati a Capgo.

Capgo per la gestione degli aggiornamenti

Capgo si integra perfettamente con le pipeline CI/CD per rilasciare aggiornamenti istantanei nel rispetto delle policy degli app store. Gli aggiornamenti vengono deployati solo dopo aver superato i gate di test automatizzati integrati nella pipeline.

Combinando build automatizzate e rollout graduali, i team ottengono risultati notevoli: Copertura dell'80% degli utenti in 7 giorni e capacità di rollback in meno di un'ora.

Una strategia comune prevede track di deployment paralleli. Le build automatizzate servono per i test interni, mentre i rollout graduali sono rivolti a segmenti specifici di utenti. Questo garantisce aggiornamenti veloci e sicuri, supportati da rigorosi gate di test automatizzati [1].

FAQ

Come creare un'app con Capacitor?

Per buildare un'app Capacitor bastano pochi semplici passaggi:

1. Configura l'ambiente: Installa Node.js e npm sul tuo sistema. Poi, usa la Ionic CLI per avviare un nuovo progetto con supporto Capacitor:

   ionic start myApp tabs --capacitor

2. Aggiungi supporto alle piattaforme: Aggiungi le piattaforme che vuoi supportare, come iOS o Android:

   npx cap add ios
   npx cap add android

3. Sincronizza la tua code web: Assicurati che la tua code web sia allineata con le piattaforme native eseguendo:

   npx cap sync

La fase di sincronizzazione è fondamentale per mantenere l'app coerente tra le piattaforme e garantire un funzionamento fluido nelle pipeline CI/CD. Per maggiori dettagli sulla configurazione dell'ambiente, consulta la sezione Tools.

Continua da Configurazione CI/CD per app Capacitor

Se stai usando Configurare la CI/CD per le app Capacitor per pianificare l'automazione CI/CD e connetterla a CI/CD con Capgo per il workflow del prodotto in Capgo CI/CD, Capgo Native Build per il workflow di prodotto in Capgo Native Builds, Integrazioni Capgo per il workflow di prodotto in Integrazioni Capgo, Integrazione CI/CD per i dettagli implementativi in CI/CD Integration, e Integrazione GitHub Actions per i dettagli implementativi in GitHub Actions Integration.