Compilación automática de Android con Capacitor y acciones de GitHub.

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

Recomendado para Nuevas Construcciones: Utilizar Capgo Build

Ahora recomendamos utilizar Capgo Build con el Capgo CLI para compilaciones nativas Capacitor. Esta guía de Fastlane se mantiene para los equipos que mantienen pipelines de acciones GitHub existentes, pero los nuevos compilados de Android deben utilizar el Capgo CLI para que no tengas que mantener Fastlane, ejecutores de Gradle, archivos de 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 y archivos de keystore de Android
Proyecto de Google Cloud Console con API de Play Store habilitado
Cuenta de servicio con permisos adecuados
Conocimiento de flujos de trabajo de GitHub Actions
Conocimiento de la configuración de Fastlane
Tiempo para mantener y depurar la pipeline

Capgo Construye para CI/CD por Capgo

Saltar la configuración de Fastlane, el ejecutor de Gradle, el keystore y el script de carga. Capgo Construye Ejecuta compilaciones nativas firmadas de Android desde tu pipeline de CI/CD existente:

Funciona con tu pipeline: Inicia Capgo Construye 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 keystore de Android, alias de clave, contraseñas y archivo JSON de servicio de Play Console en tus propios secretos de CI.
Sin mantenimiento de ejecutor nativo: Capgo Construye 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

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

Configura Capgo Build en CI/CD

Guía de configuración manual

Aquí está lo que debes hacer:

GitHub Acciones de Precios

Precio de la GitHub Acción

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 (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 archivo de llave de Android
Configurar cuenta de servicio de Google Play
Configurar Fastlane
Configurar secretos de GitHub
Crear flujo de trabajo de acciones de GitHub

1. Crear archivo de llave de Android

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

Generar llave de acceso 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 del almacén de claves: Elige una contraseña fuerte (necesitarás esta como KEYSTORE_STORE_PASSWORD)
Contraseña de la 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 del almacén de claves (por ejemplo, my-release-key.keystore)
- Alias de la clave (por ejemplo, my-key-alias) - necesitarás esta como KEYSTORE_KEY_ALIAS
- Contraseña del almacén de claves - necesitarás esta como KEYSTORE_STORE_PASSWORD
- Clave de acceso - necesitarás esta KEYSTORE_KEY_PASSWORD
Realice una copia de seguridad del archivo del keystoreSi lo pierdes, no podrás actualizar tu aplicación publicada
Manténlo en secretoNo cometas el archivo del keystore a git
Almacénalo a salvoMantén múltiples copias de seguridad 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 primero construyó la aplicación
En su Consola de Play → Configuración → Firmado de aplicaciones (si está utilizando el servicio de firmado de aplicaciones de Google Play)

2. Configuración del servicio de cuenta de Google Play

Para permitir que las acciones de GitHub suban compilaciones a Google Play, necesita una cuenta de servicio.

Paso 2.1: Crear proyecto de Google Cloud

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

Paso 2.2: Habilitar el desarrollador de Google Play API

En la Consola de Google Cloud, vaya a APIs & Servicios → Biblioteca
Buscar “Desarrollador de Android de Google Play API”
Haga 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”
Hacer 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
Elige formato JSON Haz clic
Crear Un archivo JSON descargará -
guarda esto de manera segura que lo necesitarás más tardePaso 2.5: Otorgar acceso en Play Console

Ir a

Consola de Play de Google Ir a
Step 2.5: Grant Access in Play Console Configuración → API acceso
Bajo Cuentas de servicio, haz clic Conceder acceso para tu cuenta de servicio
En la Permisos de la aplicación pantalla, agrega tu aplicación
En la Permisos de la cuenta 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 Invitar a un usuario
Hacer 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. Configura 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 GitHub Secretos

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

Paso 4.1: Acceder a GitHub Secretos

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

Paso 4.2: Agregar secretos requeridos

Agrega cada uno de estos secretos uno a la vez:

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

En Windows (PowerShell):

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

Crear un nuevo secreto llamado PLAY_CONFIG_JSON y pega la cadena base64

ARCHIVO_KEYSTORE_ANDROID

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

Cree un nuevo secreto llamado ANDROID_KEYSTORE_FILE y pegue la cadena base64

ALIAS_DE_LA_CLAVE_DEL_ALMACÉN

Cree un nuevo secreto con el alias de la clave que utilizó al generar el almacén (por ejemplo, my-key-alias)

CONTRASEÑA_DE_LA_CLAVE_DEL_ALMACÉN

Cree un nuevo secreto con la contraseña de la clave que configuró al generar el almacén

CONTRASEÑA_DEL_ALMACÉN

Cree un nuevo secreto con la contraseña del almacén que configuró al generar el almacén

NOMBRE_DEL_PAQUETE_DEL_DESARROLLADOR

Crea 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 tener configurados estos 6 secretos:

✅ PLAY_CONFIG_JSON
✅ ANDROID_KEYSTORE_FILE
✅ KEYSTORE_KEY_ALIAS
✅ KEYSTORE_KEY_PASSWORD
✅ KEYSTORE_STORE_PASSWORD
✅ NOMBRE_DE_PAQUETE_DEL_DESARROLLADOR

5. Crea GitHub Acciones de Flujo de Trabajo

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 canal
Tu aplicación se actualiza automáticamente

Tiempo de Construcción y Costos

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 CI/CD

Construcción automática de iOS con Capacitor y GitHub - Configuración completa de CI/CD de iOS
Construcción y liberación automáticas con GitHub - Tutorial completo de pipeline de CI/CD
Gestión de compilaciones de desarrollo y producción con 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 Actualizaciones en vivo Documentación - 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 Capacitor Android con acciones de GitHub

Si estás utilizando Construcción automática de Capacitor Android con acciones de GitHub 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 de CI/CD para el detalle de implementación en Integración de CI/CD, y GitHub Integración de Acciones for the implementation detail in GitHub Actions Integration.

Automatic Capacitor Android build with GitHub actions