Automatic Capacitor Android build with GitHub actions

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

Recomendado para Nuevas Construcciones: Utiliza Capgo Build

Ahora recomendamos utilizar Capgo Build con el Capgo CLI para compilaciones nativas Capacitor. Esta guía de Fastlane se mantiene para equipos que mantienen pipelines de acciones GitHub existentes, pero 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.

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

Configuración de CI/CD Profesional por Capgo

Saltarse la complejidad. Capgo __CAPGO_KEEP_0__ configura su pipeline de CI/CD directamente en su plataforma preferida:

Independencia de la Plataforma: Funciona con GitHub Actions, GitLab CI u otros
Integración Sin Problemas: No es necesario cambiar de plataforma, funciona con su proceso actual
Configuración Personalizada: Configuración personalizada que se adapta a las necesidades de su proyecto
Guía de Expertos: Ya hemos configurado CI/CD para +50 aplicaciones

Precios

Tarifa de configuración única: $2,600
Sus costos de ejecución: ~$300/año
Compare con Otra solución propietaria: $6,000/año
Ahorre $26,100 en 5 años

Configura CI/CD Ahora

Guía de configuración manual

Si todavía quieres configurar todo tú mismo, aquí está lo que necesitas hacer:

GitHub Acciones de Precios

Precio de GitHub Acción

GitHub Acciones 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 proceso típico dura entre 3-5 minutos.

Pasos de configuración manual

Crear archivo de clave 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 clave de Android

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

Generar clave de archivo 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á lo siguiente:

Contraseña del almacén de claves: Elija una contraseña fuerte (necesitará esta como KEYSTORE_STORE_PASSWORD)
Contraseña de la clave: Elija una contraseña fuerte (necesitará esta como KEYSTORE_KEY_PASSWORD)
Su nombre, organización, etc.: Rellene sus detalles

Notas importantes

Guarde 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á esta como KEYSTORE_KEY_ALIAS
- Contraseña del almacén de claves - necesitarás esta como KEYSTORE_STORE_PASSWORD
- Contraseña de la clave - necesitarás esta como KEYSTORE_KEY_PASSWORD
Realice una copia de seguridad del archivo del almacén de clavesSi lo pierdes, no podrás actualizar tu aplicación publicada
Mantén el secretoNo comitas el archivo del almacén de claves en git
Almacénalo a salvoMantén múltiples copias de seguridad en ubicaciones seguras

Alternativa: Utilice un almacén de claves existente

Si ya publicaste tu aplicación, debes utilizar el mismo almacén de claves que utilizaste inicialmente. Puedes encontrarlo:

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

2. Configura el Servicio de Cuenta de Google Play

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

Paso 2.1: Crea Proyecto de Google Cloud

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

Paso 2.2: Habilita el Desarrollador de Google Play API

En la Consola de Google Cloud, ve a APIs y Servicios → Biblioteca
Busca “Desarrollador de Android de Google Play API”
Haga clic Habilitar

Paso 2.3: Crear cuenta de servicio

Ir a IAM & Administración → Cuentas de servicio
Haga 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
Saltarse 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 Pestaña de Claves Haga clic
Agregar Clave Ahora → Crear nueva clave
Elegir JSON formato de JSON
Haga clic Crear
Un archivo JSON descargará - guárdelo de manera segura,lo necesitarás más tarde

Paso 2.5: Otorgar acceso en Play Console

Ir a Consola de Google Play
Ir a Configuración → API acceso
Bajo Cuentas de servicio, haz clic Otorgar acceso para tu cuenta de servicio
En la pestaña Permisos de la aplicación agrega tu aplicación
En la Permisos de cuenta pestaña, otorgar 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 Invitar a usuario
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. Configuración de 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. Configuración de GitHub Secrets

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

Paso 4.1: Acceder a GitHub Secrets

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

Paso 4.2: Agregar secretos requeridos

Agrega cada uno de estos secretos uno a la vez:

PLAY_CONFIG_JSON

Toma 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

Crea un nuevo secreto llamado PLAY_CONFIG_JSON y pega la cadena base64

ARCHIVO_KEYSTORE_ANDROID

Convierta 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

Cree un nuevo secreto llamado ANDROID_KEYSTORE_FILE y pegue la cadena base64

ALIAS_DE_LA_CLAVE_KEYSTORE

Cree un nuevo secreto con el alias de clave que utilizó al generar el archivo keystore (por ejemplo, my-key-alias)

CONTRASEÑA_DE_LA_CLAVE_KEYSTORE

Cree un nuevo secreto con la contraseña de clave que configuró al generar el archivo keystore

CONTRASEÑA_DE_ALMACÉN_KEYSTORE

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

NOMBRE_DE_PAQUETE_DE_DESARROLLADOR

Crea 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

Paso 4.3: Verificar todos los secretos

Asegúrate de tener configurados estos 6 secretos:

✅ CONFIGURACIÓN_DE_JUEGO_JSON
✅ ARCHIVO_DE_KEYSTORE_DE_ANDROID
✅ ALINEACIÓN_DE_CLAVE_DE_KEYSTORE
✅ CONTRASEÑA_DE_CLAVE_DE_KEYSTORE
✅ CONTRASEÑA_DE_ALMACÉN_DE_KEYSTORE
✅ NOMBRE_DE_PAQUETE_DE_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 compila tu aplicación
Fastlane la sube a Google Play beta canal
Tu aplicación se actualiza 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

Guías de Configuración de CI/CD

Crear un Capacitor de compilación automática de iOS con GitHub Actions - Configuración completa de CI/CD de iOS
Crear y liberar automáticamente con GitHub Actions - Tutorial completo de pipeline de CI/CD
Administrar compilaciones de Desarrollo y Producción con GitHub Actions - Gestión de entornos

Plataformas de CI/CD Alternativas

Crear con GitLab CI - Alternativa de Android para GitLab
Crear 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 CI/CD con Capgo - Integrar actualizaciones en vivo en tu pipeline