Integrazione CI/CD

Copia un promemoria di configurazione con i passaggi di installazione e la guida markdown completa per questo plugin.

L'integrazione di Capgo nel tuo pipeline CI/CD ti consente di automatizzare completamente il processo di creazione e distribuzione di aggiornamenti per la tua app. Sfruttando il Capgo CLI e semantic-release, puoi garantire deployment coerenti, affidabili e consentire iterazioni rapide.

Vantaggi dell'integrazione CI/CD

L'automazione: Nessun passaggio manuale o spazio per errori umani. Il tuo processo di creazione, test e distribuzione può essere automatizzato da capo a fondo.
Consistenza: Ogni distribuzione segue lo stesso set di passaggi, garantendo un processo prevedibile e ripetibile. Ciò è particolarmente utile quando hai più membri del team che contribuiscono a code.
Iterazioni più rapide: Con le distribuzioni automatizzate, puoi spedire aggiornamenti più frequentemente e con fiducia. Nessun aspettare per la QA manuale o le autorizzazioni di rilascio.

Capgo CLI

Il Capgo CLI è la chiave per integrare Capgo nel tuo workflow CI/CD. Fornisce comandi per l'invio di nuove versioni di bundle, la gestione dei canali e altro.

Il comando più importante per l'integrazione CI/CD è bundle upload:

npx @capgo/cli@latest bundle upload --channel Production --apikey YOUR_API_KEY

Se utilizzi l'encryption dovresti fornirlo in uno dei seguenti modi:

Utilizzando il percorso del file della chiave privata:

npx @capgo/cli@latest bundle upload --channel Production --apikey YOUR_API_KEY --key-v2 PRIVATE_KEY_PATH

Utilizzando il contenuto della chiave privata direttamente (consigliato per l'integrazione CI/CD):

npx @capgo/cli@latest bundle upload --channel Production --apikey YOUR_API_KEY --key-data-v2 PRIVATE_KEY_CONTENT

Utilizzando le variabili di ambiente (pratica consigliata per CI/CD):

npx @capgo/cli@latest bundle upload --channel Production --apikey YOUR_API_KEY --key-data-v2 "$CAPGO_PRIVATE_KEY"

Configurazione delle variabili di ambiente per la crittografia

In ambienti CI/CD, si consiglia di memorizzare la tua chiave privata come variabile di ambiente piuttosto che come file. Ecco come farlo:

Ottieni il contenuto della tua chiave privata:
Fermata di terminale
```
cat .capgo_key_v2 | pbcopy
```
Questo copia il contenuto della chiave nel portapenna.
Aggiungilo all'ambiente CI/CD:
- GitHub Azioni: Aggiungi CAPGO_PRIVATE_KEY a segreti del tuo repository
- GitLab CI: Aggiungilo come variabile mascherata nei tuoi impostazioni del progetto
- CircleCI: Aggiungilo come variabile di ambiente nelle impostazioni del progetto
- Jenkins: Aggiungilo come credenziale di testo segreta

Utilizzalo nella tua pipeline:

- run: npx @capgo/cli@latest bundle upload --channel=production --apikey=${{ secrets.CAPGO_API_KEY }} --key-data-v2 "${{ secrets.CAPGO_PRIVATE_KEY }}"

Nota: Il --key-data-v2 il flag consente di passare il contenuto della chiave privata direttamente come stringa, rendendolo perfetto per le variabili di ambiente nei flussi CI/CD in cui non si desidera creare file temporanei.

Questo comando carica la build web corrente sul canale specificato. Esegui di solito questo comando come passo finale nel tuo flusso CI/CD, dopo che la build web è stata completata con successo.

Configurazione di Capgo nel tuo flusso CI/CD

Mentre i passaggi esatti varieranno a seconda della tua scelta di strumento CI/CD, il processo generale per l'integrazione di Capgo assomiglia a questo:

Genera una API chiave: Accedi al pannello di controllo Capgo e crea una nuova API chiave. Questa chiave verrà utilizzata per autenticare il CLI nel tuo ambiente CI/CD. Tienila segreta e non la commettere mai nel tuo repository!
Configura il bundle upload comando: Aggiungi un passo alla tua configurazione CI/CD che esegua il bundle upload comando con gli argomenti appropriati:
upload.yml
```
- run: npx @capgo/cli@latest bundle upload --channel=production --apikey=${{ secrets.CAPGO_API_KEY }}
```
\n Sostituisci Production con il canale che desideri distribuire, ${{ secrets.CAPGO_API_KEY }} con la variabile di ambiente che contiene la tua API chiave, e aggiungi --key-data-v2 "${{ secrets.CAPGO_PRIVATE_KEY }}" se si utilizza la crittografia.

Aggiungi il upload passaggio dopo la tua costruzione web: Assicurati che il upload passaggio venga eseguito dopo che la tua costruzione web sia stata completata con successo. Ciò assicura che sempre stai distribuendo la tua ultima code.\n Ecco un esempio di configurazione per GitHub Actions:\n

name: Deploy to Capgo
 on:
  push:
   branches: [main]

jobs:
 deploy:
 runs-on: ubuntu-latest

 steps:
 - uses: actions/checkout@v6
 - uses: actions/setup-node@v6
  with:
   node-version: '24'

 - run: npm ci
 - run: npm run build

 - run: npm install -g @capgo/cli
 - run: npx @capgo/cli@latest bundle upload --channel=production --apikey=${{ secrets.CAPGO_API_KEY }} --key-data-v2 "${{ secrets.CAPGO_PRIVATE_KEY }}"

Gestione delle versioni con Semantic-release

Il modo consigliato per gestire la versioning con Capgo è impostare la versione nel tuo capacitor.config.ts file importandolo da package.json:

import pkg from './package.json'

const config: CapacitorConfig = {
  // ... other config
  plugins: {
    CapacitorUpdater: {
      version: pkg.version,
    }
  }
}

Questa approccio consente di:

Utilizzare semantic-release (o qualsiasi altro strumento) per aggiornare la package.json versione
Costruire l'app con la versione aggiornata inclusa automaticamente
Caricare il bundle con la versione corretta

La tua pipeline CI/CD sarebbe come questa:

- run: npm ci
- run: npx semantic-release  # Updates package.json version
- run: npm run build         # Builds with new version from capacitor.config
- run: npx @capgo/cli@latest bundle upload --channel=production --apikey=${{ secrets.CAPGO_API_KEY }}

Ecco un esempio .releaserc file di configurazione per semantic-release:

{
  "branches": [
    "main",
    {
      "name": "beta",
      "prerelease": true
    }
  ],
  "plugins": [
    "@semantic-release/commit-analyzer",
    "@semantic-release/release-notes-generator",
    "@semantic-release/changelog",
    [
      "@semantic-release/git",
      {
        "assets": ["CHANGELOG.md", "package.json"],
        "message": "chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
      }
    ]
  ]
}

Questa configurazione fa le seguenti cose:

Analizza i messaggi di commit per determinare il numero di versione successivo, seguendo lo spec del Conventional Commits.
Genera note di rilascio in base ai commit effettuati dalla versione precedente.
Aggiorna il CHANGELOG.md file con le nuove note di rilascio.
Aggiorna il package.json numero di versione, che verrà rilevato dal tuo capacitor.config.
Commette gli aggiornamenti al CHANGELOG.md, package.jsone a tutti gli altri file modificati nel repository.

Assicurati di eseguire semantic-release prima di costruire il tuo app per assicurarti che la versione aggiornata venga rilevata. package.json is incluso nella tua build attraverso il capacitor.config.

Risoluzione dei problemi

Se incontri problemi con l'integrazione del tuo Capgo CI/CD, ecco alcune cose da controllare:

API chiave: Assicurati che la tua API chiave sia valida e abbia le necessarie autorizzazioni. Se si utilizza una variabile di ambiente, controlla che sia impostata correttamente.
CLI versione: Assicurati di utilizzare la versione più recente del Capgo CLI. Le versioni più vecchie possono avere problemi di compatibilità o mancare di alcune funzionalità.
Articoli di costruzione: Conferma che la tua build web genera i file di output previsti. Il Capgo CLI richiede una build web valida per creare un bundle.
Connettività di rete: Controlla che l'ambiente CI/CD abbia accesso a rete ai server Capgo. I problemi di firewall o proxy possono interferire con il funzionamento del servizio. upload command.

Se hai ancora difficoltà, contatta il supporto Capgo per ricevere assistenza. Possono aiutarti a risolvere qualsiasi problema con la tua configurazione specifica.

Conclusion

L'integrazione di Capgo nella tua pipeline CI/CD con una gestione delle versioni corretta può notevolmente semplificare il tuo workflow di sviluppo. Automatizzando le tue distribuzioni e versioni attraverso l'approccio capacitor.config, puoi spedire aggiornamenti più velocemente e con maggiore fiducia.

L'approccio consigliato di impostazione della versione nel tuo capacitor.config.ts file e l'utilizzo di semantic-release per l'aggiornamento package.json fornisce un processo di distribuzione robusto e affidabile che ti consente di concentrarti sulla creazione di grandi funzionalità piuttosto che preoccuparti dei passaggi di rilascio manuali.

Per ulteriori informazioni sui comandi e le opzioni Capgo CLI, consulta la CLI reference. E per una maggiore profondità di analisi della configurazione di semantic-release, vedi i semantic-release docs.

Felice di deployare!

Continua dall'Integrazione CI/CD

Se stai utilizzando Integrazione CI/CD per pianificare l'automazione CI/CD, connettilo con Capgo Integrazione CI/CD per il flusso di lavoro del prodotto in Capgo Integrazione 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 Azioni di integrazione di GitHub per i dettagli di implementazione in Azioni di integrazione di GitHub e Integrazione CI/CD di GitLab per i dettagli di implementazione in Integrazione CI/CD di GitLab.