Integración con Azure DevOps

Integre las Actualizaciones en Vivo de Capgo con Azure DevOps Pipelines para desplegar automáticamente las actualizaciones de su aplicación cada vez que realice cambios en el código. Esta guía cubre la configuración de flujos de trabajo automatizados de construcción, pruebas y despliegue.

Requisitos previos

Antes de configurar la integración con Azure DevOps, asegúrese de tener:

• Una organización y proyecto de Azure DevOps
• Una cuenta de Capgo con una aplicación configurada
• El código fuente de su aplicación en un repositorio Git de Azure Repos
• Node.js y npm/yarn configurados en su proyecto

Configuración de Azure DevOps Pipeline

Paso 1: Crear Variables de Pipeline

Primero, Configurar las Variables necesarias en su proyecto de Azure DevOps:

1. Navegue a su proyecto de Azure DevOps
2. Vaya a Pipelines → Library → Variable groups
3. Cree un nuevo grupo de Variables llamado Capgo-Variables
4. Agregue las siguientes Variables:

Nombre de Variable	Valor	Segura
CAPGO_TOKEN	Su token de API de Capgo	✅ Sí

Consejo

Obtenga su token de API de Capgo desde console.capgo.app/apikeys. El ID de su aplicación ya está configurado en su archivo capacitor.config.ts.

Simple

Configuración básica que despliega a producción en cada push a la rama principal:

# Simple Azure DevOps Pipeline para Actualizaciones en Vivo de Capgo
trigger:
  branches:
    include:
      - main

variables:
  - group: Capgo-Variables

jobs:
  - job: BuildAndDeploy
    displayName: 'Construir y Desplegar a Capgo'
    pool:
      vmImage: 'ubuntu-latest'

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

      - script: |
          npm ci
          npm run test
          npm run build
        displayName: 'Instalar, probar y construir'

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

Avanzado

Despliegues de ramas de características

Despliegue ramas de características a canales de prueba para revisión y Pruebas:

# Despliegue de rama de características
trigger:
  branches:
    include:
      - feature/*

variables:
  - group: Capgo-Variables

jobs:
  - job: DeployFeature
    displayName: 'Desplegar rama de características'
    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: 'Instalar, probar y construir'

      - 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: 'Desplegar a canal de características'

Consejo

Pruebas con Canales: Después de desplegar a un canal de características, puede probar la actualización en su aplicación configurándola para usar ese canal específico. Aprenda más sobre configurar canales en su aplicación.

Uso de cifrado

Si está usando la función de cifrado de Capgo, deberá almacenar su clave privada de forma segura en su entorno de CI/CD.

Después de configurar las claves de cifrado localmente, agregue su clave privada a las Variables de Azure DevOps:

# Mostrar el contenido de su clave privada (copiar esta salida)
cat .capgo_key_v2

Agregue este contenido como CAPGO_PRIVATE_KEY en su grupo de Variables de Azure DevOps (márquelo como secreto), luego úselo en pipelines:

# Desplegar con cifrado
- script: |
    npm install -g @capgo/cli
    npx @capgo/cli bundle upload --apikey $(CAPGO_TOKEN) --key-data-v2 "$(CAPGO_PRIVATE_KEY)" --channel production
  displayName: 'Desplegar a Capgo con cifrado'

Precaución

Mejores prácticas de seguridad:

• Nunca confirme el archivo .capgo_key_v2 en el control de versiones
• Almacene la clave privada solo en la gestión segura de secretos de CI/CD
• Usar claves diferentes para diferentes entornos

Configuración multicanal

Para obtener información completa sobre la configuración y gestión de múltiples canales de despliegue, consulte la documentación de Canales.

Configuración completa con múltiples entornos y despliegues de Solicitud de extracción:

# Azure DevOps Pipeline avanzado con múltiples canales
trigger:
  branches:
    include:
      - main
      - develop

pr:
  branches:
    include:
      - main
      - develop

variables:
  - group: Capgo-Variables

stages:
  # Etapa de construcción
  - 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: 'Instalar, probar y construir'

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

  # Desplegar a desarrollo
  - 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: 'Desplegar a desarrollo'

  # Desplegar PR a canal de prueba
  - 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: 'Desplegar a canal de PR'

  # Desplegar a producción
  - 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: 'Desplegar a producción'

Despliegue multi-entorno

Para escenarios complejos con múltiples entornos:

# Pipeline extendido con múltiples entornos
parameters:
  - name: deployEnvironment
    displayName: 'Entorno de despliegue'
    type: string
    default: 'staging'
    values:
      - staging
      - production

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

stages:
  # Etapa de construcción
  - 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: 'Instalar, probar y construir'

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

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

  - stage: DeployProduction
    displayName: 'Desplegar a producción'
    dependsOn: Build
    condition: and(succeeded(), eq('${{ parameters.deployEnvironment }}', 'production'))
    jobs:
      - deployment: DeployProduction
        displayName: 'Desplegar a canal de producción'
        pool:
          vmImage: 'ubuntu-latest'
        environment: 'production'
        strategy:
          runOnce:
            deploy:
              steps:
                - template: deploy-steps.yml
                  parameters:
                    channel: 'production'

Plantilla de despliegue (Desplegar-Pasos.yml)

Cree un archivo de plantilla reutilizable deploy-steps.yml:

deploy-steps.yml

parameters:
  - name: channel
    type: string

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

  - task: DownloadBuildArtifacts@0
    displayName: 'Descargar artefactos de construcción'
    inputs:
      artifactName: 'app-build'
      downloadPath: '$(System.ArtifactsDirectory)'

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

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

Estrategia de despliegue basada en ramas

Configurar diferentes estrategias de despliegue según las ramas de Git:

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: 'Instalar, probar y construir'

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

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

Mejores prácticas de seguridad

Gestión segura de Variables

1. Usar grupos de Variables: Almacene datos sensibles en grupos de Variables de Azure DevOps
2. Marque como secreto: Siempre marque tokens de API y claves como Variables secretas
3. Acceso de ámbito: Limite el acceso del grupo de Variables a pipelines y usuarios específicos
4. Rote claves: Rote regularmente sus tokens de API de Capgo

Monitoreo y notificaciones

Integración con Teams

Agregue notificaciones de Microsoft Teams a su pipeline:

- task: ms-teams-deploy-card@1.4.1
  displayName: 'Notificar Teams en caso de éxito'
  condition: succeeded()
  inputs:
    webhookUri: '$(TEAMS_WEBHOOK_URL)'
    title: 'Despliegue de Capgo exitoso'
    text: 'Aplicación desplegada al canal $(targetChannel)'
    themeColor: '00FF00'

- task: ms-teams-deploy-card@1.4.1
  displayName: 'Notificar Teams en caso de fallo'
  condition: failed()
  inputs:
    webhookUri: '$(TEAMS_WEBHOOK_URL)'
    title: 'Despliegue de Capgo fallido'
    text: 'Fallo en el despliegue a $(targetChannel)'
    themeColor: 'FF0000'

Notificaciones por correo electrónico

Configurar notificaciones por correo electrónico para el estado del despliegue:

- task: EmailReport@1
  displayName: 'Enviar informe por correo'
  condition: always()
  inputs:
    sendMailConditionConfig: 'Always'
    subject: 'Informe de despliegue de Capgo - $(Build.BuildNumber)'
    to: 'team@yourcompany.com'
    body: |
      Estado de despliegue: $(Agent.JobStatus)
      Canal: $(targetChannel)
      Build: $(Build.BuildNumber)
      Commit: $(Build.SourceVersion)

Solución de problemas

Problemas comunes

El pipeline falla con “Capgo CLI no encontrado”:

# Asegúrese de la instalación global
- script: |
    npm install -g @capgo/cli
    which capgo || echo "Capgo CLI no encontrado en PATH"
  displayName: 'Instalar y verificar Capgo CLI'

Errores de autenticación:

# Verificar que el token esté configurado correctamente
- script: |
    echo "Longitud del token: ${#CAPGO_TOKEN}"
    if [ -z "$CAPGO_TOKEN" ]; then
      echo "CAPGO_TOKEN no está configurado"
      exit 1
    fi
  displayName: 'Verificar token de Capgo'
  env:
    CAPGO_TOKEN: $(CAPGO_TOKEN)

Artefactos de construcción no encontrados:

# Listar artefactos disponibles para depuración
- script: |
    ls -la $(System.ArtifactsDirectory)
    find $(System.ArtifactsDirectory) -name "*.js" -o -name "*.html"
  displayName: 'Depurar artefactos'

Depurar pipeline

Agregue pasos de depuración para solucionar problemas:

- script: |
    echo "Build.SourceBranch: $(Build.SourceBranch)"
    echo "Build.BuildNumber: $(Build.BuildNumber)"
    echo "Canal objetivo: $(targetChannel)"
  displayName: 'Depurar variables de pipeline'

- script: |
    npx @capgo/cli app debug --apikey $(CAPGO_TOKEN)
  displayName: 'Depurar estado de aplicación de Capgo'

Próximos pasos

• Aprenda sobre Canales para gestionar diferentes entornos de despliegue
• Explore Almacenamiento personalizado para escenarios de despliegue avanzados
• Configurar Cifrado para despliegues seguros
• Configurar Comportamiento de actualización para personalizar cómo se aplican las actualizaciones

Con la integración de Azure DevOps, puede automatizar sus despliegues de Capgo y garantizar actualizaciones consistentes y confiables para los usuarios de su aplicación móvil.