Construcción automática de Capacitor Android con GitHub acciones

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

Recomendado para Nuevas Construcciones: Utilizar Capgo Construcción

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 de GitHub existentes, pero nuevos builds de Android deben utilizar el Capgo CLI para que no tengas que mantener Fastlane, ejecutores de Gradle, keystore y scripts de carga tú mismo.

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 Android y archivos del almacén de claves
• Proyecto de Google Cloud Console con Play Store API habilitado
• 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

Saltar la configuración de Fastlane, Gradle runner, almacén de claves y script de carga Capgo Construcción ejecuta compilaciones nativas Android firmadas a partir de tu pipeline CI/CD existente:

• Funciona con tu pipeline: Dispara la Construcción de Capgo desde GitHub Actions, GitLab CI, Jenkins o scripts locales después de tu compilación web y npx cap sync.
• Firma desde secretos de CI: Mantén los almacenes de Android, alias de clave, contraseñas y servicio de cuenta de consola de Play en tus propios secretos de CI.
• Sin mantenimiento de ejecutor nativo: La Construcción de Capgo proporciona entornos de compilación de Android mantenidos, por lo que no tienes que administrar SDK imágenes, problemas de caché de Gradle o rutas de Fastlane.
• Artículos y presentación: Descarga artículos firmados para QA o envía compilaciones de lanzamiento a través de la Capgo CLI.

Precios

• 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 a través de créditos

Configura Capgo Compilación en CI/CD

Guía de Configuración Manual

Aquí está lo que debes hacer:

GitHub Acciones de Precio

GitHub Acciones ofrece minutos gratuitos basados en el tipo de repositorio de tu cuenta:

• Repositorios públicos: 2,000 minutos/mes
• Repositorios privados: 2,000 minutos/mes (ejecutables Linux)

Para proyectos privados, los costos son aproximadamente $0.008/minuto. Una compilación típica dura entre 3-5 minutos.

Pasos de Configuración Manual

1. Crear Keystore de Android
2. Configurar cuenta de servicio de Google Play
3. Configurar Fastlane
4. Configurar secretos GitHub
5. Crear flujo de trabajo de acciones GitHub

1. Crear Keystore de Android

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

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 fuerte (la necesitarás como KEYSTORE_STORE_PASSWORD)
• Contraseña de clave: Elige una contraseña fuerte (necesitarás esta como KEYSTORE_KEY_PASSWORD)
• Tu nombre, organización, etc.: Rellena tus detalles

Notas importantes

• Almacena 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 del keystore - necesitarás esta como KEYSTORE_STORE_PASSWORD
  • Contraseña de clave - necesitarás esta como KEYSTORE_KEY_PASSWORD

• Haz una copia de seguridad del archivo de keystore: Si lo pierdes, no podrás actualizar tu aplicación publicada

• Consérvelo en secreto: Nunca comites el archivo del keystore a git

• Almacénalo a salvo: Mantén múltiples copias en ubicaciones seguras

Alternativa: Utiliza el Keystore existente

Si ya publicaste tu aplicación, debes utilizar el mismo keystore que utilizaste inicialmente. Puedes encontrarlo:

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

2. Configura la cuenta de servicio de Google Play

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

Paso 2.1: Crea proyecto de Cloud de Google

1. Vaya a Consola de Google Cloud
2. Crear un nuevo proyecto o seleccionar uno existente
3. Nota el ID del proyecto

Paso 2.2: Habilitar al desarrollador de Google Play API

1. En la Consola de Google Cloud, vaya a APIs & Servicios → Biblioteca
2. Buscar por “Desarrollador de Android de Google Play API”
3. Haga clic Habilitar

Paso 2.3: Crear cuenta de servicio

1. Vaya a IAM & Admin → Cuentas de Servicio
2. Haga clic Crear Cuenta de Servicio
3. Introduzca detalles:
   • Nombre: github-actions-uploader
   • Descripción: “Cuenta de servicio para GitHub Acciones para subir compilaciones”
4. Haga clic Crear y Continuar
5. Saltar la asignación de roles por ahora (haga clic Continuarluego Completado)

Paso 2.4: Crear Clave de Cuenta de Servicio

1. Haga clic en la cuenta de servicio recién creada
2. Vaya a Claves pestaña
3. Haga clic Agregar Clave → Crear nueva clave
4. Seleccione JSON formato
5. Haga clic Crear
6. Un archivo JSON descargará - guarde esto de manera seguraque lo necesitarás más tarde

Paso 2.5: Otorgar acceso en la consola de Play

1. Ir a Consola de Play de Google
2. Ir a Configuración → API acceso
3. Bajo Cuentas de servicio, haz clic Otorgar acceso para tu cuenta de servicio
4. En la pestaña Permisos de la aplicación añade tu aplicación
5. En la pestaña Permisos de la cuenta 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
6. Hacer clic Invitar a un usuario
7. Hacer clic Enviar invitación

Paso 2.6: Verificar la clave JSON

El 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 fastlane carpeta en la raíz de tu proyecto y agrega 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 GitHub Secretos

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

Paso 4.1: Accede a GitHub Secretos

1. Ve a tu repositorio en GitHub
2. Hacer clic Configuración → Secretos y variables → Acciones
3. Hacer clic Nuevo secreto de repositorio

Paso 4.2: Agregar Secretos Requeridos

Agregue cada uno de estos secretos uno a la vez:

__CAPGO_KEEP_0__

1. Tome el archivo JSON de la cuenta de servicio que descargó en el Paso 2.4
2. Convirtalo a base64:

En macOS/Linux:

base64 service_account_key.json | pbcopy

En Windows (PowerShell):

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

3. Cree un nuevo secreto llamado PLAY_CONFIG_JSON y pegue la cadena base64

__CAPGO_KEEP_0__

1. Convirta su archivo 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

2. Crea un nuevo secreto con el nombre de ANDROID_KEYSTORE_FILE y pega la cadena base64

ALIAS_DE_LA_CLAVE_DEL_ALMACÉN

Crea un nuevo secreto con el alias de la clave que utilizaste al generar el almacén de claves (por ejemplo, my-key-alias)

Crea un nuevo secreto con la contraseña de la clave que estableciste al generar el almacén de claves

ALIAS_DE_LA_CLAVE_DEL_ALMACÉN

Crea un nuevo secreto con la contraseña de la clave que estableciste al generar el almacén de claves

ALIAS_DE_LA_CLAVE_DEL_ALMACÉN

Crea un nuevo secreto con la contraseña del almacén de claves que estableciste al generar el almacén de claves

NOMBRE_DEL_PAQUETE_DEL_DESARROLLADOR com.example.app)

Crea un nuevo secreto con el nombre de paquete de tu aplicación (por ejemplo, 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
• ✅ KEYSTORE_KEY_PASSWORD
• ✅ KEYSTORE_STORE_PASSWORD
• ✅ DEVELOPER_PACKAGE_NAME

5. Crear 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

1. Crear una etiqueta Git para desencadenar el flujo de trabajo
2. GitHub Acciones construye tu aplicación
3. Fastlane la sube a Google Play beta canal
4. Tus aplicaciones se actualizan automáticamente

Tiempo de compilación y costos

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

Artículos relacionados

Guías de configuración de CI/CD

• Automatic Capacitor iOS Build with GitHub Actions - Configuración de CI/CD completa de iOS
• Construcción Automática y Lanzamiento con GitHub Acciones - Tutorial completo de la pipeline de CI/CD
• Administrar Construcciones de Desarrollo y Producción con GitHub Acciones - Gestión de entornos

Plataformas Alternativas de CI/CD

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

Actualizaciones en Vivo y Despliegue

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

Recursos

• GitHub Acciones de Documentación
• Documentación de Fastlane

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

Si estás utilizando Construcción automática de Capacitor Android con GitHub acciones 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.