Integrazione CI/CD

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

L'integrazione di Capgo nella tua pipeline CI/CD ti consente di automatizzare completamente il processo di creazione e distribuzione di aggiornamenti per la tua app. Utilizzando il Capgo e il CLI e semantic-release, puoi garantire distribuzioni coerenti e affidabili e abilitare l'iterazione rapida.

Vantaggi dell'integrazione CI/CD

Automazione: Nessun passaggio manuale o margine di errore umano. Il tuo processo di costruzione, 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 code.
Iterazioni più veloci: Con le distribuzioni automatizzate, puoi spedire aggiornamenti più frequentemente e con fiducia. Nessun aspettativa per la QA manuale o le autorizzazioni di rilascio.

Capgo CLI

La 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 ancora.

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

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

Se usi 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 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 migliore per CI/CD):

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

Impostazione delle Variabili di Ambiente per l'Encryption

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

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

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 flag consente di passare il contenuto della chiave privata direttamente come stringa, rendendolo perfetto per le variabili di ambiente nei pipeline CI/CD dove non si desidera creare file temporanei.

Questo comando carica la versione web corrente nel canale specificato. Di solito eseguirai questo comando come ultimo passo nella tua pipeline CI/CD, dopo che la versione web è stata completata con successo.

Configurazione di Capgo nella tua pipeline 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 chiave API: Log in to the Capgo dashboard and create a new API key. This key will be used to authenticate the CLI in your CI/CD environment. Keep it secret and never commit it to your repository!
Questa chiave verrà utilizzata per autenticare il __CAPGO_KEEP_2__ nel tuo ambiente CI/CD. Tienila segreta e non la commettere mai nel tuo repository! bundle upload Configura ilcomando bundle upload : Aggiungi una fase alla tua configurazione CI/CD che esegue il
comando con gli argomenti appropriati:
```
- run: npx @capgo/cli@latest bundle upload --channel=production --apikey=${{ secrets.CAPGO_API_KEY }}
```
Copia nel portapenne Production \n Sostituisci ${{ secrets.CAPGO_API_KEY }} with the environment variable holding your API key, and add --key-data-v2 "${{ secrets.CAPGO_PRIVATE_KEY }}" con la variabile di ambiente che contiene la tua chiave __CAPGO_KEEP_0__ e aggiungi

Aggiungi il upload passo dopo la tua build web: Assicurati che il upload step comes after your web build has completed successfully. This ensures you’re always deploying your latest code.\n Here’s an example configuration for 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 }}"

Copia nel portapenne

The recommended way to handle versioning with Capgo is to set the version in your capacitor.config.ts Il modo consigliato per gestire la versioning con __CAPGO_KEEP_0__ è impostare la versione nel tuo package.json:

import pkg from './package.json'

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

Copia nel portapenne

Usa semantic-release (o qualsiasi altro strumento) per aggiornare il package.json __CAPGO_KEEP_0__
Costruisci l'applicazione con la versione aggiornata inclusa automaticamente
Carica il bundle con la versione corretta

Il tuo workflow CI/CD sarebbe simile a questo:

- 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 di .releaserc __CAPGO_KEEP_0__

{
  "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 il file con le note di rilascio nuove.
Aggiorna la package.json che verrà presa in carico dal tuo capacitor.config.
Fai commit degli aggiornamenti CHANGELOG.md, package.json, e di eventuali altri file modificati, nel repository.

Assicurati di eseguire semantic-release prima di costruire il tuo app, in modo che la versione aggiornata da package.json sia inclusa nella tua build attraverso il capacitor.config.

Risolvere i problemi

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

API chiave: Assicurati che la tua chiave API sia valida e abbia le autorizzazioni necessarie. Se utilizzi 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 pacchetto.
Connessione di rete: Controlla che il tuo ambiente CI/CD abbia accesso a rete ai server Capgo. I problemi di firewall o proxy possono interferire con il upload comando.

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

Conclusioni

L'integrazione di Capgo nel tuo pipeline CI/CD con una gestione delle versioni corretta può notevolmente semplificare il tuo workflow di sviluppo. Automatizzando le tue distribuzioni e la versioning 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 e sulle opzioni di configurazione di semantic-release, consulta la CLI reference. E per una visione più approfondita della configurazione di semantic-release, vedi i docs di semantic-release.

Buona fortuna con il tuo rilascio!