Compilación automática de IOS con Capacitor y GitHub con certificado

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 For construcción nativa Capacitor. Esta guía de Fastlane se mantiene para los equipos que mantienen pipelines de acciones GitHub existentes, pero los nuevos builds de iOS deben utilizar el Capgo CLI para que no tengas que mantener Fastlane, ejecutores de Xcode, certificados y scripts de carga por tu cuenta.

Capgo Build para CI/CD por Capgo

Saltate la mantenimiento de Fastlane, ejecutor de Xcode, certificado, perfil de provisión y script de carga. Capgo Build Realiza builds nativos firmados de iOS desde tu pipeline de CI/CD existente:

• Funciona con tu pipeline: Desencadena el Capgo Build desde GitHub Actions, GitLab CI, Jenkins o scripts locales después de tu build web y npx cap sync.
• Autenticación desde secretos de CI: Mantén las claves de App Store Connect, certificados, perfiles de provisión, contraseñas y IDs de equipo en tus propios secretos de CI.
• No mantenimiento de ejecutor nativo: Capgo Build proporciona entornos de construcción Apple mantenidos, por lo que no tienes que administrar ejecutores de macOS, imágenes de Xcode o rutas de Fastlane.
• Artículos y presentación: Descargar artefactos firmados para QA o presentar versiones de lanzamiento a través del Capgo CLI.

Precios

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

Configurar Capgo Build en CI/CD

Guía de configuración manual

Aquí está lo que necesita hacer:

Entrega continua para iOS utilizando Fastlane y GitHub Acciones y certificado

Requisitos previos

Antes de continuar con el tutorial:

• Asegúrate de tener instalado Fastlane en tu máquina de desarrollo. instalado Asegúrate de ser miembro del programa de desarrolladores de iOS.
• Información importante sobre el precio

Precio __CAPGO_KEEP_0__ Acción

https://github.com/features/actions

gratuito’hasta la cantidad límite, dependiendo de la máquina elegida. Vamos a utilizar un
macOS macOS Máquina, puedes ver en la captura su precio y límites (precios a la creación del tutorial, pueden sufrir cambios en el futuro)

Una vez advertido de los requisitos y precios, sigamos.

Nota: En el post supongo que tienes la aplicación creada en App Store Connect. La información importante se copiará con Fastlane!

¿Qué aprenderás en el tutorial?

Pasos a seguir en el post

1. Usando App Store Connect API con Fastlane
   • Requisitos:
     • Crear una clave de App Store Connect API
     • Usando una clave de App Store Connect API
2. Copiar archivos de Fastlane
3. Configurar acciones de GitHub

1. Usando App Store Connect API con Fastlane

A partir de febrero de 2021, se requiere autenticación en dos factores o verificación en dos pasos para todos los usuarios para iniciar sesión en App Store Connect. Esta capa adicional de seguridad para su ID de Apple ayuda a asegurarse de que solo usted puede acceder a su cuenta.
Desde Soporte de Apple

Requisitos

Para que Fastlane pueda utilizar App Store Connect API para subir su aplicación, necesita proporcionar los siguientes tres cosas:

1. Identificador del emisor
2. Identificador de clave
3. Archivo de clave o contenido de clave

Obtener una clave de App Store Connect API

Para generar claves, debe tener permiso de administrador en App Store Connect. Si no tiene ese permiso, puede dirigir a la persona relevante a este artículo.

1. Iniciar sesión en App Store Connect.

2. Seleccionar Usuarios y Acceso.

3 — Seleccionar la pestaña de Integración.

4. Haga clic en Generar API clave o en el botón Agregar (+).

5. Ingrese un nombre para la clave. El nombre es solo para su referencia y no forma parte de la clave en sí.

6 — Debajo de Acceso, seleccione el rol para la clave. Los roles que se aplican a las claves son los mismos roles que se aplican a los usuarios de su equipo. Consulte permisos de rol. Recomendamos seleccionar Administrador de Aplicación.

7. Haga clic en Generar.

El acceso de una clave API no puede limitarse a aplicaciones específicas.

El nombre de la nueva clave, el ID de la clave, un enlace de descarga y otra información aparecen en la página.

Puede obtener aquí toda la información necesaria.
<1> Identificador de problema. (APPLE_ISSUER_ID clave secreta)
<2> ID de clave. (APPLE_KEY_ID clave secreta)
Haga clic en "Descargar API Clave" para descargar su API clave privada. El enlace de descarga aparece solo si la clave privada no se ha descargado aún. Apple no almacena una copia de la clave privada. Por lo tanto, solo puede descargarla una vez.

🔴 Almacene su clave privada en un lugar seguro. Nunca debe compartir sus claves, almacenar claves en un code repositorio o incluir claves en el lado del cliente code.

Usando una Clave API de App Store Connect

El archivo de la Clave API (p8 que descargó), la clave ID y la ID del emisor son necesarios para crear el token JWT de autorización. Hay varias formas en que esta información puede ser pasada a Fastlane. Eligió usar la acción nueva de Fastlane app_store_connect_api_keyPuede aprender otras formas en documentación de Fastlane. Muestro este método porque creo que es la forma más fácil de trabajar con la mayoría de las CI allí, donde puede establecer variables de entorno.

Por favor, convierta el archivo p8 que descargó a Base64 y almacénelo como un secreto (APPLE_KEY_CONTENT).

base64 -i APPLE_KEY_CONTENT.p8 | pbcopy

Ahora podemos gestionar App Store Connect con Fastlane utilizando la clave API, ¡genial!

2. Certificados

Abra XCode y vaya a Ajustes > Cuentas > ID de Apple > Equipos y selecciona tu equipo.

Haz clic en Administrar certificados.

Si aún no has creado un certificado, puedes crear un nuevo certificado.

Haz clic en + y seleccionar Distribución de Apple

Luego debes ir a la llave de cadena para descargar el certificado como un .p12 archivo.

Para hacerlo, debes ir a la llave de cadena, cambiar a la llave de cadena de inicio de sesión y luego la pestaña Mis Certificados Mis Certificados Luego puedes seleccionar el certificado que deseas descargar. (Busca por la fecha del certificado).

__CAPGO_KEEP_0__

__CAPGO_KEEP_0__ Exportar.

Elige el formato de archivo Intercambio de información personal (.p12).

Se descargará el certificado como un .p12 archivo.

Por favor, abre el archivo en una terminal y utiliza el siguiente comando para convertirlo a Base64:

base64 -i BUILD_CERTIFICATE.p12 | pbcopy

Esto se convertirá en tu BUILD_CERTIFICATE_BASE64 segredo. También, cuando se te pregunte, por favor proporciona la contraseña del certificado. Esta contraseña será tu P12_PASSWORD segredo.

3. Perfiles de configuración de provisión

Abrir Desarrollador de Apple y seleccionar el equipo adecuado.

Luego cree un nuevo perfil, haciendo clic en +

Y seleccionar App Store Connect.

Luego debe seleccionar la aplicación correcta, ten cuidado, no se puede utilizar wildcard de lo contrario el proceso de firma fallará.

Seleccione el certificado correcto que creó antes (busque la fecha de vencimiento, debe ser el mismo día y mes que hoy) y haga clic en Continuar.

Finalmente ingrese el nombre del perfil y haga clic en Generar.

El nombre se utilizará para identificar el perfil en Fastlane, bajo el valor de APPLE_PROFILE_NAME.

Puedes descargar el perfil como un .mobileprovision archivo.

Por favor, convierte el perfil a Base64 y almacénalo como un secreto (BUILD_PROVISION_PROFILE_BASE64).

base64 -i BUILD_PROVISION_PROFILE.mobileprovision | pbcopy

4. Copiar archivos de Fastlane

Fastlane es una biblioteca de Ruby creada para automatizar tareas comunes de desarrollo móvil. Al utilizar Fastlane, puedes configurar carriles personalizados que agrupan una serie de acciones que realizan tareas que normalmente realizarías utilizando Android Studio. Puedes hacer mucho con Fastlane, pero para los propósitos de este tutorial, utilizaremos solo una docena de acciones básicas.

Crea la carpeta de Fastlane en la raíz de tu proyecto Capacitor/Ionic y agrega el archivo Fastfile allí:

• Carpeta: <project-root>/fastlane/
• Archivo: <project-root>/fastlane/Fastfile

Este es el mismo nivel que package.json, capacitor.config.*, y el ios/ carpeta. No cree esta carpeta dentro de ios/App/.

platform :ios do
  desc 'Export ipa and submit to TestFlight'
  lane :beta do
    keychain_info = { keychain_name: "ios-build-#{Time.now.to_i}.keychain", keychain_password: SecureRandom.uuid }
    
    begin
      setup_signing(keychain_info)
      bump_build_number
      build_app_with_signing(keychain_info)
      submit_to_testflight
    ensure
      cleanup_keychain(keychain_info)
    end
  end

  private_lane :setup_signing do |options|
    create_keychain(
      name: options[:keychain_name],
      password: options[:keychain_password],
      unlock: true,
      timeout: 0,
      lock_when_sleeps: false, 
      add_to_search_list: true
    )
    import_cert(options)
    install_profile
    update_project_settings
  end

  lane :bump_build_number do
		file = File.read('../package.json')
		data_hash = JSON.parse(file)
		api_key = app_store_connect_api_key(
      key_id: ENV['APPLE_KEY_ID'],
      issuer_id: ENV['APPLE_ISSUER_ID'],
      key_content: ENV['APPLE_KEY_CONTENT'],
      is_key_content_base64: true,
      duration: 1200,
      in_house: false
    )
		build_num = app_store_build_number(
      api_key: api_key,
			app_identifier: ENV['BUNDLE_IDENTIFIER'],
			live: false
    )
		build_num = build_num + 1
		UI.message("Bumped build number to #{build_num}")
		increment_build_number(
			build_number: build_num,
			xcodeproj: "./ios/App/App.xcodeproj",
			skip_info_plist: true
		)
	end

  private_lane :import_cert do |options|
    cert_path = "#{Dir.tmpdir}/build_certificate.p12"
    File.write(cert_path, Base64.decode64(ENV['BUILD_CERTIFICATE_BASE64']))
    import_certificate(
      certificate_path: cert_path,
      certificate_password: ENV['P12_PASSWORD'] || "",
      keychain_name: options[:keychain_name],
      keychain_password: options[:keychain_password],
      log_output: true
    )
    File.delete(cert_path)
  end  
  
  private_lane :cleanup_keychain do |options|
    delete_keychain(
      name: options[:keychain_name]
    )
  end  

  private_lane :install_profile do
    profile_path = "#{Dir.tmpdir}/build_pp.mobileprovision"
    File.write(profile_path, Base64.decode64(ENV['BUILD_PROVISION_PROFILE_BASE64']))
    UI.user_error!("Failed to create provisioning profile at #{profile_path}") unless File.exist?(profile_path)
    ENV['PROVISIONING_PROFILE_PATH'] = profile_path
    install_provisioning_profile(path: profile_path)
    File.delete(profile_path)
  end

  private_lane :update_project_settings do
    update_code_signing_settings(
      use_automatic_signing: false,
      path: "./ios/App/App.xcodeproj",
      code_sign_identity: "iPhone Distribution",
      profile_name: ENV['APPLE_PROFILE_NAME'],
      bundle_identifier: ENV['BUNDLE_IDENTIFIER'],
      team_id: ENV['APP_STORE_CONNECT_TEAM_ID']
    )
    update_project_team(
      path: "./ios/App/App.xcodeproj",
      teamid: ENV['APP_STORE_CONNECT_TEAM_ID']
    )
  end

  private_lane :build_app_with_signing do |options|
    unlock_keychain(
      path: options[:keychain_name],
      password: options[:keychain_password],
      set_default: false
    )
    build_app(
      workspace: "./ios/App/App.xcworkspace",
      scheme: "App",
      configuration: "Release",
      export_method: "app-store",
      output_name: "App.ipa",
      export_options: {
        provisioningProfiles: {
          ENV['BUNDLE_IDENTIFIER'] => ENV['APPLE_PROFILE_NAME']
        }
      },
      xcargs: "-verbose",
      buildlog_path: "./build_logs",
      export_xcargs: "-allowProvisioningUpdates",
    )
  end   

  private_lane :submit_to_testflight do
    api_key = app_store_connect_api_key(
      key_id: ENV['APPLE_KEY_ID'],
      issuer_id: ENV['APPLE_ISSUER_ID'],
      key_content: ENV['APPLE_KEY_CONTENT'],
      is_key_content_base64: true,
      duration: 1200,
      in_house: false
    )
    pilot(
      api_key: api_key,
      skip_waiting_for_build_processing: true,
      skip_submission: true,
      distribute_external: false,
      notify_external_testers: false,
      ipa: "./App.ipa"
    )
  end
end

5. Configuración de secretos

GitHub Acciones utiliza los secretos de repositorio que configuras en el siguiente paso. Solo necesitas un archivo local .env si deseas ejecutar o probar Fastlane desde tu propia máquina.

Para pruebas locales, crea <project-root>/fastlane/.env al lado de Fastfile. No comites este archivo. Agrega fastlane/.env a tu .gitignore primero (o verifica que ya esté ignorado). Aquí tienes un ejemplo:

APP_STORE_CONNECT_TEAM_ID=UVTJ336J2D
BUNDLE_IDENTIFIER=ee.forgr.testfastlane
# See previous section for these secrets
BUILD_CERTIFICATE_BASE64=
BUILD_PROVISION_PROFILE_BASE64=
APPLE_KEY_ID=
APPLE_ISSUER_ID=
APPLE_KEY_CONTENT=
P12_PASSWORD=
APPLE_PROFILE_NAME=

Obteniendo la APP_STORE_CONNECT_TEAM_ID

Ir a Centro de Desarrolladores y desplázate hacia abajo hasta la Membership details sección. Team ID es el valor que debes establecer en el APP_STORE_CONNECT_TEAM_ID secret.

Obtener el BUNDLE_IDENTIFIER

1. Abrir Xcode
2. Haz doble clic en el App en el navegador de proyectos
3. Luego haz clic en la pestaña Signing and Capabilities
4. Copie el valor de la Bundle identifierEsto es el valor que debes establecer en la BUNDLE_IDENTIFIER clave secreta.

6. Procesamiento de

En GitHub Acciones, se facturan minutos según los minutos que has utilizado para ejecutar tu flujo de trabajo de CI/CD. A partir de mi experiencia, lleva aproximadamente 10-15 minutos antes de que un proceso pueda ser procesado en App Store Connect. Para proyectos privados, el costo estimado por construcción puede llegar a

$0,08/min x 15 min = $1,2 , o más, dependiendo de la configuración y dependencias de tu proyecto.Si estás preocupado por los costos para proyectos privados, puedes configurar

los ajustes de costo skip_waiting_for_build_processing a true. Esto ahorrará minutos de compilación esperando a que App Store Connect termine de procesar la compilación.

Sin embargo, hay un tradeoff - deberás actualizar manualmente la información de cumplimiento de tu aplicación en App Store Connect antes de poder distribuir la compilación a los usuarios.

This optimization is mainly useful for private projects where build minutes cost money. For public/free projects, the build minutes are free so there’s no need to enable this setting. See GitHub’s Para proyectos públicos/gratuitos, los minutos de compilación son gratuitos, por lo que no hay necesidad de habilitar esta configuración. Consulte la página de precios de __CAPGO_KEEP_0__ para obtener más detalles.

7. Configuración de GitHub Actions

Configuración de GitHub secrets

Por favor, copia los secretos del archivo y pégalos en los secretos de la __CAPGO_KEEP_0__ repository. .env file and paste them into the GitHub repository secrets.

Configuración Settings > Secretos y variables > Acciones > Nuevo secreto de repositorio

2. BUILD_CERTIFICATE_BASE64 - Certificado codificado en Base64.

3. BUILD_PROVISION_PROFILE_BASE64 - Perfil de provisión codificado en Base64.

4. BUNDLE_IDENTIFIER - Identificador de paquete de tu aplicación.

5. APPLE_KEY_ID — Clave de App Store Connect API 🔺ID de clave.

6. APPLE_ISSUER_ID — Clave de App Store Connect API 🔺ID de emisor.

7. APPLE_KEY_CONTENT — Configuración de la Tienda de Mac API Clave 🔺 Contenido de la Clave .p8, revisa esto

8. Configura el archivo de flujo de trabajo GitHub

Crea un directorio de flujo de trabajo GitHub.

cd .github/workflows

Dentro del workflow directorio, crea un archivo llamado build-upload-ios.ymly agrega lo siguiente.

name: Build source code on ios

on:
  push:
    tags:
      - '*'

jobs:
  build_ios:
    runs-on: macOS-latest
    steps:
      - uses: actions/checkout@v6
      - name: Set Node.js
        uses: actions/setup-node@v6
        with:
          node-version: 24
          cache: npm
      - name: Install dependencies
        id: install_code
        run: npm ci
      - name: Build
        id: build_code
        run: npm run build
      - uses: actions/cache@v5
        with:
          path: ios/App/Pods
          key: ${{ runner.os }}-pods-${{ hashFiles('**/Podfile.lock') }}
          restore-keys: |
            ${{ runner.os }}-pods-
      - name: Sync
        id: sync_code
        run: npx cap sync
      - uses: ruby/setup-ruby@v1
        with:
          ruby-version: '3.0'
          bundler-cache: true
      - uses: maierj/fastlane-action@v3.1.0
        env:
          APP_STORE_CONNECT_TEAM_ID: ${{ secrets.APP_STORE_CONNECT_TEAM_ID }}
          BUNDLE_IDENTIFIER: ${{ secrets.BUNDLE_IDENTIFIER }}
          BUILD_CERTIFICATE_BASE64: ${{ secrets.BUILD_CERTIFICATE_BASE64 }}
          BUILD_PROVISION_PROFILE_BASE64: ${{ secrets.BUILD_PROVISION_PROFILE_BASE64 }}
          APPLE_KEY_ID: ${{ secrets.APPLE_KEY_ID }}
          APPLE_ISSUER_ID: ${{ secrets.APPLE_ISSUER_ID }}
          APPLE_KEY_CONTENT: ${{ secrets.APPLE_KEY_CONTENT }}
          P12_PASSWORD: ${{ secrets.P12_PASSWORD }}
          APPLE_PROFILE_NAME: ${{ secrets.APPLE_PROFILE_NAME }}
        with:
          lane: ios beta
      - name: Upload release bundle
        uses: actions/upload-artifact@v6
        with:
          name: ios-release
          path: ./App.ipa
          retention-days: 10

Este flujo de trabajo debe ser desencadenado después de cada GitHub etiqueta, si necesitas automatizar la etiqueta, consulta Compilación y lanzamiento automático con acciones de GitHub primero.

Luego, este flujo de trabajo extraerá tus dependencias de NodeJS, las instalará y construirá tu aplicación de JavaScript.

Cada vez que envíes un nuevo commit, se construirá una versión de prueba en TestFlight.

Tu aplicación no necesita utilizar Ionic, solo es necesario el Capacitor base, puede tener un módulo de Cordova antiguo, pero el plugin de JavaScript Capacitor se recomienda.

8. Desencadena el flujo de trabajo

Crear un Commit

Haz un commitque deberías ver el flujo de trabajo activo en el repositorio.

Desencadena el flujo de trabajo

Pushe los nuevos commits a la rama main o development para desencadenar el flujo de trabajo.

Después de unos minutos, el build debería estar disponible en tu panel de control de App Store Connect.

9. ¿Puedo desplegar desde la máquina local?

Sí, puedes, y es sencillo.

Puedes utilizar Xcode para compilar y firmar tu aplicación, como siempre.

Artículos relacionados

Guías de configuración de CI/CD

• Compilación automática de Android con Capacitor y GitHub Actions - Configuración de CI/CD de Android completa
• Compilación y liberación automáticas con GitHub Actions - Tutorial completo de pipeline de CI/CD
• Administrar construcciones de Dev y Prod con GitHub Acciones - Gestión de entornos
• Construcción automática de Capacitor iOS con Match - Alternativa utilizando Fastlane Match

Alternativas de plataformas de CI/CD

• Construir con GitLab CI - Alternativa de GitLab
• Construir 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

Gracias

Este blog se basa en los siguientes artículos:

• Entrega continua para IOS utilizando Fastlane y GitHub acciones
• Documentación de Fastlane
• Este GitHub mensaje de @mrogunlana
• Esta GitHub documentación

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

Si estás utilizando Construcción automática de IOS de Capacitor con GitHub acciones con certificado planificar la automatización de CI/CD, conectarla con Capgo automatización de CI/CD para el flujo de trabajo del producto en Capgo automatización de 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 para el detalle de implementación en GitHub integración de acciones