Azure DevOps-Integration

Integriere Capgo Live Updates mit Azure DevOps Pipelines, um Ihre App-Updates automatisch zu deployen, sobald Sie code Änderungen vornehmen. Diese Anleitung deckt die Einrichtung von automatisierten Builds, Tests und Bereitstellungsworkflows ab.

Voraussetzungen

Bevor Sie die Azure DevOps-Integration einrichten, stellen Sie sicher, dass Sie haben:

• Eine Azure DevOps-Organisation und ein Projekt
• Eine Capgo-Konto mit einer konfigurierten App
• Die Quell- code Ihres Apps in einem Azure Repos Git-Repository
• Node.js und npm/yarn in Ihrem Projekt konfiguriert

Einstellung von Azure DevOps Pipeline

Schritt 1: Erstellen von Pipeline-Variablen

Zunächst müssen Sie in Ihrem Azure DevOps-Projekt die notwendigen Variablen einrichten:

1. Navigieren Sie zu Ihrem Azure DevOps-Projekt
2. Gehe zu Pipelines → Bibliothek → Variablengruppen
3. Erstellen Sie eine neue Variablengruppe mit dem Namen Capgo-Variables
4. Fügen Sie die folgenden Variablen hinzu:

Variablenname	Wert	Sicher
CAPGO_TOKEN	Ihr Capgo API Token	✅ Ja

Tip

Erhalten Sie Ihr Capgo API Token von console.capgo.app/apikeysIhr App-ID ist bereits in Ihrem capacitor.config.ts Datei konfiguriert.

Einfach

Grundlegende Konfiguration, die auf jeden Push in die Hauptzweig in die Produktion deployt:

# Simple Azure DevOps Pipeline for Capgo Live Updates
trigger:
  branches:
    include:
      - main

variables:
  - group: Capgo-Variables

jobs:
  - job: BuildAndDeploy
    displayName: 'Build and Deploy to Capgo'
    pool:
      vmImage: 'ubuntu-latest'

    steps:
      - task: NodeTool@0
        displayName: 'Setup Node.js'
        inputs:
          versionSpec: '22.x'

      - script: |
          npm ci
          npm run test
          npm run build
        displayName: 'Install, test and build'

      - script: |
          npm install -g @capgo/cli
          npx @capgo/cli bundle upload --apikey $(CAPGO_TOKEN) --channel production
        displayName: 'Deploy to Capgo'

Erfahrener

Feature-Zweig-Deployments

Deploy Feature-Zweige in Testkanäle für Überprüfung und Testen:

# Feature branch deployment
trigger:
  branches:
    include:
      - feature/*

variables:
  - group: Capgo-Variables

jobs:
  - job: DeployFeature
    displayName: 'Deploy Feature Branch'
    pool:
      vmImage: 'ubuntu-latest'
    condition: startsWith(variables['Build.SourceBranch'], 'refs/heads/feature/')

    steps:
      - task: NodeTool@0
        inputs:
          versionSpec: '22.x'

      - script: |
          npm ci
          npm run test
          npm run build
        displayName: 'Install, test and build'

      - script: |
          BRANCH_NAME=$(echo "$(Build.SourceBranchName)" | sed 's/[^a-zA-Z0-9-]/-/g')
          CHANNEL_NAME="feature-$BRANCH_NAME"
          npm install -g @capgo/cli
          npx @capgo/cli channel create $CHANNEL_NAME --apikey $(CAPGO_TOKEN) || true
          npx @capgo/cli bundle upload --apikey $(CAPGO_TOKEN) --channel $CHANNEL_NAME
        displayName: 'Deploy to Feature Channel'

Tipp

Testen mit Kanälen: Nach der Bereitstellung in einem Feature-Kanal können Sie die Aktualisierung in Ihrer App testen, indem Sie sie auf diesen spezifischen Kanal konfigurieren. Erfahren Sie mehr über die Konfiguration von Kanälen in Ihrer App Konfigurieren Sie Kanäle in Ihrer App.

Verwendung der Verschlüsselung

Wenn Sie die Verschlüsselungsfunktion von __CAPGO_KEEP_0__ verwenden Capgo’s encryption featureNachdem

die Verschlüsselungsschlüssel eingerichtet wurden lokale, fügen Sie Ihren privaten Schlüssel zu den Azure DevOps-Variablen hinzu: Terminalfenster

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

Fügen Sie diesen Inhalt als CAPGO_PRIVATE_KEY im Azure DevOps-Variablenbereich (als Geheimnis markieren), dann verwenden Sie es in Pipelines:

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

Achtung

Security Best Practices:

• Kommt nie in die Versionierung .capgo_key_v2 Speichern Sie den privaten Schlüssel nur in einer sicheren CI/CD-Schlüsselverwaltung
• Verwenden Sie unterschiedliche Schlüssel für unterschiedliche Umgebungen
• Multi-Channel-Konfiguration

Abschnitt mit dem Titel „Multi-Channel-Konfiguration“

Für umfassende Informationen zur Einrichtung und Verwaltung mehrerer Bereitstellungskanäle, siehe die Dokumentation zu Kanälen.

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

# Advanced Azure DevOps Pipeline with Multiple Channels
trigger:
  branches:
    include:
      - main
      - develop

pr:
  branches:
    include:
      - main
      - develop

variables:
  - group: Capgo-Variables

stages:
  # Build stage
  - stage: Build
    jobs:
      - job: BuildApp
        pool:
          vmImage: 'ubuntu-latest'
        steps:
          - task: NodeTool@0
            inputs:
              versionSpec: '22.x'

          - script: |
              npm ci
              npm run test
              npm run build
            displayName: 'Install, test and build'

          - task: PublishBuildArtifacts@1
            inputs:
              pathToPublish: 'dist'
              artifactName: 'app-build'

  # Deploy to development
  - stage: DeployDev
    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/develop'))
    jobs:
      - deployment: DeployDevelopment
        environment: development
        pool:
          vmImage: 'ubuntu-latest'
        strategy:
          runOnce:
            deploy:
              steps:
                - task: NodeTool@0
                  inputs:
                    versionSpec: '22.x'

                - task: DownloadBuildArtifacts@0
                  inputs:
                    artifactName: 'app-build'
                    downloadPath: '$(Pipeline.Workspace)'

                - script: |
                    npm install -g @capgo/cli
                    npx @capgo/cli bundle upload --apikey $(CAPGO_TOKEN) --channel development --path $(Pipeline.Workspace)/app-build
                  displayName: 'Deploy to Development'

  # Deploy PR to test channel
  - stage: DeployPR
    condition: and(succeeded(), eq(variables['Build.Reason'], 'PullRequest'))
    jobs:
      - job: DeployPRChannel
        pool:
          vmImage: 'ubuntu-latest'
        steps:
          - task: NodeTool@0
            inputs:
              versionSpec: '22.x'

          - task: DownloadBuildArtifacts@0
            inputs:
              artifactName: 'app-build'
              downloadPath: '$(Pipeline.Workspace)'

          - script: |
              CHANNEL_NAME="pr-$(System.PullRequest.PullRequestNumber)"
              npm install -g @capgo/cli
              npx @capgo/cli channel create $CHANNEL_NAME --apikey $(CAPGO_TOKEN) || true
              npx @capgo/cli bundle upload --apikey $(CAPGO_TOKEN) --channel $CHANNEL_NAME --path $(Pipeline.Workspace)/app-build
            displayName: 'Deploy to PR Channel'

  # Deploy to production
  - stage: DeployProd
    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
    jobs:
      - deployment: DeployProduction
        environment: production
        pool:
          vmImage: 'ubuntu-latest'
        strategy:
          runOnce:
            deploy:
              steps:
                - task: NodeTool@0
                  inputs:
                    versionSpec: '22.x'

                - task: DownloadBuildArtifacts@0
                  inputs:
                    artifactName: 'app-build'
                    downloadPath: '$(Pipeline.Workspace)'

                - script: |
                    npm install -g @capgo/cli
                    npx @capgo/cli bundle upload --apikey $(CAPGO_TOKEN) --channel production --path $(Pipeline.Workspace)/app-build
                  displayName: 'Deploy to Production'

Mehrumgebungs-Bereitstellung

Für komplexe Szenarien mit mehreren Umgebungen:

# Extended pipeline with multiple environments
parameters:
  - name: deployEnvironment
    displayName: 'Deploy Environment'
    type: string
    default: 'staging'
    values:
      - staging
      - production

variables:
  - group: Capgo-Variables
  - name: channelName
    ${{ if eq(parameters.deployEnvironment, 'production') }}:
      value: 'production'
    ${{ else }}:
      value: 'staging'

stages:
  # Build stage
  - stage: Build
    jobs:
      - job: BuildApp
        pool:
          vmImage: 'ubuntu-latest'
        steps:
          - task: NodeTool@0
            inputs:
              versionSpec: '22.x'

          - script: |
              npm ci
              npm run test
              npm run build
            displayName: 'Install, test and build'

          - task: PublishBuildArtifacts@1
            inputs:
              pathToPublish: 'dist'
              artifactName: 'app-build'

  - stage: DeployStaging
    displayName: 'Deploy to Staging'
    dependsOn: Build
    condition: and(succeeded(), eq('${{ parameters.deployEnvironment }}', 'staging'))
    jobs:
      - deployment: DeployStaging
        displayName: 'Deploy to Staging Channel'
        pool:
          vmImage: 'ubuntu-latest'
        environment: 'staging'
        strategy:
          runOnce:
            deploy:
              steps:
                - template: deploy-steps.yml
                  parameters:
                    channel: 'staging'

  - stage: DeployProduction
    displayName: 'Deploy to Production'
    dependsOn: Build
    condition: and(succeeded(), eq('${{ parameters.deployEnvironment }}', 'production'))
    jobs:
      - deployment: DeployProduction
        displayName: 'Deploy to Production Channel'
        pool:
          vmImage: 'ubuntu-latest'
        environment: 'production'
        strategy:
          runOnce:
            deploy:
              steps:
                - template: deploy-steps.yml
                  parameters:
                    channel: 'production'

Bereitstellungs-Template (deploy-steps.yml)

Erstellen Sie ein wiederverwendbares Template-File deploy-steps.yml:

deploy-steps.yml

parameters:
  - name: channel
    type: string

steps:
  - task: NodeTool@0
    displayName: 'Install Node.js'
    inputs:
      versionSpec: '22.x'

  - task: DownloadBuildArtifacts@0
    displayName: 'Download build artifacts'
    inputs:
      artifactName: 'app-build'
      downloadPath: '$(System.ArtifactsDirectory)'

  - script: |
      npm install -g @capgo/cli
    displayName: 'Install Capgo CLI'

  - script: |
      npx @capgo/cli bundle upload \
        --apikey $(CAPGO_TOKEN) \
        --channel ${{ parameters.channel }} \
        --path $(System.ArtifactsDirectory)/app-build
    displayName: 'Upload to Capgo (${{ parameters.channel }})'

Branch-basierte Bereitstellungsstrategie

Konfigurieren Sie verschiedene Bereitstellungsstrategien basierend auf Git-Branches:

trigger:
  branches:
    include:
      - main
      - develop
      - feature/*

variables:
  - group: Capgo-Variables
  - name: targetChannel
    ${{ if eq(variables['Build.SourceBranch'], 'refs/heads/main') }}:
      value: 'production'
    ${{ elseif eq(variables['Build.SourceBranch'], 'refs/heads/develop') }}:
      value: 'staging'
    ${{ else }}:
      value: 'development'

stages:
  - stage: Build
    jobs:
      - job: BuildApp
        pool:
          vmImage: 'ubuntu-latest'
        steps:
          - task: NodeTool@0
            inputs:
              versionSpec: '22.x'

          - script: |
              npm ci
              npm run test
              npm run build
            displayName: 'Install, test and build'

          - task: PublishBuildArtifacts@1
            inputs:
              pathToPublish: 'dist'
              artifactName: 'app-build'

  - stage: Deploy
    displayName: 'Deploy to $(targetChannel)'
    dependsOn: Build
    condition: succeeded()
    jobs:
      - deployment: DeployJob
        displayName: 'Deploy to $(targetChannel) Channel'
        pool:
          vmImage: 'ubuntu-latest'
        environment: '$(targetChannel)'
        strategy:
          runOnce:
            deploy:
              steps:
                - template: deploy-steps.yml
                  parameters:
                    channel: '$(targetChannel)'

Security-Best Practices

Sichere Variable-Verwaltung

1. Verwendung von Variable-Gruppen: Speichern Sie sensitive Daten in Azure DevOps-Variable-Gruppen
2. Als Geheimnis markieren: Immer markiere API-Tokens und -Schlüssel als geheime Variablen
3. Zugriffsberechtigung: Beschränke den Zugriff auf Variabengruppen auf bestimmte Pipelines und Benutzer
4. Schlüsselrotation: Rotiere deine Capgo- API-Schlüssel regelmäßig

Überwachung und Benachrichtigungen

Teams-Integration

Füge Microsoft Teams-Benachrichtigungen deiner Pipeline hinzu:

- task: ms-teams-deploy-card@1.4.1
  displayName: 'Notify Teams on Success'
  condition: succeeded()
  inputs:
    webhookUri: '$(TEAMS_WEBHOOK_URL)'
    title: 'Capgo Deployment Successful'
    text: 'App deployed to $(targetChannel) channel'
    themeColor: '00FF00'

- task: ms-teams-deploy-card@1.4.1
  displayName: 'Notify Teams on Failure'
  condition: failed()
  inputs:
    webhookUri: '$(TEAMS_WEBHOOK_URL)'
    title: 'Capgo Deployment Failed'
    text: 'Deployment to $(targetChannel) failed'
    themeColor: 'FF0000'

E-Mail-Benachrichtigungen

Konfigurieren Sie E-Mail-Benachrichtigungen für den Status der Bereitstellung:

- task: EmailReport@1
  displayName: 'Send Email Report'
  condition: always()
  inputs:
    sendMailConditionConfig: 'Always'
    subject: 'Capgo Deployment Report - $(Build.BuildNumber)'
    to: 'team@yourcompany.com'
    body: |
      Deployment Status: $(Agent.JobStatus)
      Channel: $(targetChannel)
      Build: $(Build.BuildNumber)
      Commit: $(Build.SourceVersion)

Schwierigkeiten bei der Fehlersuche

Häufige Probleme

Pipeline fehlschlägt mit „Capgo CLI nicht gefunden“:

# Ensure global installation
- script: |
    npm install -g @capgo/cli
    which capgo || echo "Capgo CLI not found in PATH"
  displayName: 'Install and verify Capgo CLI'

Authentifizierungsfehler:

# Verify token is correctly set
- script: |
    echo "Token length: ${#CAPGO_TOKEN}"
    if [ -z "$CAPGO_TOKEN" ]; then
      echo "CAPGO_TOKEN is not set"
      exit 1
    fi
  displayName: 'Verify Capgo token'
  env:
    CAPGO_TOKEN: $(CAPGO_TOKEN)

Build-Artikel nicht gefunden:

# List available artifacts for debugging
- script: |
    ls -la $(System.ArtifactsDirectory)
    find $(System.ArtifactsDirectory) -name "*.js" -o -name "*.html"
  displayName: 'Debug artifacts'

Debug-Pipeline

Fügen Sie Schritte zur Fehlersuche hinzu:

- script: |
    echo "Build.SourceBranch: $(Build.SourceBranch)"
    echo "Build.BuildNumber: $(Build.BuildNumber)"
    echo "Target Channel: $(targetChannel)"
  displayName: 'Debug Pipeline Variables'

- script: |
    npx @capgo/cli app debug --apikey $(CAPGO_TOKEN)
  displayName: 'Debug Capgo App Status'

Nächste Schritte

• Erfahren Sie mehr über Kanäle um verschiedene Bereitstellungsumgebungen zu verwalten
• Entdecken Sie Benutzerdefinierte Speicherung für fortgeschrittene Bereitstellungs-Szenarien
• Einrichten Verschlüsselung für sichere Bereitstellungen
• Konfigurieren Aktualisierungsverhalten um die Anwendung von Updates anzupassen

Mit der Integration in Azure DevOps können Sie Ihre Capgo-Bereitstellungen automatisieren und sicherstellen, dass Ihre mobilen App-Benutzer konsistente und zuverlässige Updates erhalten.

Weitermachen von Azure DevOps Integration

Wenn Sie Azure DevOps Integration verwenden Azure DevOps Integration verwenden um die CI/CD-Automatisierung zu planen, verbinden Sie es mit Capgo CI/CD zur Produktworkflow in Capgo CI/CD, Capgo Native Builds zur Produktworkflow in Capgo Native Builds, Capgo Integrations zur Produktworkflow in Capgo Integrations, CI/CD-Integration __CAPGO_KEEP_0__ Aktionen-Integration zur Implementierungsdetail in GitHub Aktionen-Integration. for the implementation detail in GitHub Actions Integration.