Construcción automática de Android con GitLab CI

Configurar CI/CD para aplicaciones Capacitor puede ser complejo y tiempo consumidor. Aquí está lo que debes saber:

Requisitos previos

Antes de empezar, necesitarás configurar:

Una cuenta de GitLab con acceso administrativo
Tu aplicación ya publicada en Google Play Store con firmas adecuadas
Clave de firma Android y archivos de keystore
Proyecto de Google Cloud Console con Play Store API habilitado
Servicio de cuenta con permisos adecuados
Comprensión de flujos de trabajo de GitLab CI/CD
Conocimiento de configuración de Fastlane
Tiempo para mantener y depurar la canalización

Capgo Construir para CI/CD por Capgo

Saltarse la configuración de Fastlane, el ejecutor de Gradle, el keystore y el script de carga. Capgo Construir ejecuta compilaciones nativas firmadas de Android desde tu canalización de CI/CD existente:

Funciona con tu canalización: Desencadena Capgo Construir desde GitLab CI, GitHub Actions, Jenkins o scripts locales después de tu compilación web y npx cap sync.
Autenticación desde secretos de CI: Mantén los keystore de Android, alias de clave, contraseñas y servicio de cuenta de la consola de Play en tus propios secretos de CI.
No mantenimiento del ejecutor nativo: Capgo Build proporciona entornos de compilación de Android mantenidos, por lo que no tiene que gestionar SDK imágenes, problemas de caché de Gradle o rutas de Fastlane.
Artículos y presentación: Descargar artefactos firmados para QA o presentar versiones de lanzamiento a través de la Capgo CLI.

Precio

Los planes de Capgo comienzan en $12/mes
Incluye actualizaciones OTA y aproximadamente 15 compilaciones nativas por mes
Los minutos adicionales de compilación se facturan por minuto a través de créditos

Configurar Capgo Build en CI/CD

Guía de configuración manual

Esto es lo que necesita hacer:

Pasos a seguir en el post

Copy archivos de Fastlane
Almacenar tus secretos en variables de GitLab cifradas
Crear y almacenar la clave de servicio de Google Play
Almacenar tu clave de firma de Android
Configura tu archivo de flujo de trabajo de GitLab (.yml)

1. Copiar archivos de Fastlane

Fastlane es una biblioteca de Ruby creada para automatizar tareas comunes de desarrollo móvil. Al utilizar Fastlane, puedes configurar

Crear una carpeta de 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 GitLab CI/CD

GitLab proporciona una forma de almacenar variables de CI/CD cifradas, similar a los secretos de repositorio de GitHub . Para almacenar tus información sensible de manera segura.

Ve a la configuración de tu proyecto de GitLab.
Ir a CI/CD > Variables
Agregar las siguientes variables:

ANDROID_KEYSTORE_FILE: el archivo base64 codificado .jks o .keystore el archivo utilizado para firmar sus compilaciones de Android. Este será el archivo del keystore asociado con su clave de carga (si utiliza la firma de Play App), o su clave de firma de la aplicación.
KEYSTORE_KEY_PASSWORD: la contraseña asociada con el archivo del keystore
KEYSTORE_KEY_ALIAS: el alias del keystore
KEYSTORE_STORE_PASSWORD: la contraseña de la clave privada
DEVELOPER_PACKAGE_NAME: su ID de aplicación de Android como com.example.app
PLAY_CONFIG_JSON: La clave JSON de servicio de Google Play base64 codificada.

Creando una clave de servicio de Google Play

Crear el PLAY_CONFIG_JSON segredo, siga estos pasos:

Vaya a la Consola de Google Cloud
Crear un nuevo proyecto o seleccionar uno existente
Habilite el desarrollador de Android de Google Play API
Crear una cuenta de servicio:
- Vaya a “IAM & Admin” > “Cuentas de servicio”
- Haga clic en “Crear Cuenta de Servicio”
- Déle un nombre y una descripción
- Haga clic en “Crear y Continuar”
- Saltar la asignación de roles y haga clic en “Hecho”
Generar una clave JSON:
- Encuentre su cuenta de servicio en la lista
- Haga clic en el menú de tres puntos > “Administrar claves”
- Haga clic en “Agregar clave” > “Crear nueva clave”
- Elige formato JSON
- Haga clic en “Crear”
Otorgue acceso al servicio de cuenta a su aplicación en el Console de Play:
- Vaya a Console de Play
- Navegue a “Usuarios y permisos”
- Haga clic en “Invitar nuevos usuarios”
- Introduzca el correo electrónico de la cuenta de servicio (termina con @*.iam.gserviceaccount.com)
- Otorgue la permiso “Lanzar a producción”
- Haga clic en “Invitar usuario”

Convertir la clave JSON a base64:

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

Agregar la cadena base64 codificada como la PLAY_CONFIG_JSON variable en GitLab

Configuración de la Pipelina de CI/CD de GitLab

Crear un archivo .gitlab-ci.yml en la raíz de tu proyecto para definir tu pipelina de CI/CD. A continuación, se muestra un ejemplo de cómo estructurar tu pipelina:


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

Activar la Pipelina

Cuando subas una nueva etiqueta a tu repositorio de GitLab, la pipelina de CI/CD de GitLab se activará automáticamente, lo que permitirá construir y desplegar tu aplicación Android utilizando Fastlane.

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

Conclusión

Al configurar la pipelina de CI/CD de GitLab con la imagen de Docker mingc/android-build-box, puedes automatizar el proceso de construcción de la aplicación Android, lo que te permitirá tener un flujo de trabajo de desarrollo más eficiente y confiable. Esta automatización te liberará tiempo para enfocarte en los aspectos clave del desarrollo de aplicaciones, lo que te ayudará a entregar aplicaciones Android de alta calidad de manera más eficiente.

Sigue adelante desde la construcción automática de Android con GitLab Capacitor

Si estás utilizando Automatic Capacitor Android build with GitLab para planificar la automatización de CI/CD, conectarlo con Capgo CI/CD for the product workflow in Capgo CI/CD, Capgo Native Builds for the product workflow in Capgo Native Builds, Capgo Integrations for the product workflow in Capgo Integrations, Integración de CI/CD para el detalle de implementación en Integración de CI/CD, y GitHub Actions Integration for the implementation detail in GitHub Actions Integration.