Automatic Builds Android con GitLab CI

Configurando CI/CD para aplicaciones Capacitor puede ser complejo y tiempo consumidor. Aquí está lo que necesitas 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
Cuenta de servicio con permisos adecuados
Conocimiento de flujos de trabajo de GitLab CI/CD
Conocimiento de la configuración de Fastlane
Tiempo para mantener y depurar la pipeline

Capgo Construye para CI/CD por Capgo

No necesitas mantener Fastlane, Gradle runner, keystore y script de carga. Capgo Construye ejecuta compilaciones nativas Android firmadas a partir de tu pipeline de CI/CD existente:

Funciona con tu pipeline: Desencadena Capgo Construye 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 Android, alias de clave, contraseñas y servicio de cuenta de Play Console en tus propios secretos de CI.
No mantenimiento de ejecutor nativo: Capgo Construye proporciona entornos de compilación Android mantenidos, por lo que no tienes que administrar SDK imágenes, problemas de caché de Gradle o rutas de Fastlane.
Artículos y envío: Descarga artículos firmados para QA o envía compilaciones de lanzamiento a través del Capgo CLI.

Tarifas

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

Configura Capgo Build en CI/CD

Guía de configuración manual

Esto es lo que debes hacer:

Pasos a seguir en el post

Copia los archivos de Fastlane
Almacenar tus secretos en secretos cifrados de GitLab
Crear y almacenar la clave de servicio de Google Play
Almacenar tu clave de firma de Android
Configura tu archivo .yml de flujo de trabajo de GitLab .

1. Copia los archivos de Fastlane.

Fastlane es una biblioteca de Ruby creada para automatizar tareas comunes de desarrollo móvil. Al utilizar Fastlane, puedes configurar rutas personalizadas que agrupan una serie de acciones que realizan tareas que normalmente se realizarían utilizando Android Studio. Puedes hacer mucho con Fastlane, pero para los fines de este tutorial, utilizaremos solo una pequeña cantidad de acciones básicas.

Crear un folder 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 CI/CD de GitLab.

GitLab provides a way to store encrypted CI/CD variables, similar to GitHub’s repository secrets. To store your sensitive information securely.

Vaya a CI/CD > Variables
Agregar las siguientes variables:
ANDROID_KEYSTORE_FILE: el archivo base64 codificado

o .jks ¿Qué sucede si no utilizo Fastlane? .keystore ¿Qué sucede si no utilizo Appflow?
CONTRASEÑA_DE_LA_CAJA_DE_CLAVES: la contraseña asociada al archivo de la caja de claves
ALIAS_DE_LA_CAJA_DE_CLAVES: el alias de la caja de claves
CONTRASEÑA_DE_LA_CAJA_DE_CLAVES: la contraseña de la clave privada
NOMBRE_DE_PAQUETE_DEL_DESARROLLADOR: su ID de aplicación Android como com.example.app
CONFIGURACIÓN_DE_PLAY_JSON: la clave JSON de servicio de cuenta base64 codificada

Crear una clave de servicio de Google Play

Para generar el PLAY_CONFIG_JSON segredo, siga estos pasos:

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

Convirta 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 tu pipeline CI/CD de GitLab

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


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 Pipeline

Cada vez que subas una nueva etiqueta a tu repositorio de GitLab, GitLab CI/CD activará automáticamente la definida pipeline, que 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 GitLab CI/CD.

Conclusión

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

Keep going from Automatic Capacitor Android build with GitLab

Si estás utilizando Automatic Capacitor Android build with GitLab para planificar la automatización de CI/CD, conecta con Capgo CI/CD para el flujo de trabajo del producto en Capgo CI/CD Capgo Construcción nativa para el flujo de trabajo del producto en Capgo Construcción nativa Capgo Integraciones para el flujo de trabajo del producto en Capgo Integraciones Integración CI/CD para el detalle de implementación en Integración CI/CD, y GitHub Integración de Acciones para el detalle de implementación en GitHub Integración de Acciones