Automatic Capacitor Android build with GitHub actions

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

Recomendado para Nuevas Construcciones: Utilice Capgo Build

Ahora recomendamos utilizar Capgo Build con el Capgo CLI para construcciones nativas Capacitor. Esta guía de Fastlane se mantiene para equipos que mantienen existentes pipelines de acciones de GitHub, pero nuevos builds de Android deben utilizar el Capgo CLI para que no tengas que mantener Fastlane, ejecutores de Gradle, archivos de keystore y scripts de carga.

Requisitos previos

Antes de empezar, necesitarás configurar:

Una cuenta de GitHub con acceso administrativo
Tu 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
La cuenta de servicio con permisos adecuados
Conocimiento de los flujos de trabajo de GitHub Actions
Conocimiento de la configuración de Fastlane
Tiempo para mantener y depurar la pipeline

Capgo Build para CI/CD por Capgo

No mantener Fastlane, Gradle runner, keystore y script de carga. Capgo Build Ejecuta compilaciones nativas Android firmadas desde tu pipeline de CI/CD existente:

Funciona con tu pipeline: Inicia Capgo Build desde GitHub Actions, GitLab CI, Jenkins o scripts locales después de tu compilación web y npx cap sync.
La firma desde secretos de CI: Mantén los almacenes de Android, alias de clave, contraseñas y JSON de servicio de la consola de Play en tus propios secretos de CI.
No mantenimiento del ejecutor nativo: El Capgo Build proporciona entornos de compilación de Android mantenidos, por lo que no tiene que administrar 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 del Capgo CLI.

Precio

Capgo plans start at $12/month
Los planes de __CAPGO_KEEP_0__ comienzan en $12/mes
Incluye actualizaciones OTA y aproximadamente 15 compilaciones nativas por mes

Set up Capgo Build in CI/CD

contexto: Página/área: Capgo Builder / producto de compilación nativa en la nube. Rol: Oración de copia de sitio web. Visto en: página native-build.astro. Mensaje clave `native_build_builder_minutos_de_compilación` (Minutos de compilación del constructor de compilación nativa).

Configura __CAPGO_KEEP_0__ Build en CI/CD

Guía de configuración manual de GitHub Build en CI/CD

Precio GitHub Action

GitHub Actions ofrece minutos gratuitos basados en el tipo de repositorio de su cuenta:

Repositorios públicos: 2,000 minutos/mes
Repositorios privados: 2,000 minutos/mes (ejecutores de Linux)

Para proyectos privados, los costos son aproximadamente $0.008/minuto. Un típico build toma 3-5 minutos.

Pasos de configuración manual

Crear Keystore de Android
Configurar la cuenta de servicio de Google Play
Configurar Fastlane
Configurar GitHub secrets
Crear flujo de trabajo de GitHub Actions

1. Crear Keystore de Android

Antes de que puedas firmar y publicar tu aplicación Android, debes crear un archivo de keystore. Este es un proceso de configuración único.

Generar Keystore con keytool

Ejecuta este comando en tu terminal:

keytool -genkey -v -keystore my-release-key.keystore -alias my-key-alias -keyalg RSA -keysize 2048 -validity 10000

Se te pedirá:

Contraseña de keystore: Elige una contraseña segura (la necesitarás como KEYSTORE_STORE_PASSWORD)
Contraseña de clave: Elige una contraseña segura (la necesitarás como KEYSTORE_KEY_PASSWORD)
Tu nombre, organización, etc.: Rellena tus detalles

Importantes Notas

Guarda estos valores de manera segura:
- Ubicación del archivo de keystore (por ejemplo, my-release-key.keystore)
- Alias de clave (por ejemplo, my-key-alias) - necesitarás esto como KEYSTORE_KEY_ALIAS
- Contraseña del keystore - necesitarás esto como KEYSTORE_STORE_PASSWORD
- Contraseña de clave - necesitarás esto como KEYSTORE_KEY_PASSWORD
Realice una copia de seguridad del archivo de keystore: Si lo pierde, no podrá actualizar su aplicación publicada
Guárdelo en secreto: Nunca comita el archivo de keystore a git
Almacénelo de manera segura: Mantenga múltiples copias de seguridad en ubicaciones seguras

Opción alternativa: Utilice un Keystore existente

If ya publicaste ya aplicación, debes usar el mismo keystore que usaste inicialmente. Puedes encontrarlo:

En tu máquina local donde construiste la aplicación por primera vez
En tu Consola de Play → Configuración → Firmado de aplicaciones (si estás utilizando la firma de aplicaciones de Google Play)

2. Configura la cuenta de servicio de Google Play

Para permitir que las GitHub Acciones suban builds a Google Play, necesitas una cuenta de servicio.

Paso 2.1: Crea proyecto de Google Cloud

Ve a Consola de Google Cloud
Crear un nuevo proyecto o seleccionar uno existente
Nota el ID del proyecto

Paso 2.2: Habilita el desarrollador de API de Google Play

En la Consola de Google Cloud, ve a Servicios & APIs → Biblioteca
Buscar por “Desarrollador de Android de Google Play API”
Hacer clic Habilitar

Paso 2.3: Crear cuenta de servicio

Ir a IAM & Admin → Cuentas de servicio
Hacer clic Crear cuenta de servicio
Introducir detalles:
- Nombre: github-actions-uploader
- Descripción: “Cuenta de servicio para GitHub Acciones para subir compilaciones”
Haga clic Crear y Continuar
Saltar la asignación de roles por ahora (haga clic Continuar, luego Hecho)

Paso 2.4: Crear Clave de Cuenta de Servicio

Haga clic en la cuenta de servicio recién creada
Ir a Claves pestaña
Haga clic Agregar clave → Crear nueva clave
Seleccione formato JSON Haga clic
Crear Se descargará un archivo JSON -
guárdelo de manera segura lo necesitarás más tardeA un archivo JSON se descargará -

Step 2.5: Otorgar Acceso en Consola de Play

Vaya a Consola de Play
Vaya a Configuración → API access
Configuración de servicio , haga clicOtorgar acceso para su cuenta de servicio Sobre la
Configuración de servicio Permisos de la aplicación pestaña, agregar tu aplicación
En la Permisos de la cuenta pestaña, conceder estos permisos:
- Ver información de la aplicación y descargar informes en bloque (solo lectura)
- Crear, editar y eliminar aplicaciones de borrador
- Publicar aplicaciones en pistas de prueba
- Publicar aplicaciones en producción, excluir y otras pistas
Haga clic Invitar a un usuario
Haga clic Enviar invitación

Paso 2.6: Verificar la clave JSON

El archivo JSON descargado debería tener este aspecto:

{
  "type": "service_account",
  "project_id": "your-project-id",
  "private_key_id": "...",
  "private_key": "-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n",
  "client_email": "github-actions-uploader@your-project-id.iam.gserviceaccount.com",
  "client_id": "...",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "..."
}

Convertirás esto a base64 en el paso de configuración de secretos GitHub.

3. Configurar Fastlane

Crear un fastlane carpeta en la raíz de tu proyecto y agregar un Fastfile con este contenido:

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'])
        
        # Get previous build number and increment
        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}")
        
        # Build the app
        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
        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
end

4. Configurar Secretos GitHub

Ahora que tienes tu keystore y archivo JSON de servicio, debes almacenarlos de manera segura en GitHub.

Paso 4.1: Acceder a Secretos GitHub

Dirígete a tu repositorio en GitHub
Haz clic Ajustes → Secretos y variables → Acciones
Haz clic Nueva secreta de repositorio

Paso 4.2: Agregar secretos requeridos

Agregar cada uno de estos secretos por separado:

PLAY_CONFIG_JSON

Obtén el archivo JSON de la cuenta de servicio que descargaste en el paso 2.4
Conviértelo a base64:

En macOS/Linux:

base64 service_account_key.json | pbcopy

On Windows (PowerShell):

[Convert]::ToBase64String([IO.File]::ReadAllBytes("service_account_key.json")) | Set-Clipboard

Crear un nuevo secreto llamado PLAY_CONFIG_JSON y pegar la cadena base64

ANDROID_KEYSTORE_FILE

Convertir su keystore a base64:

On macOS/Linux:

base64 my-release-key.keystore | pbcopy

On Windows (PowerShell):

[Convert]::ToBase64String([IO.File]::ReadAllBytes("my-release-key.keystore")) | Set-Clipboard

Crear un nuevo secreto llamado ANDROID_KEYSTORE_FILE y pegar la cadena base64

KEYSTORE_KEY_ALIAS

Crear un nuevo secreto con la clave de alias que utilizó cuando generó el keystore (por ejemplo, my-key-alias)

KEYSTORE_KEY_PASSWORD

Crear un nuevo secreto con la clave de contraseña que configuraste al generar el keystore

KEYSTORE_STORE_PASSWORD

Crear un nuevo secreto con la contraseña del keystore que configuraste al generar el keystore

DEVELOPER_PACKAGE_NAME

Crear un nuevo secreto con el nombre de paquete de tu aplicación (por ejemplo, com.example.app)

Puedes encontrar el nombre de paquete en android/app/build.gradle bajo applicationId

Paso 4.3: Verificar todos los secretos

Asegúrate de que tengas configurados estos 6 secretos:

✅ PLAY_CONFIG_JSON
✅ ANDROID_KEYSTORE_FILE
✅ KEYSTORE_KEY_ALIAS
✅ CONTRASEÑA DEL ARCHIVO DE KEYSSTORE
✅ CONTRASEÑA DEL ALMACÉN DE KEYSSTORE
✅ NOMBRE DEL PAQUETE DEL DESARROLLADOR

5. Crea GitHub Flujos de Acciones

Crear .github/workflows/build-upload-android.yml:

name: Build and Deploy Android App

on:
  push:
    tags:
      - '*'

jobs:
  build_android:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      
      - name: Setup Node.js
        uses: actions/setup-node@v6
        with:
          node-version: 24
          cache: npm
          
      - name: Install dependencies
        run: npm ci
        
      - name: Cache Gradle
        uses: actions/cache@v5
        with:
          path: |
            ~/.gradle/caches
            ~/.gradle/wrapper
          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
          restore-keys: |
            ${{ runner.os }}-gradle-
            
      - name: Build app
        run: npm run build
        
      - name: Sync Capacitor
        run: npx cap sync
        
      - name: Setup Java
        uses: actions/setup-node@v5
        with:
            distribution: 'zulu'
            java-version: '17'
            
      - name: Setup Ruby
        uses: ruby/setup-ruby@v1
        with:
          ruby-version: '3.0'
          bundler-cache: true
          
      - name: Run Fastlane
        uses: maierj/fastlane-action@v3.1.0
        env:
          PLAY_CONFIG_JSON: ${{ secrets.PLAY_CONFIG_JSON }}
          ANDROID_KEYSTORE_FILE: ${{ secrets.ANDROID_KEYSTORE_FILE }}
          DEVELOPER_PACKAGE_NAME: ${{ secrets.DEVELOPER_PACKAGE_NAME }}
          KEYSTORE_KEY_ALIAS: ${{ secrets.KEYSTORE_KEY_ALIAS }}
          KEYSTORE_KEY_PASSWORD: ${{ secrets.KEYSTORE_KEY_PASSWORD }}
          KEYSTORE_STORE_PASSWORD: ${{ secrets.KEYSTORE_STORE_PASSWORD }}
        with:
          lane: android beta
          
      - name: Upload artifact
        uses: actions/upload-artifact@v2
        with:
          name: android-release
          path: ./android/app/build/outputs/bundle/release/app-release.aab
          retention-days: 10

Cómo Funciona

Crear una etiqueta Git para desencadenar el flujo de trabajo
GitHub Acciones construye tu aplicación
Fastlane la sube a Google Play beta
Tu aplicación se actualiza automáticamente

Tiempo y Costos de Construcción

Tiempo de construcción: 3-5 minutos
Costo para repositorios privados: ~$0.04 por construcción
Gratis para proyectos de código abierto

Guías de configuración de CI/CD

Automatic Capacitor iOS Build with GitHub Actions - Configuración completa de CI/CD de iOS
Construcción y liberación automática con acciones de GitHub - Tutorial completo de pipeline de CI/CD
Administrar construcciones de Dev y Prod con acciones de GitHub - Gestión de entornos

Plataformas de CI/CD alternativas

Construir con GitLab CI - Alternativa de GitLab para Android
Construye con CodeMagic - Guía de configuración de CodeMagic

Actualizaciones en vivo y despliegue

Capgo Documentación de Actualizaciones en vivo - Agrega actualizaciones OTA a tu aplicación
Integración CI/CD con Capgo - Integra actualizaciones en vivo en tu pipeline

Recursos

Keep going from Automatic Capacitor Android build with GitHub actions

If you are using Automatic Capacitor Android build with GitHub actions 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 Builds Nativos para el flujo de trabajo del producto en Capgo Builds Nativos, Capgo Integraciones para el flujo de trabajo del producto en Capgo Integraciones, Integración de CI/CD para el detalle de implementación en Integración de CI/CD, y GitHub Integración de Acciones para los detalles de implementación en GitHub Integración de Acciones.