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

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

Recomendado para Nuevas Compilaciones: Utiliza 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 builds de iOS deben utilizar el Capgo CLI para que no tengas que mantener Fastlane, ejecutores de Xcode, certificados y scripts de carga tú mismo.

Requisitos previos

Antes de empezar, necesitarás configurar:

• Una cuenta de GitHub con acceso administrativo
• Miembro del programa de desarrolladores de iOS
• Acceso a API de App Store Connect 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
• Certificados y perfiles de provisión adecuados

Configuración profesional de CI/CD por Capgo

Evita la complejidad. Capgo configura directamente tu pipeline CI/CD en tu 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 tu proceso actual
• Configuración personalizada: Configuración personalizada que se adapta a las necesidades de tu proyecto
• Guía experta: 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 la solución propietaria de Otros: $6,000/año
• Ahorre $26,100 en 5 años

Configuración de CI/CD Ahora

Guía de configuración manual

Si todavía quieres configurar todo tú mismo, aquí está lo que necesitas 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 instalado en su máquina de desarrollo.
• Asegúrese de ser parte del programa de membresía de desarrollador de iOS.

Información importante sobre el precio

https://github.com/características/acciones

El servicio es ‘gratuito’ hasta la cantidad límite, dependiendo de la máquina elegida.
Vamos a utilizar una máquina macOS, puede ver en la captura de pantalla su precio y límites (precios a la creación del tutorial, podrían sufrir cambios en el futuro) Una vez advertido de los requisitos y precios, continuemos.

on your development machine.

Nota: En el post supongo que tienes la aplicación creada en App Store Connect. La información importante se copiará mediante 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 tu ID de Apple ayuda a asegurarte de que eres la única persona que puede acceder a tu 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. ID de 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 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 misma.

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 rolRecomendamos que seleccione Administrador de aplicaciones.

7. Haga clic en Generar.

No se puede limitar el acceso a una clave API a aplicaciones específicas.

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

Puede obtener aquí la información necesaria para las tres claves.
<1> ID de la cuestión. (APPLE_ISSUER_ID secreto)
<2> ID de la clave. (APPLE_KEY_ID secreto)
<3> Haga clic en “Descargar clave API” para descargar su clave privada API. 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, almacene claves en un repositorio code o incluya claves en el lado del cliente code.

Usando una clave de App Store Connect API

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

Por favor, convierte el archivo p8 que descargas a Base64 y almacénalo 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

Abre XCode y ve 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 selecciona Distribución de Apple

Luego debes ir a la caja de llaves para descargar el certificado como un .p12 archivo.

Para hacerlo, debes ir a la caja de llaves, cambiar a la pestaña de __CAPGO_KEEP_0__ la caja de llaves y luego la pestaña Mis Certificados.

Luego puedes seleccionar el certificado que deseas descargar. (Busca por la fecha del certificado)

Y luego haz clic derecho en la clave privada del certificado y selecciona Exportar.

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

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

3. Perfiles de configuración

Abrir Desarrollador de Apple y selecciona el equipo correcto.

Luego crea un nuevo perfil, haciendo clic en +

Y selecciona Conectar con App Store.

Luego debes seleccionar la aplicación correcta, ten cuidado, no puedes utilizar un wildcard 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 Genera.

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

Puedes descargar el perfil como un archivo. .mobileprovision file

Por favor, convierta el perfil a Base64 y almacénelo 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

Create the Fastlane folder at the root of your Capacitor/Ionic project and add the Fastfile there:

• personalizados que agrupan una serie de <project-root>/fastlane/
• acciones <project-root>/fastlane/Fastfile

que realizan tareas que normalmente realizarías utilizando Android Studio. Puedes hacer mucho con Fastlane, pero para los fines de este tutorial, utilizaremos solo una pequeña cantidad de acciones básicas. package.json, capacitor.config.*Crea el folder de Fastlane en la raíz de tu proyecto __CAPGO_KEEP_0__/Ionic y agrega el Fastfile allí: ios/ Carpeta: 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

Archivo:

Este es el mismo nivel que la carpeta " y el folder. No lo crees dentro de "5. Configurando secretos" GitHub Acciones utiliza los secretos de repositorio que configuras en el siguiente paso. Solo necesitas una configuración local .env Si deseas ejecutar o probar Fastlane desde tu propia máquina.

Para pruebas locales, crea <project-root>/fastlane/.env al lado de FastfileNo 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 APP_STORE_CONNECT_TEAM_ID

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

Obteniendo el identificador del paquete

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. Copia el valor del Bundle identifierEste es el valor que debes establecer en el BUNDLE_IDENTIFIER secret.

6. Procesamiento de compilación

En GitHub Acciones, se le facturan minutos según los minutos que ha utilizado para ejecutar su flujo de trabajo de CI/CD. A partir de mi experiencia, tarda unos 10-15 minutos antes de que se pueda procesar una compilación en App Store Connect. Para proyectos privados, el costo estimado por compilación puede llegar a

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

para ahorrar minutos de compilación no esperando a que App Store Connect termine procesando la compilación. skip_waiting_for_build_processing Sin embargo, hay un tradeoff - tendrá que actualizar manualmente la información de cumplimiento de su aplicación en App Store Connect antes de poder distribuir la compilación a los usuarios. trueEsta 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. Consulte la página de precios de __CAPGO_KEEP_0__

https://__CAPGO_KEEP_0__.com/pricing

https://GitHub.com https://__CAPGO_KEEP_0__.com para obtener más detalles.

7. Configura GitHub Acciones

Configura GitHub secretos

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

Configuración Secretos y variables > Acciones > Nuevo secreto de repositorio > __CAPGO_KEEP_0__-secretos

2. BUILD_CERTIFICATE_BASE64 7. Setup __CAPGO_KEEP_0__ Acciones

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 carpeta, 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 etiquetaSi necesita automatizar etiquetas, consulte Construcción y lanzamiento automático con GitHub acciones primero.

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

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

Su aplicación no necesita utilizar Ionic, solo es obligatorio el Capacitor base, puede tener módulos de Cordova antiguos, pero se recomienda utilizar el Capacitor plugin de JavaScript.

8. Desencadene el flujo de trabajo

Crear un commit

Hacer un commit 8. Disparar el flujo de trabajo, deberías ver el flujo de trabajo activo en el repositorio.

Activar el flujo de trabajo

Pushe los nuevos commits a la rama main o development para activar 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

• Crear automáticamente un paquete de Android con Capacitor utilizando GitHub - Configuración completa de CI/CD para Android
• Crear y liberar automáticamente con GitHub - Tutorial completo de pipeline de CI/CD
• Administrar paquetes de desarrollo y producción con GitHub - Gestión de entornos
• Crear automáticamente un paquete de iOS con Capacitor - Alternativa utilizando Fastlane Match

Plataformas de CI/CD Alternativas

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

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