# Jenkins

> Integra Jenkins con Applivery para automatizar la subida de Builds y agilizar tu flujo de trabajo CI/CD de distribución de apps móviles.

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

**Answers:** ¿Cómo integro Jenkins con Applivery? · ¿Cómo guardo el token de Applivery de forma segura en Jenkins? · ¿Qué variables de entorno de Jenkins puedo usar con Applivery? · ¿Cómo notifico a los Colaboradores de nuevas Builds subidas desde Jenkins?

---

**TL;DR:** Integra Jenkins con Applivery para subir nuevas builds automáticamente tras cada ejecución del pipeline, optimizando tu flujo de CI/CD.

![jenkins](https://docs.applivery.com/int/_r2/media/09ac0a4e-3ad8-478f-9f15-3474973eec71/8507c9b2-5456-4b69-abe0-f284975ab253.jpg "jenkins | Applivery")

# Integración con Jenkins

[Jenkins](https://www.jenkins.io/) es un servidor de automatización de código abierto ampliamente utilizado para la integración y entrega continuas. Orquesta las etapas de compilación, prueba, empaquetado y despliegue de un pipeline de entrega de software.

La integración de Applivery con Jenkins te permite subir automáticamente una nueva Build a Applivery al final de cada ejecución del pipeline, haciendo que los binarios recién compilados estén inmediatamente disponibles para los equipos de QA, las partes interesadas o los usuarios internos sin ningún paso manual.

:::info
Applivery no tiene un plugin dedicado para Jenkins. La integración usa el [plugin HTTP Request](https://www.jenkins.io/doc/pipeline/steps/http_request/) estándar de Jenkins para llamar directamente a la API de subida de Applivery. Este enfoque es más sencillo, más fácil de mantener y funciona con cualquier versión de Jenkins.
:::

---

## Requisitos previos

Antes de configurar la integración, asegúrate de tener:

- Una instancia de Jenkins con el [plugin HTTP Request](https://plugins.jenkins.io/http_request/) instalado.
- Un App API Token de Applivery. Encuéntralo en **Ajustes de la App → Token API** en el panel de Applivery, o consulta [Integration API Token](https://docs.applivery.com/en/app-distribution/api/app-api-token/) para instrucciones sobre cómo crearlo.
- Un pipeline de Jenkins que genere un artefacto de Build (`.ipa`, `.apk`, `.aab` u otro formato compatible).

---

**Guardar el App Token como credencial de Jenkins**

Nunca escribas tu token de Applivery directamente en el `Jenkinsfile`. Guárdalo como credencial secreta en Jenkins y referencíala mediante una variable de entorno.

1. Ve a **Jenkins → Manage Jenkins → Credentials**.
2. Añade una nueva credencial de tipo **Secret text**.
3. Establece el ID como `APPLIVERY_TOKEN` (o cualquier nombre que prefieras; úsalo de forma consistente).
4. Pega tu App API Token de Applivery como valor secreto.

En tu `Jenkinsfile`, expón la credencial como variable de entorno:

```groovy
environment {
    APPLIVERY_TOKEN = credentials('APPLIVERY_TOKEN')
}
```

**Añadir la etapa de subida a tu pipeline**

Añade una etapa `Applivery Upload` después de tu paso de compilación. La etapa usa el paso `httpRequest` del plugin HTTP Request para llamar a la API de subida de Applivery con `multipart/form-data`.

```groovy
stage('Applivery Upload') {
    def response = httpRequest(
        url: 'https://upload.applivery.io/v1/integrations/builds',
        httpMode: 'POST',
        consoleLogResponseBody: true,
        wrapAsMultipart: true,
        customHeaders: [
            [
                maskValue: true,
                name: 'Authorization',
                value: "Bearer ${env.APPLIVERY_TOKEN}"
            ]
        ],
        formData: [
            // Archivo de Build
            [
                name: 'build',
                fileName: 'app.ipa',
                uploadFile: './app.ipa',
                contentType: 'application/octet-stream'
            ],
            // Metadatos de la Build
            [name: 'versionName',        value: "${env.BUILD_TAG}"],
            [name: 'changelog',          value: "${env.GIT_COMMIT_MSG}"],
            [name: 'tags',               value: 'jenkins, ci'],
            // Notificaciones
            [name: 'notifyCollaborators', value: 'true'],
            [name: 'notifyEmployees',     value: 'false'],
            [name: 'notifyMessage',       value: 'Nueva Build disponible desde Jenkins'],
            [name: 'notifyLanguage',      value: 'es'],
            // Filtro de grupo de notificación (opcional)
            // Para notificar a usuarios en group1 Y group2, O group3:
            [name: 'filter[0][0]',        value: 'group1'],
            [name: 'filter[0][1]',        value: 'group2'],
            [name: 'filter[1][0]',        value: 'group3'],
            // Metadatos CI/CD — aparecen en el panel de Applivery
            [name: 'deployer.name',                   value: 'Jenkins'],
            [name: 'deployer.info.commitMessage',      value: "${env.GIT_COMMIT_MSG}"],
            [name: 'deployer.info.commit',             value: "${env.GIT_COMMIT}"],
            [name: 'deployer.info.branch',             value: "${env.GIT_BRANCH}"],
            [name: 'deployer.info.buildUrl',           value: "${env.BUILD_URL}"],
            [name: 'deployer.info.buildNumber',        value: "${env.BUILD_NUMBER}"],
            [name: 'deployer.info.repositoryUrl',      value: "${env.GIT_URL}"]
        ]
    )

    echo "Respuesta de subida a Applivery: ${response}"
}
```

---

## Ejemplo completo de Jenkinsfile

Aquí tienes un ejemplo completo de pipeline para una Build iOS:

```groovy
pipeline {
    agent any

    environment {
        APPLIVERY_TOKEN = credentials('APPLIVERY_TOKEN')
    }

    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }

        stage('Build') {
            steps {
                // Reemplaza con tu comando de compilación real
                sh 'xcodebuild -scheme MyApp -configuration Release archive -archivePath build/MyApp.xcarchive'
                sh 'xcodebuild -exportArchive -archivePath build/MyApp.xcarchive -exportPath build/ -exportOptionsPlist ExportOptions.plist'
            }
        }

        stage('Applivery Upload') {
            steps {
                script {
                    def response = httpRequest(
                        url: 'https://upload.applivery.io/v1/integrations/builds',
                        httpMode: 'POST',
                        consoleLogResponseBody: true,
                        wrapAsMultipart: true,
                        customHeaders: [
                            [
                                maskValue: true,
                                name: 'Authorization',
                                value: "Bearer ${env.APPLIVERY_TOKEN}"
                            ]
                        ],
                        formData: [
                            [
                                name: 'build',
                                fileName: 'MyApp.ipa',
                                uploadFile: './build/MyApp.ipa',
                                contentType: 'application/octet-stream'
                            ],
                            [name: 'versionName',                    value: "${env.BUILD_TAG}"],
                            [name: 'changelog',                      value: "Build #${env.BUILD_NUMBER} — ${env.GIT_BRANCH}"],
                            [name: 'notifyCollaborators',             value: 'true'],
                            [name: 'notifyMessage',                   value: 'Nueva Build lista para pruebas'],
                            [name: 'notifyLanguage',                  value: 'es'],
                            [name: 'deployer.name',                   value: 'Jenkins'],
                            [name: 'deployer.info.commit',            value: "${env.GIT_COMMIT}"],
                            [name: 'deployer.info.branch',            value: "${env.GIT_BRANCH}"],
                            [name: 'deployer.info.commitMessage',     value: "${env.GIT_COMMIT_MSG}"],
                            [name: 'deployer.info.buildUrl',          value: "${env.BUILD_URL}"],
                            [name: 'deployer.info.buildNumber',       value: "${env.BUILD_NUMBER}"],
                            [name: 'deployer.info.repositoryUrl',     value: "${env.GIT_URL}"]
                        ]
                    )
                    echo "Respuesta de subida a Applivery: ${response}"
                }
            }
        }
    }

    post {
        failure {
            echo 'La compilación o la subida han fallado.'
        }
    }
}
```

---

## Referencia de parámetros clave

El array `formData` se corresponde 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. Usa `uploadFile` para la ruta local y `fileName` para el nombre que Applivery registrará. |
| `versionName` | Etiqueta legible para la Build. Usar `${env.BUILD_TAG}` o `${env.BUILD_NUMBER}` facilita su trazabilidad en Applivery. |
| `changelog` | Notas de la versión mostradas en el panel de Applivery y en los emails de notificación. |
| `tags` | Etiquetas separadas por comas para filtrar Builds. Por ejemplo: `jenkins, staging`. |
| `notifyCollaborators` | Establece como `true` para enviar un email a los Colaboradores de la App cuando se suba la Build. |
| `notifyEmployees` | Establece como `true` para enviar un email a los empleados de la tienda. |
| `notifyMessage` | Mensaje personalizado incluido en el email de notificación. |
| `notifyLanguage` | Idioma del email de notificación. Valores admitidos: `en`, `es`, `fr`, `de`, `it`, `zh`, `pt`, `ru`. |
| `filter[N][M]` | Filtro de notificación por grupos. Cada array interno es una cláusula AND; cada índice externo es un OR. |
| `deployer.name` | Nombre de la plataforma CI mostrado en el panel de Applivery. Por ejemplo: `Jenkins`. |
| `deployer.info.commit` | SHA del commit de Git. |
| `deployer.info.branch` | Nombre de la rama de Git. |
| `deployer.info.buildNumber` | Número de Build de Jenkins. |
| `deployer.info.buildUrl` | URL directa a la ejecución de Build en Jenkins. |
| `deployer.info.repositoryUrl` | URL del repositorio de origen. |

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

---

## Variables de entorno de Jenkins

Los ejemplos de pipeline anteriores usan variables de entorno integradas de Jenkins, disponibles en cualquier pipeline sin configuración adicional:

| Variable | Descripción |
|---|---|
| `BUILD_NUMBER` | El número de Build actual. |
| `BUILD_TAG` | Cadena con el formato `jenkins-<job>-<número>`. Útil como nombre de versión. |
| `BUILD_URL` | URL completa a la Build actual en la interfaz de Jenkins. |
| `GIT_COMMIT` | SHA del commit de Git actual (requiere el plugin de Git). |
| `GIT_BRANCH` | Nombre de la rama de Git actual (requiere el plugin de Git). |
| `GIT_URL` | URL del repositorio de Git (requiere el plugin de Git). |

:::warning
`GIT_COMMIT_MSG` no es una variable integrada de Jenkins. Para usar el mensaje de commit en la subida, captúralo primero con un paso de shell:
```groovy
env.GIT_COMMIT_MSG = sh(script: 'git log -1 --pretty=%B', returnStdout: true).trim()
```
:::