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

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

Recomendado para Nuevas Construcciones: Utilice Capgo Build

Ahora recomendamos utilizar Capgo Build con el Capgo CLI para construcciones nativas Capacitor. Esta guía de Fastlane se mantiene para equipos que mantienen existentes pipelines de acciones de GitHub, pero nuevos builds de iOS deberían utilizar el Capgo CLI para que no tengas que mantener Fastlane, ejecutores de Xcode, certificados y scripts de carga.

Capgo Build para CI/CD por Capgo

Saltate la configuración de Fastlane, ejecutor de Xcode, certificado, perfil de provisión y script de carga. Capgo Build ejecuta construcciones nativas firmadas de iOS desde tu pipeline de CI/CD existente:

• Funciona con tu pipeline: Disparar Capgo Build desde GitHub Actions, GitLab CI, Jenkins o scripts locales después de tu construcción web y npx cap sync.
• Autenticación desde secretos de CI: Mantén las llaves de App Store Connect, certificados, perfiles de configuración 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 compilació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: Descarga artefactos firmados para QA o presenta versiones de lanzamiento a través de los Capgo CLI.

Precio

• Los planes de Capgo comienzan en $12/mes
• Include 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:

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. Asegúrate de ser parte del programa de membresía de desarrollador de iOS.
• Información importante sobre el precio

Precio __CAPGO_KEEP_0__ Acción

https://github.com/features/actions

El servicio es ‘gratuito hasta el límite, dependiendo de la máquina elegida.
Vamos a utilizar una máquina de macOS máquina de macOS, puedes ver en la captura de pantalla su precio y límites (precios a la creación del tutorial, pueden sufrir cambios en el futuro)

Una vez advertidos de los requisitos y precios, sigamos.

Nota: En el post supongo que ya 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. ID 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 Acceso a App Store Connect.

2. Seleccionar Usuarios y acceso.

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

4. Haga clic en Generar clave de API 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. Se recomienda seleccionar Administrador de aplicaciones.

7. Haga clic en Generar.

La accesibilidad de una clave API no puede limitarse a aplicaciones específicas.

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

Puede obtener aquí todas las tres información necesarias.
ID de la cuestión. (APPLE_ISSUER_ID ID de la clave. (
Haga clic en “Descargar __CAPGO_KEEP_0__ Clave” para descargar su __CAPGO_KEEP_1__ clave privada. El enlace de descarga aparece solo si la clave privada no se ha descargado aún. Apple no conserva una copia de la clave privada. Por lo tanto, solo puede descargarla una vez.APPLE_KEY_ID Almacene su clave privada en un lugar seguro. Nunca debe compartir sus claves, almacene claves en un __CAPGO_KEEP_0__ repositorio, o incluya claves en el lado del cliente __CAPGO_KEEP_1__.
<3> Click “Download API Key” to download your API private key. The download link appears only if the private key has not yet been downloaded. Apple does not keep a copy of the private key. So, you can download it only once.

🔴 Store your private key in a safe place. You should never share your keys, store keys in a code repository, or include keys in client-side code.

Using an App Store Connect API Key

The API Key file (p8 file that you download), the key ID, and the issuer ID are required in order to create the JWT token for authorization. There are multiple ways that this information can be passed into Fastlane. I chose to use the Fastlane’s new action app_store_connect_api_key. 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 (Por favor, convierta el archivo p8 que descargó a Base64 y almacénelo como un secreto (

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 administrar App Store Connect con Fastlane utilizando la clave API, ¡genial!

2. Certificados

Abra XCode y vaya a Configuración > Cuentas > ID de Apple > Equipos y seleccione su equipo.

Haga clic en Administrar certificados.

Si aún no ha creado un certificado, puede crear un nuevo certificado.

Haga clic en + y seleccione Distribución de Apple

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

Para hacerlo, necesitará ir a la llave de cadena, cambiar a la llave de cadena de inicios de sesión y luego la pestaña Mis Certificados.

Luego, puede seleccionar el certificado que desee descargar. (Busque por la fecha del certificado)

Y luego haz clic derecho en la clave privada en el certificado y selecciona __CAPGO_KEEP_0__.

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

Eso 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

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

3. Perfiles de configuración

Abrir Desarrollador de Apple y selecciona el equipo correcto.

Luego crea un nuevo perfil, haciendo clic en +

Y selecciona App Store Connect.

Luego debes seleccionar la aplicación correcta, ten cuidado, no puedes usar comodines de lo contrario la firma fallará.

Selecciona el certificado correcto que creaste antes (busca la fecha de vencimiento, debe ser el mismo día y mes que hoy) y haz clic en Continúa.

Finalmente ingresa el nombre del perfil y haz 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. Utilizando 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 pequeña cantidad de acciones básicas.

Crear el folder de Fastlane en la raíz de tu proyecto Capacitor/Ionic y agregar el Fastfile allí:

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

Este es el mismo nivel que package.json, capacitor.config.*, y el ios/ carpeta. No cree este archivo 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 del 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=

Obtener el ID DE EQUIPO DE CONEXIÓN A LA TIENDA DE APLICACIONES

Vaya a Centro de Desarrolladores y desplácese hacia abajo hasta la Membership details sección. Team ID Es el valor que necesita establecer en el APP_STORE_CONNECT_TEAM_ID secret.

Obtener el IDENTIFICADOR DE PAQUETE

1. Abra Xcode
2. Haga doble clic en el App en el navegador de proyectos
3. Luego haz clic en la pestaña Signing and Capabilities
4. Copiar el valor de la Bundle identifier. Este es el valor que debes establecer en el BUNDLE_IDENTIFIER secret.

6. Procesamiento de

En GitHub Acciones, se te facturará según los minutos que hayas utilizado para ejecutar tu flujo de trabajo CI/CD. De mi experiencia, tarda aproximadamente 10–15 minutos antes de que un build pueda ser procesado en App Store Connect.

Para proyectos privados, el costo estimado por build puede llegar a $0.08/min x 15 mins = $1.2, o más, dependiendo de la configuración y dependencias de tu proyecto.

If estás preocupado por los costos para proyectos privados, puedes establecer skip_waiting_for_build_processing a true. Esto ahorrará minutos de compilación no esperando a que App Store Connect termine procesando la compilación.

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

Esta optimización es principalmente útil para proyectos privados donde los minutos de compilación cuestan dinero. Para proyectos públicos/gratuitos, los minutos de compilación son gratuitos, por lo que no hay necesidad de habilitar esta configuración. Consulta la página de precios de GitHub para obtener más detalles. 7. Configura __CAPGO_KEEP_0__ Acciones

Configura secretos de GitHub

Configure GitHub secrets

archivo y pégalos en los secretos de la .env repositorio de GitHub.

Ve a Configuración > 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 🔺 Identificador de clave.

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

7. APPLE_KEY_CONTENT — Clave de App Store Connect API 🔺 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 debería ser desencadenado después de cada GitHub etiqueta, si necesitas automatizar la etiqueta, consulta Automatización de compilación y lanzamiento con acciones GitHub en primer lugar.

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

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

Your App doesn’t need to use Ionic, only Capacitor base is mandatory., it can have old Cordova module, but Capacitor JS plugin should be preferred.

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.

After 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 hacerlo y es muy sencillo.

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

Artículos relacionados

Guías de configuración de CI/CD

• Capacitor construcción automática de Android con GitHub acciones - Configuración completa de CI/CD de Android
• Construcción y liberación automáticas con GitHub acciones - Tutorial completo de pipeline de CI/CD
• Gestión de construcciones de Dev y Prod con GitHub acciones - Gestión de entorno
• Automatic Capacitor iOS Build with Match - Alternativa utilizando Fastlane Match

Plataformas de CI/CD alternativas

• Compilar con GitLab CI - Alternativa de GitLab
• Compilar con CodeMagic - Guía de configuración de CodeMagic

Actualizaciones en vivo y despliegue

• Documentación de actualizaciones en vivo de Capgo - Agregar actualizaciones OTA a tu aplicación
• Integración de 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 acciones de GitHub
• Documentación de Fastlane
• Este mensaje de GitHub de @mrogunlana
• Esta documentación de GitHub

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

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