# Azure Pipelines

> Integra Applivery con Azure Pipelines para automatizar la distribución de Apps móviles usando Fastlane o la API de Applivery.

Source: https://docs.applivery.com/es/app-distribution/ci-cd/azure-pipelines/  •  Last updated: 2026-06-08

**Answers:** ¿Cómo integro Applivery con Azure Pipelines? · ¿Cómo guardo el token de Applivery de forma segura en Azure Pipelines? · ¿Qué variables predefinidas de Azure Pipelines puedo usar con Applivery? · ¿Cómo subo Builds a Applivery desde Azure Pipelines sin Fastlane?

---

**TL;DR:** Integra Applivery con Azure Pipelines para automatizar la distribución de apps móviles usando Fastlane o la CLI de Applivery.

![azure-pipelines-long](https://www.applivery.com/wp-content/uploads/2021/12/azure-pipelines-long-1024x307.png "azure-pipelines-long | Applivery")

[Azure DevOps](https://azure.microsoft.com/en-us/services/devops/) es una plataforma de Microsoft que cubre el ciclo de vida completo de las aplicaciones: control de versiones, gestión de proyectos, compilaciones automatizadas, pruebas y gestión de releases. [Azure Pipelines](https://azure.microsoft.com/en-us/services/devops/pipelines/), parte del conjunto de Azure DevOps, proporciona pipelines CI/CD alojados en la nube para Linux, macOS y Windows, con soporte para aplicaciones web, de escritorio y móviles.

La integración de Applivery con Azure Pipelines te permite subir automáticamente nuevas Builds a Applivery al final de cada ejecución del pipeline, haciéndolas inmediatamente disponibles para los equipos de QA, las partes interesadas o los usuarios internos.

Hay dos enfoques para integrar Azure Pipelines con Applivery:

- **Mediante Fastlane** (recomendado para proyectos iOS y Android que ya usan Fastlane) — delega la subida al plugin de Applivery para Fastlane.
- **Mediante la API de subida de Applivery directamente** (recomendado para cualquier proyecto o cuando no se usa Fastlane) — llama a la API con un paso `curl` en tu pipeline YAML.

---

## Requisitos previos

Antes de configurar cualquiera de los dos enfoques, asegúrate de tener:

- Una cuenta de Azure DevOps con una configuración de Azure Pipelines en marcha.
- Un App API Token de Applivery. Encuéntralo en **Ajustes de la App → Token API** en el panel de Applivery, o consulta [Apps API Authentication](https://docs.applivery.com/en/app-distribution/api/app-api-token/).
- Un pipeline que genere un artefacto de Build (`.ipa`, `.apk`, `.aab` u otro formato compatible).

---

**Guardar el App Token como variable secreta**

Nunca escribas tu token de Applivery directamente en `azure-pipelines.yml`. Guárdalo como variable secreta del pipeline en Azure DevOps para que quede enmascarado en los logs y no se incluya en el repositorio.

1. Abre tu proyecto de Azure DevOps y ve a **Pipelines → tu pipeline → Edit**.
2. Haz clic en **Variables** (arriba a la derecha).
3. Añade una nueva variable llamada `APPLIVERY_TOKEN`.
4. Pega tu App API Token de Applivery como valor.
5. Activa el interruptor **Keep this value secret** para enmascararlo en los logs.
6. Guarda.
![azure-devops-pipelines-vars](https://www.applivery.com/wp-content/uploads/2021/12/azure-devops-pipelines-vars-1024x559.png "azure-devops-pipelines-vars | Applivery")

Una vez definida, referénciala en tu pipeline YAML como `$(APPLIVERY_TOKEN)`.

**Opción A — Integración mediante Fastlane**

Este es el enfoque recomendado si tu proyecto ya usa Fastlane para compilar y firmar. El plugin de Applivery para Fastlane gestiona la subida y todos los metadatos automáticamente.

Para la documentación completa del plugin de Fastlane, consulta [Integración con Fastlane](https://docs.applivery.com/en/app-distribution/ci-cd/fastlane/).

### Pipeline YAML

En tu `azure-pipelines.yml`, añade un paso de script que invoque tu lane de Fastlane y pase el token como parámetro:

```yaml
- script: fastlane dev_deploy applivery_token:$(APPLIVERY_TOKEN)
  displayName: 'Desplegar en Applivery mediante Fastlane'
  env:
    APPLIVERY_TOKEN: $(APPLIVERY_TOKEN)
```

### Fastfile

Define un lane en tu `Fastfile` que compile y suba a Applivery. El ejemplo siguiente usa `last_git_commit[:message]` como changelog y `number_of_commits` para incrementar el número de Build automáticamente:

```ruby
desc "Compilar y desplegar en Applivery"
lane :dev_deploy do |options|
  increment_build_number(
    build_number: number_of_commits
  )

  build_app(
    scheme: "MyApp-Dev",
    export_method: "enterprise"
  )

  applivery(
    app_token: options[:applivery_token],
    notify_collaborators: true,
    changelog: last_git_commit[:message]
  )
end
```

:::tip
Puedes ampliar la acción `applivery` con opciones adicionales como `tags`, `notify_message` y `notify_language`. Consulta la documentación de [integración con Fastlane](https://docs.applivery.com/en/app-distribution/ci-cd/fastlane/) para ver todos los parámetros disponibles.
:::

**Opción B — Integración mediante la API de subida (sin Fastlane)**

Si no usas Fastlane, o prefieres una configuración más sencilla sin dependencias adicionales, llama directamente a la API de subida de Applivery desde tu pipeline usando `curl`. Funciona para cualquier plataforma y agente de pipeline.

### Pipeline YAML — Ejemplo iOS

```yaml
trigger:
  - main

pool:
  vmImage: 'macos-latest'

stages:
  - stage: Build
    jobs:
      - job: BuildAndUpload
        steps:
          - checkout: self

          - task: Xcode@5
            displayName: 'Compilar app iOS'
            inputs:
              actions: 'build'
              scheme: 'MyApp'
              sdk: 'iphoneos'
              configuration: 'Release'
              xcWorkspacePath: 'MyApp.xcworkspace'
              packageApp: true
              signingOption: 'default'

          - script: |
              curl 'https://upload.applivery.io/v1/integrations/builds' \
                --retry 5 \
                --fail \
                -H "Authorization: Bearer $(APPLIVERY_TOKEN)" \
                -F "build=@$(Build.ArtifactStagingDirectory)/MyApp.ipa" \
                -F "versionName=$(Build.BuildNumber)" \
                -F "changelog=$(Build.SourceVersionMessage)" \
                -F "tags=azure-pipelines, ios" \
                -F "notifyCollaborators=true" \
                -F "notifyMessage=Nueva Build disponible desde Azure Pipelines" \
                -F "notifyLanguage=es" \
                -F "deployer.name=Azure Pipelines" \
                -F "deployer.info.commit=$(Build.SourceVersion)" \
                -F "deployer.info.branch=$(Build.SourceBranchName)" \
                -F "deployer.info.commitMessage=$(Build.SourceVersionMessage)" \
                -F "deployer.info.buildUrl=$(System.TeamFoundationCollectionUri)$(System.TeamProject)/_build/results?buildId=$(Build.BuildId)" \
                -F "deployer.info.buildNumber=$(Build.BuildNumber)" \
                -F "deployer.info.repositoryUrl=$(Build.Repository.Uri)"
            displayName: 'Subir a Applivery'
            env:
              APPLIVERY_TOKEN: $(APPLIVERY_TOKEN)
```

### Pipeline YAML — Ejemplo Android

```yaml
trigger:
  - main

pool:
  vmImage: 'ubuntu-latest'

stages:
  - stage: Build
    jobs:
      - job: BuildAndUpload
        steps:
          - checkout: self

          - task: Gradle@3
            displayName: 'Compilar APK de Android'
            inputs:
              workingDirectory: ''
              gradleWrapperFile: 'gradlew'
              gradleOptions: '-Xmx3072m'
              tasks: 'assembleRelease'

          - script: |
              curl 'https://upload.applivery.io/v1/integrations/builds' \
                --retry 5 \
                --fail \
                -H "Authorization: Bearer $(APPLIVERY_TOKEN)" \
                -F "build=@$(Build.ArtifactStagingDirectory)/app-release.apk" \
                -F "versionName=$(Build.BuildNumber)" \
                -F "changelog=$(Build.SourceVersionMessage)" \
                -F "tags=azure-pipelines, android" \
                -F "notifyCollaborators=true" \
                -F "notifyMessage=Nueva Build de Android desde Azure Pipelines" \
                -F "notifyLanguage=es" \
                -F "deployer.name=Azure Pipelines" \
                -F "deployer.info.commit=$(Build.SourceVersion)" \
                -F "deployer.info.branch=$(Build.SourceBranchName)" \
                -F "deployer.info.commitMessage=$(Build.SourceVersionMessage)" \
                -F "deployer.info.buildUrl=$(System.TeamFoundationCollectionUri)$(System.TeamProject)/_build/results?buildId=$(Build.BuildId)" \
                -F "deployer.info.buildNumber=$(Build.BuildNumber)" \
                -F "deployer.info.repositoryUrl=$(Build.Repository.Uri)"
            displayName: 'Subir a Applivery'
            env:
              APPLIVERY_TOKEN: $(APPLIVERY_TOKEN)
```

---

## Variables predefinidas de Azure Pipelines

Los ejemplos de pipeline anteriores usan variables predefinidas de Azure Pipelines, disponibles automáticamente en cualquier pipeline sin configuración adicional:

| Variable | Descripción |
|---|---|
| `Build.BuildNumber` | El número de Build. Útil como `versionName` en Applivery. |
| `Build.BuildId` | ID numérico único para la ejecución de la Build. Se usa para construir la URL de la Build. |
| `Build.SourceVersion` | SHA completo del commit de Git que desencadenó la Build. |
| `Build.SourceBranchName` | Nombre de la rama que desencadenó la Build. Por ejemplo: `main`, `develop`. |
| `Build.SourceVersionMessage` | Mensaje del commit que desencadenó la Build. Útil como `changelog`. |
| `Build.Repository.Uri` | URL del repositorio de origen. |
| `Build.ArtifactStagingDirectory` | Directorio local donde se guardan los artefactos de compilación. |
| `System.TeamFoundationCollectionUri` | URL base de tu organización de Azure DevOps. |
| `System.TeamProject` | Nombre del proyecto de Azure DevOps. |

Para la lista completa de variables predefinidas, consulta la [documentación de variables predefinidas de Azure Pipelines](https://docs.microsoft.com/en-us/azure/devops/pipelines/build/variables).

---

## Referencia de parámetros de subida

Los campos del formulario `curl` se corresponden directamente con los parámetros de la API de subida de Applivery. Los más utilizados:

| Parámetro | Descripción |
|---|---|
| `build` | El archivo binario a subir. |
| `versionName` | Etiqueta legible para la Build. Usar `$(Build.BuildNumber)` la vincula con la ejecución de Azure. |
| `changelog` | Notas de la versión mostradas en el panel y en los emails de notificación. |
| `tags` | Etiquetas separadas por comas para filtrar Builds. |
| `notifyCollaborators` | Establece como `true` para enviar un email a los Colaboradores de la App al subir. |
| `notifyMessage` | Mensaje personalizado incluido en el email de notificación. |
| `deployer.name` | Nombre de la plataforma CI mostrado en el panel de Applivery. |
| `deployer.info.commit` | SHA del commit de Git. |
| `deployer.info.branch` | Nombre de la rama de Git. |
| `deployer.info.buildNumber` | Número de Build del pipeline. |
| `deployer.info.buildUrl` | URL directa a la ejecución del pipeline de Azure. |

Para la referencia completa de parámetros, consulta [POST – Subir una Build](https://docs.applivery.com/en/app-distribution/api/builds/upload-build/).
