Incluye la versión en tu compilación

Los usuarios de su software necesitan saber qué versión están utilizando. Coroid asigna a cada lanzamiento una versión y un número de compilación, los envía al pipeline de compilación y posteriormente verifica que el entorno ejecute el lanzamiento desplegado.

Todos los parámetros de esta página se configuran por proyecto en Lanzamientos → Configuración de lanzamiento → Control de versiones.

Origen de la versión#

Seleccione un origen por proyecto:

• Coroid lo asigna automáticamente. (el predeterminado): Coroid sugiere la siguiente versión al preparar un lanzamiento. Incrementa el último número de la versión más alta ya lanzada por el proyecto, de modo que 1.4.0 va seguido de 1.4.1. El primer lanzamiento es 0.1.0. Escriba una versión diferente cuando lo necesite.
• Leerlo desde el repositorio: Coroid lee la versión que indica su código en la confirmación de lanzamiento. Busca en VERSION, package.json, app.json (Expo), pubspec.yaml, el archivo Gradle de Android, Cargo.toml, pyproject.toml y el proyecto de Xcode, o bien solo en el archivo que usted especifique. Si el archivo todavía contiene una versión utilizada en un lanzamiento anterior, Coroid le pedirá que la incremente primero.
• Mi pipeline lo asigna: su CI/CD selecciona la versión, por ejemplo mediante semantic-release o a partir de una etiqueta, y la comunica durante el despliegue.

Cada lanzamiento también recibe un número de compilación. Los números de compilación siempre aumentan y nunca se reutilizan dentro de un proyecto, tal como exigen las tiendas de aplicaciones de iOS CFBundleVersion y Android versionCode.

Qué recibe la compilación#

Cuando Coroid inicia un flujo de trabajo de GitHub Actions o una pipeline de GitLab CI/CD para un lanzamiento, pasa estos valores:

GitHub rechaza las entradas que el flujo de trabajo no declara. Por eso Coroid envía coroid_version, coroid_build_number y coroid_release_name solo a un flujo de trabajo que los incluya. Déclarelos como opcionales:

on:
  workflow_dispatch:
    inputs:
      coroid_release_id: { required: true }
      coroid_attempt_id: { required: true }
      coroid_commit_sha: { required: true }
      coroid_environment: { required: true }
      coroid_version: { required: false }
      coroid_build_number: { required: false }
      coroid_release_name: { required: false }

jobs:
  deploy:
    runs-on: ubuntu-latest
    env:
      APP_VERSION: ${{ inputs.coroid_version || '0.0.0-dev' }}
      APP_BUILD_NUMBER: ${{ inputs.coroid_build_number || '0' }}
      APP_COMMIT: ${{ inputs.coroid_commit_sha || github.sha }}

GitLab pasa los valores como variables, por lo que no se necesita declaración alguna:

deploy:
  script:
    - export APP_VERSION="${COROID_VERSION:-0.0.0-dev}"
    - export APP_BUILD_NUMBER="${COROID_BUILD_NUMBER:-0}"
    - export APP_COMMIT="${COROID_COMMIT_SHA:-$CI_COMMIT_SHA}"

Una pipeline que se ejecute de forma independiente puede utilizar sus propios valores. Comunique la versión que desplegó, como se describe a continuación, para que el lanzamiento la muestre.

Escribir un manifiesto de lanzamiento#

El método más sencillo y compatible con todas las plataformas consiste en crear un archivo pequeño durante la compilación y leerlo donde se muestre la versión:

cat > release.json <<EOF
{
  "version": "$APP_VERSION",
  "buildNumber": "$APP_BUILD_NUMBER",
  "commitSha": "$APP_COMMIT",
  "releaseName": "${COROID_RELEASE_NAME:-}",
  "environment": "${COROID_ENVIRONMENT:-local}"
}
EOF

Para una aplicación web o un servicio, sirva el archivo en /version.json. Esto también proporciona a Coroid una URL para verificar (ver más abajo).

Recetas#

Aplicaciones web (Next.js, Vite)#

Los valores que necesita el navegador deben definirse al compilar el paquete:

NEXT_PUBLIC_APP_VERSION="$APP_VERSION" NEXT_PUBLIC_APP_COMMIT="$APP_COMMIT" npm run build
VITE_APP_VERSION="$APP_VERSION" npm run build

Mostrar process.env.NEXT_PUBLIC_APP_VERSION o import.meta.env.VITE_APP_VERSION en el pie de página o en una pantalla de Acerca de, y copiar release.json en la carpeta pública antes de la compilación.

Servidores y API#

Leer los valores al iniciarse y responder en un punto de enlace de versión:

app.get('/version.json', (_request, response) => {
  response.json({
    version: process.env.APP_VERSION,
    buildNumber: process.env.APP_BUILD_NUMBER,
    commitSha: process.env.APP_COMMIT,
  });
});

Imágenes de Docker#

Pase los valores como argumentos de compilación y etiquete la imagen, para que tanto el contenedor en ejecución como el registro conozcan la versión:

ARG APP_VERSION=0.0.0-dev
ARG APP_COMMIT=unknown
ENV APP_VERSION=$APP_VERSION APP_COMMIT=$APP_COMMIT
LABEL org.opencontainers.image.version=$APP_VERSION \
      org.opencontainers.image.revision=$APP_COMMIT

docker build --build-arg APP_VERSION="$APP_VERSION" --build-arg APP_COMMIT="$APP_COMMIT" .

iOS#

Xcode lee la versión que muestra la App Store desde MARKETING_VERSION y el número de compilación desde CURRENT_PROJECT_VERSION:

xcodebuild -scheme App -configuration Release archive \
  MARKETING_VERSION="$APP_VERSION" \
  CURRENT_PROJECT_VERSION="$APP_BUILD_NUMBER"

Con fastlane, utilice increment_version_number(version_number: ENV["APP_VERSION"]) y increment_build_number(build_number: ENV["APP_BUILD_NUMBER"]).

Android#

Lea los valores en app/build.gradle.kts:

android {
    defaultConfig {
        versionName = System.getenv("APP_VERSION") ?: "0.0.0-dev"
        versionCode = (System.getenv("APP_BUILD_NUMBER") ?: "1").toInt()
    }
}

BuildConfig.VERSION_NAME luego muestra la versión en la aplicación.

Flutter#

flutter build appbundle --build-name="$APP_VERSION" --build-number="$APP_BUILD_NUMBER"
flutter build ipa --build-name="$APP_VERSION" --build-number="$APP_BUILD_NUMBER"

Expo y React Native#

Lea los valores en app.config.js:

export default {
  expo: {
    version: process.env.APP_VERSION ?? '0.0.0-dev',
    ios: { buildNumber: process.env.APP_BUILD_NUMBER ?? '1' },
    android: { versionCode: Number(process.env.APP_BUILD_NUMBER ?? 1) },
  },
};

Informe la versión que desplegó#

Un evento de despliegue puede indicar qué versión y compilación se desplegaron. Agregue version y buildNumber al evento que ya envía su canal de distribución:

{
  "schemaVersion": 1,
  "eventId": "ci:run-812:production:succeeded",
  "providerRunId": "run-812",
  "projectId": "<project-uuid>",
  "environmentKey": "production",
  "repository": "owner/repository",
  "commitSha": "0123456789abcdef0123456789abcdef01234567",
  "status": "succeeded",
  "occurredAt": "2026-09-28T12:00:00Z",
  "version": "1.4.0",
  "buildNumber": "42"
}

Si el canal de distribución del proyecto asigna versiones, el lanzamiento tomará la versión reportada. De lo contrario, la página de lanzamiento mostrará la versión reportada e indicará cuando difiera del lanzamiento. Para un proyecto alojado en Coroid, configure repository con el ID del proyecto. Eventos de despliegue y configuración de CI describe el resto del evento.

Compruebe qué se está ejecutando#

Asigne a cada entorno una URL de versión, como https://app.example.com/version.json. Una vez que el despliegue se complete con éxito, Coroid abrirá la URL y buscará el SHA del commit o la versión. El commit reportado debe coincidir con el commit del lanzamiento; de lo contrario, la versión debe coincidir. Coroid seguirá comprobando durante diez minutos mientras finaliza la implementación, y luego mostrará Verificado, Versión diferente o No accesible bajo Qué se está ejecutando en la página de lanzamiento.

La URL debe usar HTTPS y ser una dirección pública. Coroid no sigue redirecciones y lee como máximo 64 KB.

Deje que Coroid lo configure#

Configure el marcado de versión en la pantalla de Versión abre Nuevo trabajo con una solicitud redactada para el stack detectado del proyecto. Un agente lee los valores anteriores en tiempo de compilación, muestra la versión en la aplicación, escribe release.json, declara las entradas del flujo de trabajo y lo documenta en el README. Revise la solicitud y luego continúe como con cualquier otro trabajo.

Relacionado#

• Configuración de lanzamientos
• Eventos de despliegue y configuración de CI
• Lanzamientos