Builds automáticos de Android con GitLab CI

Configurar CI/CD para apps de Capacitor puede ser complejo y llevar mucho tiempo. Esto es lo que necesitas saber:

Requisitos

Antes de empezar, necesitas configurar:

Una cuenta de GitLab con acceso de administrador
Tu app ya publicada en Google Play Store con la firma adecuada
Clave de firma de Android y archivos keystore
Un proyecto en Google Cloud Console con API de Play Store habilitado
Una cuenta de servicio con los permisos adecuados
Conocimiento de los flujos de trabajo de GitLab CI/CD
Conocimiento de la configuración de Fastlane
Tiempo para mantener y depurar el pipeline

Capgo Build para CI/CD por Capgo

Olvídate de mantener Fastlane, el runner de Gradle, el keystore y los scripts de upload. Build de Capgo ejecuta builds nativos de Android firmados desde tu pipeline de CI/CD actual:

Funciona con tu pipeline: Ejecuta Capgo Build desde GitLab CI, GitHub Actions, Jenkins o scripts locales después de tu build web y npx cap sync.
Firma mediante secretos de CI: Mantén los keystores de Android, alias de claves, contraseñas y el JSON de la cuenta de servicio de Play Console en tus propios secretos de CI.
Sin mantenimiento de runners nativos: Capgo Build ofrece entornos de build para Android mantenidos, para que no tengas que gestionar imágenes SDK, problemas de caché de Gradle o lanes de Fastlane.
Artifacts y envío: Descarga artifacts firmados para QA o envía builds de release mediante Capgo CLI.

Precios

Los planes de Capgo desde $12/mes
Incluye actualizaciones OTA y unos 15 Native Build al mes
Los minutos de build extra se cobran por minuto mediante créditos

Configura Capgo Build en tu CI/CD

Guía de configuración manual

Esto es lo que tienes que hacer:

Pasos a seguir en el post

Copiar archivos de Fastlane
Guardar tus secretos en los secretos cifrados de GitLab
Crear y guardar tu clave de cuenta de servicio de Google Play
Guardar tu clave de firma de Android
Configura tu archivo .yml de workflow de GitLab

1. Copia los archivos de Fastlane

Fastlane es una librería de Ruby creada para automatizar tareas comunes de desarrollo móvil. Con Fastlane, puedes configurar “lanes” personalizadas que agrupan una serie de “actions” que realizan tareas que normalmente harías usando Android Studio. Puedes hacer mucho con Fastlane, pero para este tutorial usaremos solo unas pocas acciones principales.

Crea una carpeta Fastlane en la raíz de tu proyecto y copia los siguientes archivos: Fastlane

default_platform(:android)

KEYSTORE_KEY_ALIAS = ENV["KEYSTORE_KEY_ALIAS"]
KEYSTORE_KEY_PASSWORD = ENV["KEYSTORE_KEY_PASSWORD"]
KEYSTORE_STORE_PASSWORD = ENV["KEYSTORE_STORE_PASSWORD"]

platform :android do
    desc "Deploy a beta version to the Google Play"
    private_lane :verify_changelog_exists do |version_code: |
      changelog_path = "android/metadata/en-US/changelogs/#{version_code}.txt"
      UI.user_error!("Missing changelog file at #{changelog_path}") unless File.exist?(changelog_path)
      UI.message("Changelog exists for version code #{version_code}")
    end

    private_lane :verify_upload_to_staging do |version_name: |
      UI.message "Skipping staging verification step"
    end
    lane :beta do
				keystore_path = "#{Dir.tmpdir}/build_keystore.keystore"
				File.write(keystore_path, Base64.decode64(ENV['ANDROID_KEYSTORE_FILE']))
				json_key_data = Base64.decode64(ENV['PLAY_CONFIG_JSON'])
				previous_build_number = google_play_track_version_codes(
					package_name: ENV['DEVELOPER_PACKAGE_NAME'],
					track: "internal",
					json_key_data: json_key_data,
				)[0]

				current_build_number = previous_build_number + 1
				sh("export NEW_BUILD_NUMBER=#{current_build_number}")
        gradle(
          task: "clean bundleRelease",
          project_dir: 'android/',
          print_command: false,
          properties: {
            "android.injected.signing.store.file" => "#{keystore_path}",
            "android.injected.signing.store.password" => "#{KEYSTORE_STORE_PASSWORD}",
            "android.injected.signing.key.alias" => "#{KEYSTORE_KEY_ALIAS}",
            "android.injected.signing.key.password" => "#{KEYSTORE_KEY_PASSWORD}",
						'versionCode' => current_build_number
          })
        upload_to_play_store(
					package_name: ENV['DEVELOPER_PACKAGE_NAME'],
					json_key_data: json_key_data,
          track: 'internal',
          release_status: 'completed',
          skip_upload_metadata: true,
          skip_upload_changelogs: true,
          skip_upload_images: true,
          skip_upload_screenshots: true,
        )
    end
    lane :build do
      gradle(
        task: "clean bundleRelease",
        project_dir: 'android/',
        print_command: false,
        properties: {
          "android.injected.signing.store.file" => "#{keystore_path}",
          "android.injected.signing.store.password" => "#{KEYSTORE_STORE_PASSWORD}",
          "android.injected.signing.key.alias" => "#{KEYSTORE_KEY_ALIAS}",
          "android.injected.signing.key.password" => "#{KEYSTORE_KEY_PASSWORD}",
        })
    end
    lane :prod_release do
      build_gradle = File.read("../android/app/build.gradle")

      verify_changelog_exists(version_code: build_gradle.match(/versionCode (\d+)/)[1])
      verify_upload_to_staging(version_name: build_gradle.match(/versionName '([\d\.]+)'/)[1])

      supply(
        track_promote_to: 'beta',
        skip_upload_apk: true,
        skip_upload_aab: true,
        skip_upload_metadata: false,
        skip_upload_changelogs: false,
        skip_upload_images: false,
        skip_upload_screenshots: false
      )
    end
end

Almacenar tus secretos en variables de CI/CD de GitLab

GitLab permite almacenar variables CI/CD cifradas, al igual que los secretos de repositorio de GitHub. Para guardar tu información sensible de forma segura.

Ve a la configuración de tu proyecto en GitLab.
Navega a CI/CD > Variables
Añade las siguientes variables:

ANDROID_KEYSTORE_FILE: el archivo codificado en base64 .jks o .keystore utilizado para firmar tus builds de Android. Será el archivo keystore asociado a tu clave de subida (si usas Play App Signing) o tu clave de firma de la app.
KEYSTORE_KEY_PASSWORD: la contraseña asociada al archivo keystore
KEYSTORE_KEY_ALIAS: el alias del almacén de claves
KEYSTORE_STORE_PASSWORD: la contraseña de la clave privada
DEVELOPER_PACKAGE_NAME: el ID de tu app de Android, como com.example.app
PLAY_CONFIG_JSON: La clave JSON de la cuenta de servicio codificada en base64.

Crear una clave de cuenta de servicio de Google Play

Para generar la PLAY_CONFIG_JSON clave secreta, sigue estos pasos:

Ve a la pestaña Consola de Google Cloud
Crea un nuevo proyecto o selecciona uno existente
Habilita el API de desarrollador de Android de Google Play
Crea una cuenta de servicio:
- Ve a “IAM & Admin” > “Service Accounts”
- Haz clic en “Create Service Account”
- Dale un nombre y una descripción
- Haz clic en “Crear y continuar”
- Omite la asignación de roles y haz clic en “Listo”
Genera una clave JSON:
- Busca tu cuenta de servicio en la lista
- Haz clic en el menú de tres puntos > “Administrar claves”
- Haz clic en “Añadir clave” > “Crear clave nueva”
- Elige el formato JSON
- Haz clic en “Crear”
Da acceso a la cuenta de servicio a tu app en Play Console:
- Ve a Play Console
- Ve a “Usuarios y permisos”
- Haz clic en “Invitar nuevos usuarios”
- Introduce el correo de la cuenta de servicio (termina en @*.iam.gserviceaccount.com)
- Concede el permiso “Release to production”
- Haz clic en “Invitar usuario”

Convierte la clave JSON a base64:

base64 -i path/to/your/service-account-key.json | pbcopy

Añade la cadena codificada en base64 como PLAY_CONFIG_JSON variable en GitLab

Configura tu pipeline de CI/CD en GitLab

Crea un archivo .gitlab-ci.yml en la raíz de tu proyecto para definir tu pipeline de CI/CD. A continuación, un ejemplo de cómo puedes estructurarlo:


image: mingc/android-build-box:latest

stages:
  - build
  - upload_to_capgo
  - build_and_upload_android

build:
  stage: build
  tags:
    - saas-linux-xlarge-amd64
  cache:
    - key:
        files:
          - bun.lockb
      paths:
        - .node_modules/
  script:
    - npm install
    - npm run build
  artifacts:
    paths:
      - node_modules/
      - dist/
  only:
    - master

upload_to_capgo:
  stage: upload_to_capgo
  tags:
    - saas-linux-xlarge-amd64
  script:
    - npx @capgo/cli@latest bundle upload -a $CAPGO_TOKEN -c dev
  dependencies:
    - build
  when: manual
  only:
    - master

build_and_upload_android:
  tags:
    - saas-linux-xlarge-amd64
  stage:    build_and_upload_android
  cache:
    - key:
        files:
          - android/gradle/wrapper/gradle-wrapper.properties
      paths:
        - ~/.gradle/caches/
  script:
    - npx cap sync android
    - npx cap copy android
    - bundle exec fastlane android beta # We do create a tag for the build to trigger XCode cloud builds
  dependencies:
    - build
  when: manual
  only:
    - master

Disparar el pipeline

Cada vez que hagas push de una nueva tag a tu repositorio de GitLab, GitLab CI/CD disparará automáticamente el pipeline definido, que compilará y desplegará tu app de Android usando Fastlane.

Asegúrate de ajustar las rutas y dependencias según la estructura y requisitos de tu proyecto. Esta configuración te ayudará a automatizar el despliegue de tu app de Android en GitLab CI/CD.

Conclusión

Al configurar GitLab CI/CD con la imagen Docker mingc/android-build-box, puedes automatizar el proceso de build de tu app de Android, haciendo que tu flujo de trabajo de desarrollo sea más eficiente y confiable. Esta automatización te libera tiempo para centrarte en los aspectos clave del desarrollo de apps, lo que te ayuda a entregar apps de Android de alta calidad de manera más eficiente.

Sigue con la build automática de Capacitor para Android con GitLab

Si estás usando Build automático de Capacitor para Android con GitLab para planificar la automatización de CI/CD, conéctalo con CI/CD de Capgo para el flujo de trabajo del producto en Capgo CI/CD, Native Builds de Capgo para el flujo de trabajo del producto en Capgo Native Builds, Integraciones de Capgo para el flujo de trabajo del producto en Capgo Integraciones, Integración CI/CD para los detalles de implementación de CI/CD Integration, y Integración con GitHub Actions para los detalles de implementación de GitHub Actions Integration.