Integrazione CI/CD

Copia un prompt 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 CLI e semantic-release, puoi garantire distribuzioni coerenti e affidabili e abilitare l'iterazione rapida.

Vantaggi dell'integrazione CI/CD

Automazione: Nessun passo manuale o margine per errori umani. Il tuo processo di costruzione, test e distribuzione può essere automatizzato da fine a fine.
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 utilizzi l'encryption dovresti fornirlo da uno di questi modi:

Utilizzando un 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 la crittografia

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

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

Usalo 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 in cui non si desidera creare file temporanei.

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

Configurazione di Capgo nella pipeline CI/CD

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

Genera una chiave API: Accedi al Capgo dashboard 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 una fase alla tua configurazione CI/CD che esegue 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 upload passo dopo la tua costruzione web: Assicurati che il upload passo venga eseguito dopo che la tua costruzione web sia stata completata con successo. Ciò assicura di sempre distribuire la tua versione più recente 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 caricando il contenuto 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 version
Costruisci l'app con la versione aggiornata inclusa automaticamente
Carica 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 di 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 di Conventional Commits.
Genera note di rilascio in base ai commit dallo scorso rilascio.
Aggiorna il CHANGELOG.md file con le note sulla nuova versione.
Aggiorna il package.json la versione, che verrà presa in carico dal tuo capacitor.config.
Commette gli aggiornamenti dei CHANGELOG.md, package.json, e di qualsiasi altro file modificato, nel repository.

Assicurati di eseguire semantic-release prima di costruire il tuo app, in modo che la versione aggiornata da package.json venga inclusa nel tuo 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 API chiave sia valida e abbia le necessarie autorizzazioni. Se si utilizza una variabile di ambiente, controlla che sia impostata correttamente.
CLI version: Assicurati di utilizzare la versione più recente di Capgo CLI. Le versioni più vecchie possono avere problemi di compatibilità o mancare di alcune funzionalità.
Build artifacts: Conferma che la tua build web sta generando i file di output previsti. Il Capgo CLI richiede una build web valida per creare un bundle.
Network connectivity: Controlla che il tuo ambiente CI/CD abbia accesso a rete ai server Capgo. I problemi di firewall o proxy possono interferire con il comando. upload command.

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

Conclusion

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 versionando 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 utilizzando 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 il CLI riferimento. E per una visione più approfondita della configurazione di semantic-release, vedi i docs di semantic-release.

Buon rilascio!

Continua dall'Integrazione CI/CD

Integrazione CI/CD per pianificare l'automazione CI/CD, connettilo con Se stai utilizzando l'Integrazione CI/CD 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 GitHub Integrazione delle Azioni per il dettaglio di implementazione in GitHub Integrazione delle Azioni, e Integrazione CI/CD di GitLab per il dettaglio di implementazione in Integrazione CI/CD di GitLab