Automaticos Builds de Android con GitLab CI

Configurar 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
Su aplicación ya publicada en Google Play Store con firmado correctamente
Clave de firma Android y archivos de keystore
Proyecto de Google Cloud Console con Play Store API habilitado
Cuenta de servicio 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 pipeline

Capgo Build para CI/CD por Capgo

No mantener Fastlane, ejecutor de Gradle, keystore y script de carga. Capgo Construcción ejecuta compilaciones nativas Android firmadas a partir de tu pipeline CI/CD existente:

Funciona con tu pipeline: Inicia Capgo Build desde GitLab CI, GitHub Actions, Jenkins o scripts locales después de tu compilación web y npx cap sync.
La firma desde secretos de CIMantén tus keystore Android, alias de clave, contraseñas y archivo JSON de servicio de Play Console en tus propios secretos de CI.
No mantenimiento de ejecutor nativo: Capgo Build ofrece 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 envíoDescargar artefactos firmados para QA o enviar builds de lanzamiento a través del Capgo CLI.

Pricing

Los planes de Capgo comienzan a $12/mes
: Los minutos adicionales de compilación se facturan por minuto a través de créditos
Los minutos adicionales de construcción se facturan por minuto mediante créditos

Configura Capgo Build en CI/CD

Guía de configuración manual

Aquí está lo que debes hacer:

Pasos a seguir en el post

Copiar archivos de Fastlane
Almacenar sus secretos en secretos cifrados de GitLab
Almacenar tus secretos en variables de GitLab cifradas
Almacenar su clave de firma Android
Almacenar tu clave de firma de Android

1. Copie archivos de Fastlane

Fastlane is a Ruby library created to automate common mobile development tasks. Using Fastlane, you can configure custom “lanes” which bundle a series of “actions” that perform tasks that you’d normally perform using Android studio. You can do a lot with Fastlane, but for the purposes of this tutorial, we’ll be using only a handful of core actions.

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

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 sus secretos en variables de GitLab CI/CD

GitLab ofrece una forma de almacenar variables CI/CD cifradas, similar a los secretos de repositorio de GitHub.

Dirígete a los ajustes de tu proyecto de GitLab.
Navega a CI/CD > Variables
Agrega las siguientes variables:

ANDROID_KEYSTORE_FILE: el archivo base64 codificado .jks o .keystore el archivo utilizado para firmar tus builds de Android. Esto será el archivo de keystore asociado con tu clave de carga (si estás utilizando la firma de Play App Signing), o tu clave de firma de la aplicación.
KEYSTORE_KEY_PASSWORD: la contraseña asociada con el archivo de keystore
KEYSTORE_KEY_ALIAS: el alias del almacén de claves
KEYSTORE_STORE_PASSWORD: la contraseña de la clave privada
DEVELOPER_PACKAGE_NAME: tu ID de aplicación Android como com.example.app
PLAY_CONFIG_JSON: La clave JSON de servicio base64 codificada.

Crear una cuenta de servicios de Google Play

Para generar el PLAY_CONFIG_JSON segredo, sigue estos pasos:

Ir a la Consola de Google Cloud
Crear un nuevo proyecto o seleccionar uno existente
Habilita el desarrollador de Android de Google Play API
Crear una cuenta de servicio:
- Ir a “IAM & Admin” > “Cuentas de servicio”
- Hacer clic en “Crear Cuenta de Servicio”
- Darle un nombre y descripción
- Hacer clic en “Crear y Continuar”
- Saltarse la asignación de roles y hacer clic en “Hecho”
Genera 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 formato JSON
- Haz clic en ‘Crear’
Otorga acceso a la cuenta de servicio a tu aplicación en el Console de Play:
- Ve a Console de Play
- Navega a ‘Usuarios y permisos’
- Haz clic en ‘Invitar a nuevos usuarios’
- Introduzca la dirección de correo electrónico del servicio (termina con @*.iam.gserviceaccount.com)
- Otorgue la permiso de "Lanzar a producción"
- Haga clic en "Invitar a usuario"

Convirta la clave JSON a base64:

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

Agregue 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 su proyecto para definir su pipeline de CI/CD. A continuación, se muestra un ejemplo de cómo estructurar su 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 Pipelina

Cuando suba una nueva etiqueta a su repositorio de GitLab, la CI/CD de GitLab automáticamente activará la pipeline definida, que construirá y desplegará su aplicación Android utilizando Fastlane.

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

Conclusión

Configurando GitLab CI/CD con la imagen de Docker mingc/android-build-box, puede automatizar el proceso de compilación de la aplicación Android, lo que hace que su flujo de trabajo de desarrollo sea más eficiente y confiable. Esta automatización libera su tiempo para centrarse en los aspectos clave del desarrollo de aplicaciones, lo que le ayuda a entregar aplicaciones Android de alta calidad de manera más eficiente.

Keep going from Automatic Capacitor Android build with GitLab

Si está utilizando Automático Capacitor construcción de Android con GitLab para planificar la automatización de CI/CD, conecte 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 Nativas Builds, Capgo Integrations para el flujo de trabajo del producto en Capgo Integraciones, Integración de CI/CD para los detalles de implementación en la Integración CI/CD, y GitHub Integración de Acciones para los detalles de implementación en GitHub Integración de Acciones.