Bitbucket Pipelines Integration

Integriere Capgo Live Updates mit Bitbucket Pipelines, um deine App-Updates automatisch zu deployen, sobald du code Änderungen pushst. Dieser Guide deckt das Setup für automatisierte Builds, Tests und Deployment-Workflows ab.

Voraussetzungen

Bevor du die Bitbucket Pipelines Integration einrichtest, stelle sicher, dass du Folgendes hast:

• Ein Bitbucket-Konto mit einem Repository
• Ein Capgo Konto mit einer konfigurierten App
• Node.js und npm/yarn in deinem Projekt konfiguriert

Bitbucket Pipelines einrichten

Schritt 1: Repository-Variablen konfigurieren

Richte zuerst die erforderlichen Variablen in deinem Bitbucket-Repository ein:

1. Navigiere zu deinem Bitbucket-Repository
2. Gehe zu Repository-Einstellungen → Pipelines → Repository-Variablen
3. Füge die folgenden Variablen hinzu:

Variablenname	Value	Secured
CAPGO_TOKEN	Dein Capgo API Token	✅ Ja

Tipp

Hol dir deinen Capgo API Token unter console.capgo.app/apikeys. Deine App-ID ist bereits in deiner capacitor.config.ts file.

Einfach

Basis-Konfiguration, die bei jedem Push auf den main-Branch in die Production deployt:

# bitbucket-pipelines.yml - Simple Configuration
image: node:22

pipelines:
  branches:
    main:
      - step:
          name: Build and Deploy to Production
          script:
            - npm ci
            - npm run test
            - npm run build
            - npm install -g @capgo/cli
            - npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel production
          artifacts:
            - dist/**

Erweitert

Feature-Branch-Deployments

Deploye Feature-Branches in Test-Channels für Reviews und Tests:

# Feature branch deployment
pipelines:
  branches:
    feature/*:
      - step:
          name: Deploy Feature Branch
          script:
            - npm ci
            - npm run test
            - npm run build
            - BRANCH_NAME=$(echo $BITBUCKET_BRANCH | sed 's/[^a-zA-Z0-9-]/-/g')
            - CHANNEL_NAME="feature-$BRANCH_NAME"
            - npm install -g @capgo/cli
            - npx @capgo/cli channel add $CHANNEL_NAME --apikey $CAPGO_TOKEN || true
            - npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel $CHANNEL_NAME
          artifacts:
            - dist/**

Tipp

Testen mit Channels: Nachdem du in einen Feature-Channel deployed hast, kannst du das Update in deiner App testen, indem du sie so konfigurierst, dass sie diesen spezifischen Channel nutzt. Erfahre mehr über die Konfiguration von Channels in deiner App.

Verschlüsselung nutzen

If you’re using die Verschlüsselungsfunktion von Capgonutzt, musst du deinen privaten Schlüssel sicher in deiner CI/CD-Umgebung speichern.

Nachdem du die Verschlüsselungsschlüssel Füge deinen privaten Key lokal zu den Bitbucket-Variablen hinzu:

# Display your private key content (copy this output)
cat .capgo_key_v2

Füge diesen Inhalt als CAPGO_PRIVATE_KEY in deinen Bitbucket-Repository-Variablen hinzu (als „secured“ markieren) und nutze ihn dann in Pipelines:

# Deploy with encryption
- step:
    name: Deploy to Capgo with Encryption
    script:
      - npm install -g @capgo/cli
      - npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --key-data-v2 "$CAPGO_PRIVATE_KEY" --channel production

Achtung

Best Practices für die Sicherheit:

• Commiten Sie niemals die .capgo_key_v2 Datei in die Versionsverwaltung
• Speichern Sie den Private Key nur in einem sicheren CI/CD Secret Management
• Nutzen Sie unterschiedliche Keys für verschiedene Umgebungen

Multi-Channel-Konfiguration

Für umfassende Informationen zur Einrichtung und Verwaltung mehrerer Deployment-Channels lesen Sie die Channels-Dokumentation.

Vollständige Konfiguration mit mehreren Umgebungen und Pull-Request-Deployments:

# bitbucket-pipelines.yml - Advanced Multi-Channel Configuration
image: node:22

definitions:
  steps:
    - step: &build-step
        name: Build Application
        script:
          - npm ci
          - npm run test
          - npm run build
        artifacts:
          - dist/**

    - step: &deploy-step
        name: Deploy to Capgo
        script:
          - npm install -g @capgo/cli
          - npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel $CHANNEL_NAME

pipelines:
  branches:
    main:
      - step:
          <<: *build-step
      - step:
          <<: *deploy-step
          name: Deploy to Production
          deployment: production
          trigger: manual
          script:
            - export CHANNEL_NAME=production
            - npm install -g @capgo/cli
            - npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel $CHANNEL_NAME

    develop:
      - step:
          <<: *build-step
      - step:
          <<: *deploy-step
          name: Deploy to Development
          deployment: development
          script:
            - export CHANNEL_NAME=development
            - npm install -g @capgo/cli
            - npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel $CHANNEL_NAME

  pull-requests:
    '**':
      - step:
          <<: *build-step
      - step:
          name: Deploy PR to Test Channel
          script:
            - CHANNEL_NAME="pr-$BITBUCKET_PR_ID"
            - npm install -g @capgo/cli
            - npx @capgo/cli channel add $CHANNEL_NAME --apikey $CAPGO_TOKEN || true
            - npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel $CHANNEL_NAME
          artifacts:
            - dist/**

Multi-Environment-Pipeline

Für komplexe Deployment-Szenarien mit Staging- und Production-Umgebungen:

# Multi-environment pipeline
image: node:22

pipelines:
  branches:
    main:
      - step:
          name: Build
          script:
            - npm ci
            - npm run test
            - npm run build
          artifacts:
            - dist/**
      - step:
          name: Deploy to Staging
          deployment: staging
          script:
            - npm install -g @capgo/cli
            - npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel staging
      - step:
          name: Deploy to Production
          deployment: production
          trigger: manual
          script:
            - npm install -g @capgo/cli
            - npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel production

    develop:
      - step:
          name: Build and Deploy to Development
          script:
            - npm ci
            - npm run test
            - npm run build
            - npm install -g @capgo/cli
            - npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel development
          artifacts:
            - dist/**

Branch-basierte Deployment-Strategie

Verschiedene Branches automatisch in die passenden Channels deployen:

# Dynamic channel deployment
image: node:22

definitions:
  scripts:
    - script: &determine-channel |
        if [ "$BITBUCKET_BRANCH" = "main" ]; then
          export CHANNEL_NAME="production"
        elif [ "$BITBUCKET_BRANCH" = "develop" ]; then
          export CHANNEL_NAME="staging"
        else
          export CHANNEL_NAME="development"
        fi
        echo "Deploying to channel: $CHANNEL_NAME"

pipelines:
  default:
    - step:
        name: Build and Deploy
        script:
          - npm ci
          - npm run test
          - npm run build
          - *determine-channel
          - npm install -g @capgo/cli
          - npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel $CHANNEL_NAME
        artifacts:
          - dist/**

Parallele Pipeline-Ausführung

Build-Zeiten durch parallele Steps optimieren:

# Parallel execution pipeline
image: node:22

pipelines:
  branches:
    main:
      - parallel:
          - step:
              name: Run Tests
              script:
                - npm ci
                - npm run test
          - step:
              name: Lint Code
              script:
                - npm ci
                - npm run lint
      - step:
          name: Build Application
          script:
            - npm ci
            - npm run build
          artifacts:
            - dist/**
      - step:
          name: Deploy to Production
          deployment: production
          script:
            - npm install -g @capgo/cli
            - npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel production

Sicherheits-Best-Practices

Repository-Variablen

1. Gesicherte Variablen: Markiere API Tokens immer als gesichert
2. Umgebungsvariablen: Nutze bei Bedarf deployment-spezifische Variablen
3. Zugriffskontrolle: Beschränke den Repository-Zugriff auf autorisierte Teammitglieder
4. Token-RotationRotiere regelmäßig deine Capgo API Tokens

Deployment-Umgebungen

Konfiguriere Deployment-Umgebungen für mehr Sicherheit:

# Deployment with environment restrictions
pipelines:
  branches:
    main:
      - step:
          name: Deploy to Production
          deployment: production
          trigger: manual
          script:
            - npm install -g @capgo/cli
            - npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel production

Monitoring und Benachrichtigungen

Slack-Integration

Füge Slack-Benachrichtigungen zu deiner Pipeline hinzu:

# Pipeline with Slack notifications
pipelines:
  branches:
    main:
      - step:
          name: Build and Deploy
          script:
            - npm ci
            - npm run test
            - npm run build
            - npm install -g @capgo/cli
            - npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel production
          after-script:
            - |
              if [ $BITBUCKET_EXIT_CODE -eq 0 ]; then
                curl -X POST -H 'Content-type: application/json' \
                  --data '{"text":"✅ Capgo deployment successful for '$BITBUCKET_BRANCH'"}' \
                  $SLACK_WEBHOOK_URL
              else
                curl -X POST -H 'Content-type: application/json' \
                  --data '{"text":"❌ Capgo deployment failed for '$BITBUCKET_BRANCH'"}' \
                  $SLACK_WEBHOOK_URL
              fi

E-Mail-Benachrichtigungen

Konfiguriere E-Mail-Benachrichtigungen über die integrierten Bitbucket-Funktionen oder externe Dienste:

# Email notification step
- step:
    name: Send Notification
    script:
      - |
        curl -X POST \
          -H "Content-Type: application/json" \
          -d '{
            "to": "team@yourcompany.com",
            "subject": "Capgo Deployment Status",
            "body": "Deployment of '$BITBUCKET_BRANCH' completed with status: '$BITBUCKET_EXIT_CODE'"
          }' \
          $EMAIL_SERVICE_URL
    condition:
      result: [successful, failed]

Fehlerbehebung

Häufige Probleme

Pipeline schlägt fehl mit „Capgo CLI not found“:

# Debug CLI installation
- step:
    name: Debug CLI
    script:
      - npm install -g @capgo/cli
      - which capgo || echo "Capgo CLI not found"
      - npx @capgo/cli --version

Authentifizierungsfehler:

# Verify token configuration
- step:
    name: Debug Auth
    script:
      - |
        if [ -z "$CAPGO_TOKEN" ]; then
          echo "CAPGO_TOKEN is not set"
          exit 1
        fi
        echo "Token length: ${#CAPGO_TOKEN}"

Build-Artefakte nicht gefunden:

# List build outputs
- step:
    name: Debug Build
    script:
      - ls -la dist/
      - find dist/ -type f -name "*.js" -o -name "*.html"

Pipeline debuggen

Füge Debugging-Infos hinzu, um Probleme zu beheben:

# Debug pipeline
pipelines:
  branches:
    main:
      - step:
          name: Debug Information
          script:
            - echo "Branch: $BITBUCKET_BRANCH"
            - echo "Commit: $BITBUCKET_COMMIT"
            - echo "Build: $BITBUCKET_BUILD_NUMBER"
            - env | grep BITBUCKET_ | sort
      - step:
          name: Build and Deploy
          script:
            - npm ci
            - npm run test
            - npm run build
            - npm install -g @capgo/cli
            - npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel production

Pipeline-Validierung

Aktiviere die Pipeline-Validierung, um Konfigurationsfehler zu finden:

# Enable pipeline validation
options:
  docker: true
  size: 2x

pipelines:
  branches:
    main:
      - step:
          name: Validate Pipeline
          script:
            - echo "Pipeline validation successful"
      - step:
          name: Build and Deploy
          script:
            # ... deployment steps

Nächste Schritte

• Erfahre mehr über Channels um verschiedene Deployment-Umgebungen zu verwalten
• Entdecken Eigener Speicher für fortgeschrittene Deployment-Szenarien
• Einrichten Verschlüsselung für sichere Deployments
• Konfigurieren Update-Verhalten um die Anwendung von Updates anzupassen

Mit der Bitbucket Pipelines Integration kannst du deine Capgo Deployments automatisieren und konsistente, zuverlässige Updates für deine Mobile-App-Nutzer sicherstellen.

Weiter mit der Bitbucket Pipelines Integration

If you are using Bitbucket Pipelines Integration nutzt, um CI/CD-Automatisierung zu planen, verbinde sie mit Capgo CI/CD für den Produkt-Workflow in Capgo CI/CD, Capgo Native Builds für den Produkt-Workflow in Capgo Native Builds, Capgo Integrationen für den Produkt-Workflow in Capgo Integrations, CI/CD-Integration für die Implementierungsdetails in der CI/CD-Integration und GitHub Actions-Integration für die Implementierungsdetails in der GitHub Actions-Integration.