Automático Capacitor de Android con GitHub acciones

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

Recomendado para Nuevas Construcciones: Utilice Capgo Build

Ahora recomendamos utilizar Capgo Construcción con el Capgo CLI para construcciones nativas de Capacitor. Esta guía de Fastlane se mantiene para equipos que mantienen pipelines de acciones existentes de GitHub, pero los nuevos builds de Android deben utilizar el Capgo CLI para que no deban mantener Fastlane, ejecutores de Gradle, keystore y scripts de carga por sí mismos.

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 firmas adecuadas
Clave de firma y archivos de keystore de Android
Proyecto de Google Cloud Console con API de Play Store habilitado
Cuenta de servicio con permisos adecuados
Comprender los flujos de trabajo de GitHub
Conocimientos de la configuración de Fastlane
Tiempo para mantener y depurar la pipeline

Capgo Build para CI/CD por Capgo

Evita el mantenimiento de Fastlane, Gradle runner, keystore y script de carga. Capgo Construcción ejecuta compilaciones nativas Android firmadas desde tu pipeline CI/CD existente:

Funciona con tu pipelineDesencadena la construcción de Capgo desde GitHub Actions, GitLab CI, Jenkins o scripts locales después de tu compilación web. npx cap sync.
Firmar desde secretos de CIMantén tus keystore Android, alias de clave, contraseñas y archivo JSON de servicio de Play Console en tus propias secretas de CI.
Mantenimiento de ejecución nativa: Capgo Build ofrece 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 envíoDescargue artefactos firmados para QA o envíe builds de lanzamiento a través de los Capgo CLI.

Pricing

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

Configura Capgo Build en CI/CD

Configura __CAPGO_KEEP_0__ Build en CI/CD

Guía de configuración manual

Pricing de GitHub

GitHub Actions Pricing

GitHub Acciones ofrece minutos gratuitos según el tipo de repositorio de su cuenta.

Repositorios públicos: 2,000 minutos/mes
Repositorios públicos: 2,000 minutos/mes

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

Pasos de configuración manual

Crear archivo de clave Android
Configurar cuenta de servicio de Google Play
Configurar Fastlane
Configurar secretos de GitHub
Crear flujo de trabajo de GitHub

1. Crear archivo de clave Android

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

Generar clave 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 le pedirá que:

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

Notas importantes

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 esta como KEYSTORE_KEY_ALIAS
- Contraseña de keystore - necesitarás esta como KEYSTORE_STORE_PASSWORD
- Contraseña clave - necesitarás esta como KEYSTORE_KEY_PASSWORD
Almacene el archivo del keystore: Si lo pierde, no podrá actualizar su aplicación publicada
Guárdelo en secreto: Nunca comita el archivo del keystore a git
Almacénelo a salvo: Mantenga múltiples copias en ubicaciones seguras

Alternativa: Utilice un Keystore existente

: Si ya publicó su aplicación, debe utilizar el mismo keystore que utilizó inicialmente. Puede encontrarlo:

: En su máquina local donde construyó la aplicación por primera vez
En su Consola de Play → Configuración → Firmado de Aplicación (si utiliza la firma de aplicaciones de Play)

2. Configura la cuenta de servicio de Google Play

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

Step 2.1: Crea un proyecto de Google Cloud

Vaya a Consola de Google Cloud
Crear un nuevo proyecto o seleccionar uno existente
Tenga en cuenta el ID del proyecto

Step 2.2: Habilita el desarrollador de Google Play API

En la Consola de Google Cloud, vaya a APIs y Servicios → Biblioteca
Búsqueda de "Desarrollador de Android de Google Play API"
Haga clic Habilitar

Step 2.3: Crea Cuenta de Servicio

Vaya a Administración de IAM → Cuentas de Servicio
Haga clic Crea Cuenta de Servicio
Introduzca 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
Elegir JSON formato
Haz clic Crear
Un archivo JSON descargará - guarda esto de manera segurate lo necesitarás más tarde

Paso 2.5: Otorgar Acceso en la Consola de Play

Ve a Consola de Play
Ve a Setup → API acceso
Bajo Cuentas de servicio, haz clic Otorgar acceso para tu cuenta de servicio
En la pestaña Permisos de la aplicación pestaña, agrega tu aplicación
En la pestaña Permisos de cuenta pestaña, otorga 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
Hacer clic Invita al usuario
Hacer clic Enviar invitación

Paso 2.6: Verificar la clave JSON

La archivo JSON descargado debería verse así:

{
  "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. Configura los secretos de GitHub

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

Paso 4.1: Acceder a los secretos de GitHub

Ve a tu repositorio en GitHub
Hacer clic Configuración → Secretos y variables → Acciones
Hacer clic Nuevo repositorio secreto

Step 4.2: Agregar Secretos Requeridos

Agregue cada una de estas secretas una por una.

PLAY_CONFIG_JSON

Tome el archivo JSON de la cuenta de servicio descargado en el paso 2.4
Convirtalo a base64:

Convirtalo a base64:

base64 service_account_key.json | pbcopy

En Windows (PowerShell):

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

En Windows (PowerShell): PLAY_CONFIG_JSON Crear un nuevo secreto llamado

y pegue la cadena base64

Convierta su keystore a base64:

En macOS/Linux:

base64 my-release-key.keystore | pbcopy

En Windows (PowerShell):

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

Crea un secreto nuevo llamado ANDROID_KEYSTORE_FILE y pega la cadena base64

Alias de la clave del keystore

Crea un secreto con la clave de alias que utilizaste al generar el keystore (por ejemplo, my-key-alias)

CONTRASEÑA_DE_LA_CLAVE_DEL_KEYSTORE

Crea un secreto con la contraseña de la clave que estableciste al generar el keystore

CONTRASEÑA_DE_ALMACÉN_DE_CLAVES

Crea un secreto con la contraseña del keystore que estableciste al generar el keystore

DEVELOPER_PACKAGE_NAME

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

Puede encontrar su nombre de paquete en android/app/build.gradle bajo applicationId

Paso 4.3: Verificar todos los secretos

Asegúrese de que tenga configurados estos 6 secretos:

✅ Configuración de Juego JSON
✅ ARCHIVO_DE_CLAVE_ANDROID
✅ ALIAS_DE_KEYSTORE
✅ CONTRASEÑA DE LA LLAVE DEL KEYSSTORE
✅ Contraseña del almacén de llaves
✅ NOMBRE_DE_PAQUETE_DE_DESARROLLADOR

5. Cree GitHub Workflow 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

Construcción Automática de Capacitor iOS con GitHub Acciones - Configuración de CI/CD completa para iOS
Construcción automática y lanzamiento con acciones de GitHub - Tutorial completo de pipeline de CI/CD
Gestión de compilaciones de Dev y Prod con acciones de GitHub - Gestión de entornos

Plataformas de CI/CD alternativas

Construcción con GitLab CI - Alternativa de GitLab para Android
Construcción 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

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

Si estás utilizando Automatic Capacitor Android build con GitHub acciones automáticas 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 Compilaciones nativas para el flujo de trabajo del producto en Capgo Compilaciones nativas 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

Automático Capacitor Android con GitHub acciones automatizadas