Automático Capacitor Android con acciones de GitHub

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

Requisitos previos

Antes de empezar, necesitarás configurar:

Una cuenta de GitHub 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
Conocimiento de GitHub Actions workflows
Conocimiento de la configuración de Fastlane
Tiempo para mantener y depurar la pipeline

Capgo Build para CI/CD por Capgo

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

Funciona con tu pipeline: Disparar Capgo Build desde GitHub Actions, GitLab CI, Jenkins o scripts locales después de su compilación web y npx cap sync.
La firma desde secretos de CI: Mantenga las llaves de Android, alias de llave, contraseñas y servicio de cuenta de Play Console en sus propios secretos de CI.
No mantenimiento del ejecutor nativoLa Capgo Build ofrece entornos de compilación de Android mantenidos, por lo que no necesita administrar SDK imágenes, problemas de caché de Gradle o rutas de Fastlane.
Artículos y envíoDescargue los artefactos firmados para QA o envíe 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

Esto es lo que debes hacer:

GitHub Acciones de Precios

Precio de la GitHub Acción

GitHub Acciones ofrece minutos gratuitos según el tipo de repositorio:

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

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

Pasos de configuración manual

Crear Keystore de Android
Configurar Cuenta de Servicio de Google Play
Configurar Fastlane
Configura GitHub secretos
Crear GitHub flujo de trabajo de Acciones

1. Crea 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.

Genera 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

Serás solicitado para:

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 (la necesitarás como KEYSTORE_KEY_PASSWORD)
Tu nombre, organización, etc.: Rellene los detalles

Importantes Notas

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

Opción alternativa: Utilizar 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 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 acciones GitHub suban versiones a Google Play, necesitas una cuenta de servicio.

2.1: Crea proyecto de Google Cloud

context Google Cloud Console
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 y Servicios → Biblioteca
Buscar "Desarrollador de Android de Google Play API"
Haga clic Habilitar

Paso 2.3: Crear cuenta de servicio

Vaya a IAM y Administración → Cuentas de servicio
Haz clic Crear cuenta de servicio
Introduce los detalles:
- Nombre: github-actions-uploader
- Descripción: “Cuenta de servicio para GitHub Acciones para subir compilaciones”
Haz clic Crear y continuar
Saltar la asignación de roles por ahora (haz clic Continúa, luego Listo)

Paso 2.4: Crear clave de cuenta de servicio

Haga clic en la cuenta de servicio recién creada
Vaya a Claves pantalla
Haga clic Agregar clave → Crear nueva clave
Seleccione formato JSON Crear
Haga clic Create
A un archivo JSON se descargará - guárdelo de manera seguraque lo necesitarás más tarde

Paso 2.5: Otorgar acceso en el Console de Play

Vaya a Console de Play de Google
Vaya a Configuración → Acceso a API
Bajo Cuentas de serviciohaga 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 pantalla, concede 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
Haz clic Invita al usuario
Haz clic Enviar invitación

2.6: Verificar la clave JSON

La archivo JSON descargado debe tener este formato:

{
  "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 secretos GitHub

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

Step 4.1: Accede a GitHub Secrets

Vaya a tu repositorio en GitHub
Click Ajustes → Secretos y variables → Acciones
Click Nueva secreta de repositorio

Step 4.2: Agrega los secretos requeridos

Agrega cada uno de estos secretos uno por uno:

PLAY_CONFIG_JSON

Cargue el archivo JSON de la cuenta de servicio descargado en el paso 2.4.
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

Crear un secreto nuevo llamado PLAY_CONFIG_JSON y pegue la cadena base64

Archivo_de_clave_Android

Convirta 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

Crear un secreto nuevo llamado ANDROID_KEYSTORE_FILE y pegue la cadena base64

Alias de la clave del keystore

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

CONTRASEÑA_DE_LA_CUENTA_DE_CLENTES

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

CONTRASEÑA_DE_ALMACÉN_DE_CLAVES

Crear un nuevo secreto con la contraseña del keystore que estableciste 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 tu nombre de paquete en android/app/build.gradle bajo applicationId

Step 4.3: Verificar todos los secretos

Asegúrese de que tenga configuradas estas 6 secretas:

✅ CONFIGURACIÓN DE PLAY JSON
✅ ARCHIVO DE KEYS DE ANDROID
✅ ALINEACIÓN DE LA CLAVE DEL KEYS
✅ CONTRASEÑA DE LA CLAVE DEL KEYS
✅ CONTRASEÑA DEL ALMACÉN DE KEYS
✅ 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 un etiqueta Git para desencadenar el flujo de trabajo
GitHub Acciones compila tu aplicación
Fastlane la sube a Google Play beta canal
Su 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 de CI/CD

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

Plataformas CI/CD alternativas

Construye 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

Continúa desde la construcción automática de Android de Capacitor con acciones de GitHub

Si estás utilizando Automático 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 los detalles de implementación en Integración CI/CD, y GitHub Integración de Acciones para los detalles de implementación en GitHub Integración de Acciones.