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 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 un'iterazione rapida.

Vantaggi dell'integrazione CI/CD

Automazione : Nessun passaggio manuale o spazio per errori umani. Il tuo processo di creazione, 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.
Frazioni di iterazione più veloci: Con le distribuzioni automatizzate, puoi spedire aggiornamenti più frequentemente e con fiducia. Non devi più attendere la verifica manuale o le autorizzazioni di rilascio.

Capgo CLI

La chiave per integrare Capgo nel tuo workflow CI/CD è Capgo CLI . 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:

Ottieni il contenuto della tua chiave privata:
Finestra del terminale
```
cat .capgo_key_v2 | pbcopy
```
Questo copia il contenuto della chiave nella clipboard.
Aggiungilo all'ambiente CI/CD:
- GitHub Azioni: Aggiungi CAPGO_PRIVATE_KEY al segreti del tuo repository
- GitLab CI: Aggiungilo come variabile mascherata nei impostazioni del tuo progetto
- CircleCI: Aggiungilo come variabile di ambiente nelle impostazioni del tuo 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 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 sul canale specificato. Di solito eseguirai questo comando come ultimo passo del tuo pipeline CI/CD, dopo che la versione web è stata completata con successo.

Impostazione di Capgo nel tuo 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 API chiave: Accedi al dashboard di Capgo e crea una nuova API chiave. Questa chiave verrà utilizzata per autenticare il CLI nel tuo ambiente CI/CD. Tienila segreta e non commetterla mai nel tuo repository!
Configura il bundle upload comando: Aggiungi un passo alla 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 }}
```
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 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 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 della versione con Semantic-release

Il modo consigliato per gestire la versione con Capgo è impostare la versione nel tuo capacitor.config.ts file caricandolo 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'applicazione con la versione aggiornata inclusa automaticamente
Inviare il bundle con la versione corretta

Il tuo workflow CI/CD avrebbe l'aspetto seguente:

- 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 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 CHANGELOG.md, package.json, e tutti gli altri file modificati, nuovamente nel repository.

Assicurati di eseguire semantic-release prima di costruire l'applicazione, in modo che la versione aggiornata da package.json venga inclusa nel tuo build attraverso il capacitor.config.

Risoluzione dei problemi

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

API chiave: Assicurati che la tua API chiave sia valida e abbia le necessarie autorizzazioni. 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 potrebbero avere problemi di compatibilità o mancare di alcune funzionalità.
Articoli di costruzione: Verifica che la tua build web generi i file di output previsti. I Capgo CLI richiedono una build web valida per creare un bundle.
Connessione di rete: Controlla che il tuo ambiente CI/CD abbia accesso alla rete ai server Capgo. Problemi di firewall o proxy possono interferire con la upload comando.

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

Conclusioni

Integrare 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 le versioni attraverso l'approccio capacitor.config, puoi spedire aggiornamenti più velocemente e con maggiore fiducia.

L'approccio consigliato di impostare la versione nel tuo capacitor.config.ts file e utilizzare semantic-release per aggiornare 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 referenceEcco ulteriori informazioni sulla configurazione di semantic-release. Consulta i docs di semantic-release.

Buona fortuna con la distribuzione!

Continua dall'Integrazione CI/CD

Se stai utilizzando Integrazione CI/CD per pianificare l'automazione CI/CD, connettilo con Capgo Integrazione CI/CD for the product workflow in Capgo CI/CD, Capgo Integrazione CI/CD, 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 dell'azione per la dettaglio di implementazione in GitHub Integrazione dell'azione, e Integrazione CI/CD di GitLab per la dettaglio di implementazione in Integrazione CI/CD di GitLab.