Documentación

Incluye la versión en tu compilación

Asigna una versión y un número de compilación a cada lanzamiento, pásalos al proceso de compilación y deja que CoRoid confirme qué se ejecuta en cada entorno.

Las personas que utilizan tu software necesitan ver qué versión están ejecutando. CoRoid asigna una versión y un número de compilación a cada lanzamiento, los pasa al pipeline de compilación y posteriormente verifica que el entorno ejecute el lanzamiento que desplegaste.

1. CoRoid lo denomina así

Lanzamiento

1.4.1

Compilación 12

Proviene de CoRoid, de un archivo en su repositorio o de su canalización.

2. Su canal de integración continua lo genera

Tu CI/CD

COROID_VERSION=1.4.1

COROID_BUILD_NUMBER=12

COROID_COMMIT_SHA=3da015d…

Los valores llegan como variables o entradas del flujo de trabajo.

3. Los usuarios lo visualizan

Acerca de

Versión 1.4.1 (12)

Se muestra en la aplicación y se escribe en release.json.

4. CoRoid lo verifica

GET /version.json

Verificado

La canalización informó 1.4.1, compilación 12

Después de un despliegue, CoRoid lee la URL de la versión.

La versión viaja con el lanzamiento hasta su compilación, y CoRoid verifica qué se ejecuta realmente en el entorno.

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. (el valor predeterminado): CoRoid sugiere la siguiente versión cuando preparas un lanzamiento. Incrementa el último número de la versión más alta que el proyecto haya lanzado, de modo que 1.4.0 va seguido de 1.4.1. El primer lanzamiento es 0.1.0. Escribe una versión diferente siempre que la necesites. Un despliegue que CoRoid no inició, como un despliegue manual que informa a CoRoid, también toma la siguiente versión, a menos que su pipeline indique otra.
  • Leerlo desde el repositorio: CoRoid lee la versión que tu código declara 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 en el proyecto de Xcode, o solo en el archivo que especifiques. Si el archivo todavía contiene una versión utilizada por un lanzamiento anterior, CoRoid te pedirá que la incrementes 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 un pipeline de GitLab CI/CD para un lanzamiento, pasa estos valores:

Variable de GitLabEntrada de GitHubValor
COROID_VERSIONcoroid_versionLa versión del lanzamiento
COROID_BUILD_NUMBERcoroid_build_numberEl número de compilación
COROID_RELEASE_NAMEcoroid_release_nameEl nombre del lanzamiento
COROID_COMMIT_SHAcoroid_commit_shaEl hash completo de la confirmación
COROID_ENVIRONMENTcoroid_environmentLa clave del entorno
COROID_RELEASE_IDcoroid_release_idEl ID de lanzamiento de CoRoid
COROID_ATTEMPT_IDcoroid_attempt_idEl intento de despliegue

GitHub rechaza las entradas que un 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. Eso 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 pipeline del proyecto asigna versiones, el lanzamiento adoptará la versión indicada. De lo contrario, la página de lanzamiento mostrará la versión reportada y señalará cuándo difiere del lanzamiento. Para un proyecto alojado en CoRoid, configura 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. Tras un despliegue exitoso, CoRoid abre la URL y busca el SHA de la confirmación o la versión. La confirmación reportada debe coincidir con la confirmación del lanzamiento; de lo contrario, la versión debe coincidir. CoRoid seguirá verificando durante diez minutos mientras finaliza el despliegue 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.

Deja 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.